Shuffle the array (using "shuffle" from List::Util) and take the first ten elements.

Update: Here's a non-destructive approach that uses "shuffle":

use List::Util 'shuffle';

my @arr = (1 .. 200);

my @random = @arr[(shuffle 0 .. $#arr)[0 .. 9]];

print "@random\n";
[download]

davorg,
Great advice and I upvoted you. It is nice to point out though that this, and randomly splicing elements of the original array do not leave it intact. Apparently Data::Random can do this as well as my suggestion of using a parallel array of indices.

Update: After looking at the source of Data::Random's rand_set(), I noticed the routine can be terribly run-time inefficient depending on the parameters. It continously selects random indices until it finds enough unique ones to satisfy the 'size' option. This is doing a lot more work than necessary. I have emailed the author with suggestions.

Cheers - L~R

Shuffling all 100 elements (or indices) just to get 10 of them... A partial Fisher-Yates shuffle can be more efficient. For example, using pickFromRange which I wrote after Limbic~Region asked for such a thing in the CB (probably prompted by this thread), you could do:

my @pick= @quest[ pickFromRange( 10, 0, $#quest ) ];
[download]

Though I bet it will actually be slower than just shuffling the whole list of indices for this particular case given how slow dispatching Perl opnodes is and that List::Util uses XS. But for larger lists, it could be a win.

- tye        

rsriram,

Here is a way to do it.

use strict;
use warnings;
use Data::Random qw(:all);

my @array = (1, 2, 1..120); #assign values to array
 
my @ten = rand_set( set => \@array, size => 10 );#get random  

print "Ten unique random numbers: @ten";
[download]

updated: Added random module. Removed identifying unique elements as per L~R's advice. As far as runtime is concerned, it is not most efficient way though. Take a look at Limbic~Region node or davorg's. Limbic~Region Thanks.

prasadbabu,
I think you have misunderstood though it is not your fault and I might be the one that is wrong. rsriram said unique elements but meant unique indices judging by the rest of the node. In other words, by repeating the random number selection, the same index was appearing multiple times. While your updated use of the Data::Random module gets the job done, the %unique is not needed. Update: Your second update corrects all the problems and this is a valid solution.

Several ways to do this that involve changing the original array are to use List::Util's shuffle() as davorg has suggested or use splice to pull out elements randomly. Alternatively, a parrallel array of indices allows the original array to remain intact.

my (@index, @rand);
@index = 0 .. $#array;
push @rand, splice(@index, rand @index, 1) for 1 .. 10;
print "@array[@rand]\n";
# untested
[download]

Update: I added a couple of alternatives that do not leave the original array intact. Additionally, I need to point out that your use of Data::Random can be terribly runtime inefficient. See my update in this node for details. The alternatives consume more memory (trading space for time). I also originally incorrectly thought that the module was returning the set in the original order by default but it isn't.

Cheers - L~R

A slight change to your code can help:

my %seen;

for my $x (0..9)
{
my $element = $quest[rand @quest];
redo if $seen{$element}++;
print $element;
}
[download]

You set the element as a key to the hash, and you test to see if you have already used that element.

Leviathan,
While this code works, it can be terribly runtime inefficient. Imagine that you have an initial data set of 10_000 elements and the desired random set is 9_990 elements. This is how Data::Random does it under the covers and I have emailed the author with a couple of alternatives.

Cheers - L~R

for my $x (0..9)
{
my $element = splice(@quest,rand @quest,1);
print $element;
}
[download]

my $limit = 0;
for $selection ( sort { rand() <=> 0.5 } @array ) {
    print "$selection\n";
    ( ++$limit < 10 ) or last;
}
[download]

@output = sort { rand() <=> 0.5 } @input;
$#output = 9; #truncate the randomly sorted copy
[download]

#!/usr/bin/perl

my $n = 1000;
my $cnt = 10;
my %ret;

for (my $i = 0; $i < $cnt; $i++) {
    my $r = int(rand()*$n);
    $r++ while exists $ret{$r};
    $ret{$r} = undef;
    $n--;
}

print "$cnt random indexes:\n";
foreach (keys %ret) {
    print "$_\n";
}
[download]

I am sorry, I'v made a mistake:

my $n = 1000;
my $cnt = 10;
my @ret;
for (my $i = 0; $i < $cnt; $i++) {
    my $r = int(rand()*$n);
    my $j = 0;
    while ($j <= $r) {
        $r++ if defined $ret[$j];
        $j++;
    }
    $ret[$r] = 1;
    $n--;
}
    
print "$cnt random indexes:\n";
for (my $i = 0; $i < $n+$cnt; $i++) {
   print "$i\n" if $ret[$i];
}
[download]

As you can see, the repaired algorithm does ~ $n*$cnt cycles. It is too naive. Therefore, it should be better to use some previously adviced libraries.