Briefest method of generating a list of random numbers?

ruby-talk
1

Hi all,

I wondered if there was a more compact method of generating things like
a random string, or a random list of numbers than I'm using now (using
ruby 1.9.0-1)

  array = [] ; 100.times {array << rand}
  string = "" ; 100.times {string << (rand(26) + 97).chr}

The temptation is to use

  array = [rand] * 100
  string = (rand(26) + 97).chr * 100

but that only draws one random number a 100 times.

Is there a bit of syntax that I missed?

···

--
Posted via http://www.ruby-forum.com/.

2

Array(100) { rand }

The block is evaluated for each element.

···

On May 26, 2008, at 10:45, Boris Schmid wrote:

Hi all,

I wondered if there was a more compact method of generating things like
a random string, or a random list of numbers than I'm using now (using
ruby 1.9.0-1)

--
Mikael Høilund

3

-------- Original-Nachricht --------

Datum: Mon, 26 May 2008 17:45:57 +0900
Von: Boris Schmid <boris@bagofsouls.com>
An: ruby-talk@ruby-lang.org
Betreff: briefest method of generating a list of random numbers?

Hi all,

I wondered if there was a more compact method of generating things like
a random string, or a random list of numbers than I'm using now (using
ruby 1.9.0-1)

  array = ; 100.times {array << rand}
  string = "" ; 100.times {string << (rand(26) + 97).chr}

The temptation is to use

  array = [rand] * 100
  string = (rand(26) + 97).chr * 100

but that only draws one random number a 100 times.

Is there a bit of syntax that I missed?
--
Posted via http://www.ruby-forum.com/\.

Hello Boris,

  string = (rand(26) + 97).chr * 100

but that only draws one random number a 100 times.

That's not correct - it draws a random number once, turns it into
a letter and then repeats it 100 times -

you could also write, e.g.,

string='x'*100 .

But what's wrong with the first - it looks fairly compact to me:

string = "" ; 100.times { string << (rand(26) + 97).chr}

You could add a srand(); in the bracket to call different
strings every time, but that's less compact :slight_smile:

Best regards,

Axel

···

--
Psssst! Schon vom neuen GMX MultiMessenger gehört?
Der kann`s mit allen: http://www.gmx.net/de/go/multimessenger

4

Boris Schmid wrote:

Hi all,

I wondered if there was a more compact method of generating things like
a random string, or a random list of numbers than I'm using now (using
ruby 1.9.0-1)

("a".."z").sort_by {rand}.join

this is not really the same, maybe
(("a".."z").to_a * N).sort_by { rand }[0..x].join
does what OP wants (if N is large enough) and although this approach
has a certain elegance it would be very,very inefficent.

Cheers
R.

···

On Mon, May 26, 2008 at 12:39 PM, S2 <non.sto.gioando@nien.te> wrote:

--
http://ruby-smalltalk.blogspot.com/

---
Whereof one cannot speak, thereof one must be silent.
Ludwig Wittgenstein

5

But what's wrong with the first - it looks fairly compact to me:

string = "" ; 100.times { string << (rand(26) + 97).chr}

For strings I'll have to use the one above, but arrays now read a bit
more natural (to my eyes). The size doesn't matter that much, but it is
simpler to understand.

  population = Array.new(POP_SIZE) {
function_that_generates_a_random_individual }

vs the old

  population = ; POP_SIZE.times {population <<
function_that_generates_a_random_individual }

Thanks both of you!

···

--
Posted via http://www.ruby-forum.com/\.

6

Don't you mean

   Array.new(100) { rand }

Array(arg) creates an array equal to 'arg' (if it responds to .to_ary)
or an array containing precisly 'arg' otherwise. It never yields.

There is also

   (1..100).map { rand }

And for strings

   (1..100).map { (rand(26)+97).chr }.join

Lars

···

On May 26, 11:16 am, Mikael Høilund <mik...@hoilund.org> wrote:

On May 26, 2008, at 10:45, Boris Schmid wrote:

> Hi all,

> I wondered if there was a more compact method of generating things
> like
> a random string, or a random list of numbers than I'm using now (using
> ruby 1.9.0-1)

Array(100) { rand }

7

Boris Schmid wrote:

string = "" ; 100.times { string << (rand(26) + 97).chr}

For strings I'll have to use the one above,

Duh. I can just use the Array.new, and append a .join at the end to get
the random string. And Axel, I'm generating quite a lot of arrays in my
small prog, and using this shorter way makes it indeed clearer :). It is
definitly worth it.

Example:

   filter = Array.new(WINDOW) { bucket = Array.new(AMINO) {|i| (97 +
i).chr} }

was

   filter =
   WINDOW.times {bucket = ; AMINO.times {|i| bucket << (97 + i).chr}
; filter << bucket}

···

--
Posted via http://www.ruby-forum.com/\.

8

Note that String#<< understands ints as being character codes - so you
do not need the .chr:

irb(main):005:0> str = 100.to_enum(:times).inject("") {|s,| s << (?a +
rand(26))}
=> "uepizlkepyoxxfkefosxxptvcpdiuwyexecngmftnidlyfnhqgmtndbzthhykdjjiyayzwvhatovzbxzqkhclnxwbqbsoxpszwkn"
irb(main):006:0>

I believe in 1.9 you can as well do

str = 100.times.inject("") {|s,| s << (?a + rand(26))}

Kind regards

robert

···

2008/5/26 Boris Schmid <boris@bagofsouls.com>:

But what's wrong with the first - it looks fairly compact to me:

string = "" ; 100.times { string << (rand(26) + 97).chr}

For strings I'll have to use the one above,

--
use.inject do |as, often| as.you_can - without end

9

You could also do

  Array.new(100) { 97 + rand(26) }.pack("c*")

Peter

···

On Mon, May 26, 2008 at 11:34 AM, Boris Schmid <boris@bagofsouls.com> wrote:

But what's wrong with the first - it looks fairly compact to me:

string = "" ; 100.times { string << (rand(26) + 97).chr}

For strings I'll have to use the one above, but arrays now read a bit
more natural (to my eyes). The size doesn't matter that much, but it is
simpler to understand.

10

You could also do

  Array.new(100) { 97 + rand(26) }.pack("c*")

Peter

Pack seems to be faster than the combination of .chr and join, which is
a nice side-effect, as I'm running simulations in ruby, and they takes
aeons of time (well, nearly a week). Don't ask me why I'm using ruby, it
just sort of happened ;), and the code is only 160 lines, which compares
favorably to the C ancestor of this simulation (which did more or less
the same in 4000 lines)

irb(main):017:0> time = Time.new ; 1000.times {string = Array.new(1000)
{ rand(26) + 97 }.pack("c*")} ; puts Time.new - time
0.184389
=> nil
irb(main):018:0> time = Time.new ; 1000.times {string = Array.new(1000)
{ (rand(26) + 97).chr }.join} ; puts Time.new - time
0.330891
=> nil

···

--
Posted via http://www.ruby-forum.com/\.