Array#choice always produce the same sequence

Discussion in 'Ruby' started by Stefano Crocco, Feb 5, 2009.

  1. I've just stumbled upon a strange behaviour of Array#choice (using ruby 1.8.7-
    p72). As far I understand, an_array.choice should be (almost) the same as
    an_array[rand(an_array.size)]. Thus, the two following pieces of code should
    be equivalent

    a = [1, 2, 3, 4]
    p 10.times.map{a.choice}.join
    p 10.times.map{a[rand(a.size)].join}

    However, this doesn't seem to be the case. In particular, something like:

    ruby -e 'a = [1, 2, 3, 4]; p 10.times.map{a.choice}.join'

    always give the same result, while
     
    Stefano Crocco, Feb 5, 2009
    #1
    1. Advertising

  2. Alle Thursday 05 February 2009, Stefano Crocco ha scritto:
    > I've just stumbled upon a strange behaviour of Array#choice (using ruby
    > 1.8.7- p72). As far I understand, an_array.choice should be (almost) the
    > same as an_array[rand(an_array.size)]. Thus, the two following pieces of
    > code should be equivalent
    >
    > a = [1, 2, 3, 4]
    > p 10.times.map{a.choice}.join
    > p 10.times.map{a[rand(a.size)].join}
    >
    > However, this doesn't seem to be the case. In particular, something like:
    >
    > ruby -e 'a = [1, 2, 3, 4]; p 10.times.map{a.choice}.join'
    >
    > always give the same result, while


    Sorry, hit the "Send" button too soon. Here's the full version

    I've just stumbled upon a strange behaviour of Array#choice (using ruby
    1.8.7- p72). As far I understand, an_array.choice should be (almost) the
    same as an_array[rand(an_array.size)]. Thus, the two following pieces of
    code should be equivalent

    a = [1, 2, 3, 4]
    p 10.times.map{a.choice}.join
    p 10.times.map{a[rand(a.size)]}.join

    However, this doesn't seem to be the case. In particular, something like:

    ruby -e 'a = [1, 2, 3, 4]; p 10.times.map{a.choice}.join'

    always give the same result, while

    ruby -e 'a = [1, 2, 3, 4]; p 10.times.map{a[rand(a.size)]}.join'

    gives a different result every time the command is executed (which, in my
    opinion, is the correct behaviour).

    It seems that to get the correct behaviour from choice, you need to call srand
    before using it. Does anyone know why this is necessary with choice but not
    with rand? Is it the intended behaviour or a bug?

    Thanks

    Stefano
     
    Stefano Crocco, Feb 5, 2009
    #2
    1. Advertising

  3. Hi Stefano,

    it seems to work for me:

    irb(main):003:0> a = [1, 2, 3, 4]
    => [1, 2, 3, 4]
    irb(main):004:0> p 10.times.map{a.choice}.join
    "4414312344"
    => nil
    irb(main):006:0> p 10.times.map{a[rand(a.size)]}.join
    "4342411331"
    => nil
    irb(main):007:0> p 10.times.map{a.choice}.join
    "2333341212"
    => nil
    irb(main):008:0> p 10.times.map{a.choice}.join
    "1312441122"
    => nil
    irb(main):009:0> p 10.times.map{a.choice}.join
    "2412444223"
    => nil
    Z ruby -v
    ruby 1.8.7 (2008-08-11 patchlevel 72) [i486-linux]


    On 05/02/2009, Stefano Crocco <> wrote:
    > Alle Thursday 05 February 2009, Stefano Crocco ha scritto:
    >> I've just stumbled upon a strange behaviour of Array#choice (using ruby
    >> 1.8.7- p72). As far I understand, an_array.choice should be (almost) the
    >> same as an_array[rand(an_array.size)]. Thus, the two following pieces of
    >> code should be equivalent
    >>
    >> a = [1, 2, 3, 4]
    >> p 10.times.map{a.choice}.join
    >> p 10.times.map{a[rand(a.size)].join}
    >>
    >> However, this doesn't seem to be the case. In particular, something like:
    >>
    >> ruby -e 'a = [1, 2, 3, 4]; p 10.times.map{a.choice}.join'
    >>
    >> always give the same result, while

    >
    > Sorry, hit the "Send" button too soon. Here's the full version
    >
    > I've just stumbled upon a strange behaviour of Array#choice (using ruby
    > 1.8.7- p72). As far I understand, an_array.choice should be (almost) the
    > same as an_array[rand(an_array.size)]. Thus, the two following pieces of
    > code should be equivalent
    >
    > a = [1, 2, 3, 4]
    > p 10.times.map{a.choice}.join
    > p 10.times.map{a[rand(a.size)]}.join
    >
    > However, this doesn't seem to be the case. In particular, something like:
    >
    > ruby -e 'a = [1, 2, 3, 4]; p 10.times.map{a.choice}.join'
    >
    > always give the same result, while
    >
    > ruby -e 'a = [1, 2, 3, 4]; p 10.times.map{a[rand(a.size)]}.join'
    >
    > gives a different result every time the command is executed (which, in my
    > opinion, is the correct behaviour).
    >
    > It seems that to get the correct behaviour from choice, you need to call
    > srand
    > before using it. Does anyone know why this is necessary with choice but not
    > with rand? Is it the intended behaviour or a bug?
    >
    > Thanks
    >
    > Stefano
    >
    >
     
    ruud grosmann, Feb 5, 2009
    #3
  4. Alle Thursday 05 February 2009, ruud grosmann ha scritto:

    > > I've just stumbled upon a strange behaviour of Array#choice (using ruby
    > > 1.8.7- p72). As far I understand, an_array.choice should be (almost) the
    > > same as an_array[rand(an_array.size)]. Thus, the two following pieces of
    > > code should be equivalent
    > >
    > > a =3D [1, 2, 3, 4]
    > > p 10.times.map{a.choice}.join
    > > p 10.times.map{a[rand(a.size)]}.join
    > >
    > > However, this doesn't seem to be the case. In particular, something lik=

    e:
    > >
    > > ruby -e 'a =3D [1, 2, 3, 4]; p 10.times.map{a.choice}.join'
    > >
    > > always give the same result, while
    > >
    > > ruby -e 'a =3D [1, 2, 3, 4]; p 10.times.map{a[rand(a.size)]}.join'
    > >
    > > gives a different result every time the command is executed (which, in =

    my
    > > opinion, is the correct behaviour).
    > >
    > > It seems that to get the correct behaviour from choice, you need to call
    > > srand
    > > before using it. Does anyone know why this is necessary with choice but
    > > not with rand? Is it the intended behaviour or a bug?
    > >
    > > Thanks
    > >
    > > Stefano


    >Hi Stefano,
    >
    >it seems to work for me:
    >
    >irb(main):003:0> a =3D [1, 2, 3, 4]
    >=3D> [1, 2, 3, 4]
    >irb(main):004:0> p 10.times.map{a.choice}.join
    >"4414312344"
    >=3D> nil
    >irb(main):006:0> p 10.times.map{a[rand(a.size)]}.join
    >"4342411331"
    >=3D> nil
    >irb(main):007:0> =C2=A0p 10.times.map{a.choice}.join
    >"2333341212"
    >=3D> nil
    >irb(main):008:0> p 10.times.map{a.choice}.join
    >"1312441122"
    >=3D> nil
    >irb(main):009:0> =C2=A0p 10.times.map{a.choice}.join
    >"2412444223"
    >=3D> nil
    >Z ruby -v
    >ruby 1.8.7 (2008-08-11 patchlevel 72) [i486-linux]


    Maybe I wasn't clear in explaining the issue. Within a single irb session (=
    or=20
    ruby invocation in general) I, too, get different results at each invocatio=
    n.=20
    The problem is that if I run the script twice, I get the same results for e=
    ach=20
    call to choice (that is, the first call to choice gives the same result at=
    =20
    each ruby invocation; the second call always gives the same result, which c=
    an=20
    be different from the first, and so on). A simpler example:

    =46ile: test.rb

    p [1,2,3,4].choice

    ruby test.rb
    =3D> 4
    ruby test.rb
    =3D> 4
    ruby test.rb
    =3D> 4

    And so on. If at the beginning of the script I add a call to Kernel#srand=20
    (without arguments), I get the correct behaviour, that is a different numbe=
    r=20
    every time the script is run.

    Stefano
     
    Stefano Crocco, Feb 5, 2009
    #4
  5. On Thu, Feb 5, 2009 at 2:42 PM, Stefano Crocco <> wr=
    ote:
    > p [1,2,3,4].choice
    >
    > ruby test.rb
    > =3D> 4
    > ruby test.rb
    > =3D> 4
    > ruby test.rb
    > =3D> 4
    >
    > And so on. If at the beginning of the script I add a call to Kernel#srand
    > (without arguments), I get the correct behaviour, that is a different num=

    ber
    > every time the script is run.



    It looks like it was fixed in ruby1.9 (notice that #choice has been
    renamed to #sample):

    ruby1.9.1 -e "p [1,2,3,4].sample"
    4
    ruby1.9.1 -e "p [1,2,3,4].sample"
    1
    ruby1.9.1 -e "p [1,2,3,4].sample"
    2
    ruby1.9.1 -e "p [1,2,3,4].sample"
    3
    ruby1.9.1 -e "p [1,2,3,4].sample"
    1
    ruby1.9.1 -e "p [1,2,3,4].sample"

    File a bug or ask in ruby-core if it's desired behavior.

    --=20
    Pozdrawiam

    Rados=B3aw Bu=B3at
    http://radarek.jogger.pl - m=F3j blog
     
    Rados³aw Bu³at, Feb 5, 2009
    #5
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. Mickey Segal
    Replies:
    0
    Views:
    913
    Mickey Segal
    Feb 2, 2004
  2. zorro
    Replies:
    0
    Views:
    445
    zorro
    Jul 31, 2004
  3. Replies:
    1
    Views:
    670
    Crutcher Dunnavant
    Feb 26, 2006
  4. Replies:
    5
    Views:
    473
    Luc The Perverse
    Oct 27, 2006
  5. miles.jg
    Replies:
    16
    Views:
    895
    Alf P. Steinbach
    Nov 14, 2007
Loading...

Share This Page