Looking for more Ruby-like way to create an array


#1

I’m creating an array that is the result of the members of another array
each multiplied by 100. Here’s what I have:

converted_array = []
original_array.each {|line| converted_array << line.to_f * 100}

This works, but I’m wondering if there is a more idiomatically “Ruby”
way of doing it.


#2

Steve N. wrote:

I’m creating an array that is the result of the members of another array
each multiplied by 100. Here’s what I have:

converted_array = []
original_array.each {|line| converted_array << line.to_f * 100}

This works, but I’m wondering if there is a more idiomatically “Ruby”
way of doing it.

Try map

converted_array = orginal_array.map {|line| line.to_f * 100 }


#3

2008/10/8 Steve N. removed_email_address@domain.invalid:

I’m creating an array that is the result of the members of another array
each multiplied by 100. Here’s what I have:

converted_array = []
original_array.each {|line| converted_array << line.to_f * 100}

This works, but I’m wondering if there is a more idiomatically “Ruby”
way of doing it.

converted_array = original_array.map{|item| item.to_f * 100}

Regards,
Rimantas


#4

a=[1,2,3]
a.map (|item| 100*item}

— On Tue, 10/7/08, Steve N. removed_email_address@domain.invalid wrote:

From: Steve N. removed_email_address@domain.invalid
Subject: Looking for more Ruby-like way to create an array
To: “ruby-talk ML” removed_email_address@domain.invalid
Date: Tuesday, October 7, 2008, 5:33 PM

I’m creating an array that is the result of the members of another array
each multiplied by 100. Here’s what I have:

converted_array = []
original_array.each {|line| converted_array << line.to_f * 100}

This works, but I’m wondering if there is a more idiomatically
“Ruby”
way of doing it.


#5

Tim H. wrote:

Try map

converted_array = orginal_array.map {|line| line.to_f * 100 }

Thanks, Tim, Rimantas, and Dan for the unanimous advice. I will study up
on map.


#6

On Oct 7, 4:33 pm, Steve N. removed_email_address@domain.invalid wrote:

I’m creating an array that is the result of the members of another array
each multiplied by 100. Here’s what I have:

converted_array = []
original_array.each {|line| converted_array << line.to_f * 100}

This works, but I’m wondering if there is a more idiomatically “Ruby”
way of doing it.

Posted viahttp://www.ruby-forum.com/.

irb(main):001:0> a = 2,3,5,8
=> [2, 3, 5, 8]
irb(main):002:0> a.map!{|n| n*10 }
=> [20, 30, 50, 80]
irb(main):003:0> a
=> [20, 30, 50, 80]


#7

Hi –

On Wed, 8 Oct 2008, William J. wrote:

Posted viahttp://www.ruby-forum.com/.

irb(main):001:0> a = 2,3,5,8
=> [2, 3, 5, 8]
irb(main):002:0> a.map!{|n| n*10 }
=> [20, 30, 50, 80]
irb(main):003:0> a
=> [20, 30, 50, 80]

That’s a little different, since it leaves you without the original
array (which may in fact be OK, but is an important difference).

David


#8

converted_array = original_array.inject([]) {|a, line| a << (line.to_f *
100)}


#9

Hi –

On Wed, 8 Oct 2008, Bilyk, Alex wrote:

converted_array = original_array.inject([]) {|a, line| a << (line.to_f * 100)}

I’d definitely favor map over inject for this. It’s much more
straightforward for this particular operation.

David


#10

2008/10/8 David A. Black removed_email_address@domain.invalid:

On Wed, 8 Oct 2008, Bilyk, Alex wrote:

converted_array = original_array.inject([]) {|a, line| a << (line.to_f *
100)}

I’d definitely favor map over inject for this. It’s much more
straightforward for this particular operation.

Absolutely agree!

robert


#11

I agree with David. I did a simple benchmarking test and you can already
see a difference with an array of ten integers:

irb(main):001:0> require ‘benchmark’
=> true
irb(main):002:0> a = [1,2,3,4,5,6,7,8,9,10]
=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
irb(main):003:0> Benchmark.bm do |b|
irb(main):004:1* b.report { new_array = a.inject([]) { |array,item|
array << item * 100 } }
irb(main):005:1> end
user system total real
0.000000 0.000000 0.000000 ( 0.000035)
=> true
irb(main):006:0> Benchmark.bm do |b|
irb(main):007:1* b.report { new_array = a.map { |item| item * 100 }
}
irb(main):008:1> end
user system total real
0.000000 0.000000 0.000000 ( 0.000022)
=> true
irb(main):009:0>

But if you up the ante (because how often is it that we deal with an
array of only ten elements?) you get something more like this:

irb(main):009:0> a = (0…250).map
=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72,
73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106,
107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120,
121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134,
135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,
149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162,
163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176,
177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190,
191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204,
205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218,
219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232,
233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246,
247, 248, 249, 250]
irb(main):010:0> Benchmark.bm do |b|
irb(main):011:1* b.report { new_array = a.inject([]) { |array,item|
array << item * 100 } }
irb(main):012:1> end
user system total real
0.000000 0.000000 0.000000 ( 0.000442)
=> true
irb(main):013:0> Benchmark.bm do |b|
irb(main):014:1* b.report { new_array = a.map { |item| item * 100 }
}
irb(main):015:1> end
user system total real
0.000000 0.000000 0.000000 ( 0.000165)
=> true
irb(main):016:0>

So you can see there’s some substantial difference with map. Not to
mention, “map” just looks cleaner and creates an array by default (where
inject can do many different things).

You can get more background on why inject takes longer than map by
reading the documentation:

Map: http://ruby-doc.org/core/classes/Array.html#M002212
Inject: http://ruby-doc.org/core/classes/Enumerable.html#M003160

– Josh
http://iammrjoshua.com

David A. Black wrote:

Hi –

On Wed, 8 Oct 2008, Bilyk, Alex wrote:

converted_array = original_array.inject([]) {|a, line| a << (line.to_f * 100)}

I’d definitely favor map over inject for this. It’s much more
straightforward for this particular operation.

David