hi,
was wondering what the prettiest way to do the below would be:
i got a hash
{ ‘1’ => ‘some’, ‘4’ => ‘thing’, ‘6’ => ‘good’ }
and i want to turn it into
{ ‘1’ => {‘name’ => ‘some’}, ‘4’ => {‘name’ => ‘thing’}, ‘6’ =>
{‘name’=>‘good’} }
hash.map{|k, v| {k => {‘name’ => v}}.to_hash
should work.
Not sure if there’s a prettier solution.
Aur
Wait, no.
hash.map{|k, v| k, {‘name’ => v}}.to_hash
This should work.
Or
h = {}
hash.each{|k, v| h.add(k, {‘name’ => ‘v’})
Aur
On 7/16/07, hemant [email protected] wrote:
{ ‘1’ => {‘name’ => ‘some’}, ‘4’ => {‘name’ => ‘thing’}, ‘6’ =>
{‘name’=>‘good’} }Dunno, I can think of a couple of ways:
a.each {|key,value| a[key] = {‘name’ => value}}
Are you allowed to do this?
or
a.inject({}) {|mem,(key,value)| mem[key] = {‘name’ => value}; mem }
Wow, thanks for showing me a new idea.
Aur
On 7/16/07, SonOfLilit [email protected] wrote:
{ ‘1’ => {‘name’ => ‘some’}, ‘4’ => {‘name’ => ‘thing’}, ‘6’ =>
{‘name’=>‘good’} }Dunno, I can think of a couple of ways:
a.each {|key,value| a[key] = {‘name’ => value}}
Are you allowed to do this?
Why not? Seem to work here.
–
Let them talk of their oriental summer climes of everlasting
conservatories; give me the privilege of making my own summer with my
own coals.
On 7/16/07, Shai R. [email protected] wrote:
{‘name’=>‘good’} }
Dunno, I can think of a couple of ways:
a.each {|key,value| a[key] = {‘name’ => value}}
or
a.inject({}) {|mem,(key,value)| mem[key] = {‘name’ => value}; mem }
–
Let them talk of their oriental summer climes of everlasting
conservatories; give me the privilege of making my own summer with my
own coals.
a.each {|key,value| a[key] = {‘name’ => value}}
Are you allowed to do this?
Why not? Seem to work here.
I was taught not to modify a structure I’m #each ing on…
Does this not apply when you only modify substructures of it?
Aur
SonOfLilit wrote:
a.each {|key,value| a[key] = {‘name’ => value}}
Are you allowed to do this?
Why not? Seem to work here.
I was taught not to modify a structure I’m #each ing on…
Does this not apply when you only modify substructures of it?
Aur
I think that only applies for insert/delete. As e.g. with an array it
may happen that elements are left out if you delete them wile iterating,
or that you iterate over a newly create value (which you might not want
to)
Regards
Stefan
On Jul 16, 2007, at 5:58 AM, hemant wrote:
a.inject({}) {|mem,(key,value)| mem[key] = {‘name’ => value}; mem }
I would write that as:
a.inject(Hash.new) { |h, (k, v)| h.merge(k => v) }
James Edward G. II
On 7/16/07, James Edward G. II [email protected] wrote:
But that doesn’t yield what he wanted… You could do
a.inject(Hash.new){|h,(k,v)| h.merge(k => { ‘name’ => value})}
On 7/16/07, Stefan R. [email protected] wrote:
Does this not apply when you only modify substructures of it?
Stefan–
Posted via http://www.ruby-forum.com/.
You just made me ponder a cool thing:
N = 8
(a = [0, 1]).each_index{|n, i| a << a[i-1] + a[i] if i > 0 and i < N
Of course it probably wouldn’t work, but… Cool
Aur
2007/7/16, Chris C. [email protected]:
But that doesn’t yield what he wanted… You could do
a.inject(Hash.new){|h,(k,v)| h.merge(k => { ‘name’ => value})}
Still it’s inefficient because of all the small Hashes that are thrown
away immediately. The solution provided by hemant is better although
not as elegant.
Kind regards
robert
On Jul 16, 2007, at 9:19 AM, Chris C. wrote:
But that doesn’t yield what he wanted… You could do
a.inject(Hash.new){|h,(k,v)| h.merge(k => { ‘name’ => value})}
Right, my bad. Thanks.
I just wanted to get away from using inject() like each().
James Edward G. II
On 7/16/07, SonOfLilit [email protected] wrote:
Wait, no.
hash.map{|k, v| k, {‘name’ => v}}.to_hash
Well that is very nice;), but where does #to_hash come from?? (Facets,
maybe?)
I suppose it should behave like
def to_hash
Hash[*self]
end
Robert
On Jul 16, 2007, at 9:36 AM, Robert K. wrote:
James Edward G. II
But that doesn’t yield what he wanted… You could do
a.inject(Hash.new){|h,(k,v)| h.merge(k => { ‘name’ => value})}Still it’s inefficient because of all the small Hashes that are thrown
away immediately. The solution provided by hemant is better although
not as elegant.
If that bothers you, change merge() to merge!().
James Edward G. II
On 16.07.2007 17:03, James Edward G. II wrote:
a.inject(Hash.new) { |h, (k, v)| h.merge(k => v) }
not as elegant.If that bothers you, change merge() to merge!().
… which doesn’t help because it does not avoid all those one pair
hashes. 
Kind regards
robert
Robert K. schrieb:
James Edward G. II
Kind regardsrobert
Hi,
I also tested a theory of mine, Hash#update does this ~20% faster than
Hash#each:
hash.update(hash) { |key, o_val, n_val| Hash[‘name’ => o_val] }
Thread ID: 101250
Total: 7.24
%self total self wait child calls name
66.16 7.24 4.79 0.00 2.45 1 Hash#update
33.84 2.45 2.45 0.00 0.00 456976 Class::Hash#[]
0.00 7.24 0.00 0.00 7.24 0 Global#[No method]
hash.each { |key, value| hash[key] = Hash[‘name’ => value] }
Thread ID: 101250
Total: 9.28
%self total self wait child calls name
60.78 9.28 5.64 0.00 3.64 1 Hash#each
26.62 2.47 2.47 0.00 0.00 456976 Class::Hash#[]
12.61 1.17 1.17 0.00 0.00 456976 Hash#[]=
0.00 9.28 0.00 0.00 9.28 0 Global#[No method]
As I profiled both cases I came across something I don’t understand:
When I do the profiling of both cases In the same Ruby process the later
one always is slower as when I profile them seperatly, can somebody
explain this?
Regards
Florian
profile_update.rb:
require ‘rubygems’
require ‘ruby-prof’
puts ‘Hash#update’
hash = (‘aaaa’…‘zzzz’).inject Hash.new do |hash, value|
hash[value] = value
hash
end
result = RubyProf.profile do
hash.update(hash) { |key, o_val, n_val| Hash[‘name’ => o_val] }
end
RubyProf::FlatPrinter.new(result).print(STDOUT, 0)
profile_update_first.rb:
require ‘rubygems’
require ‘ruby-prof’
puts ‘Hash#update’
hash = (‘aaaa’…‘zzzz’).inject Hash.new do |hash, value|
hash[value] = value
hash
end
result = RubyProf.profile do
hash.update(hash) { |key, o_val, n_val| Hash[‘name’ => o_val] }
end
RubyProf::FlatPrinter.new(result).print(STDOUT, 0)
puts ‘Hash#each’
hash = (‘aaaa’…‘zzzz’).inject Hash.new do |hash, value|
hash[value] = value
hash
end
result = RubyProf.profile do
hash.each { |key, value| hash[key] = Hash[‘name’ => value] }
end
RubyProf::FlatPrinter.new(result).print(STDOUT, 0)
profile_each.rb:
require ‘rubygems’
require ‘ruby-prof’
puts ‘Hash#each’
hash = (‘aaaa’…‘zzzz’).inject Hash.new do |hash, value|
hash[value] = value
hash
end
result = RubyProf.profile do
hash.each { |key, value| hash[key] = Hash[‘name’ => value] }
end
RubyProf::FlatPrinter.new(result).print(STDOUT, 0)
profile_each_first.rb:
require ‘rubygems’
require ‘ruby-prof’
puts ‘Hash#each’
hash = (‘aaaa’…‘zzzz’).inject Hash.new do |hash, value|
hash[value] = value
hash
end
result = RubyProf.profile do
hash.each { |key, value| hash[key] = Hash[‘name’ => value] }
end
RubyProf::FlatPrinter.new(result).print(STDOUT, 0)
puts ‘Hash#update’
hash = (‘aaaa’…‘zzzz’).inject Hash.new do |hash, value|
hash[value] = value
hash
end
result = RubyProf.profile do
hash.update(hash) { |key, o_val, n_val| Hash[‘name’ => o_val] }
end
RubyProf::FlatPrinter.new(result).print(STDOUT, 0)
On 16.07.2007 17:41, Florian Aßmann wrote:
James Edward G. II
robert
Thread ID: 101250
Total: 9.28
explain this?
I’d guess it’s GC. IMHO for comparing performance Benchmark is a better
tool - especially since you can have a warmup run.
Kind regards
robert
On 7/16/07, SonOfLilit [email protected] wrote:
a.each {|key,value| a[key] = {‘name’ => value}}
Are you allowed to do this?
Why not? Seem to work here.
I was taught not to modify a structure I’m #each ing on…
Does this not apply when you only modify substructures of it?
It doesn’t affect the “spine” of the structure, just the values hanging
off it.
martin
Florian Aßmann wrote:
hash.update(hash) { |key, o_val, n_val| Hash[‘name’ => o_val] }
Hash[foo => bar] is a needless method call. foo => bar is already a hash
literal, Hash::[] creates a new hash from that hash (suprised me a bit
tbh, as I don’t really see a reason for it to do that), though. But
since that’s useless work and method calls weigh heavy in ruby, I’d not
do that.
You can try it if you want:
x = {:a => :b}
Hash[x].equal?(x) #Â => false
Regards
Stefan