#!/usr/bin/perl
use strict;
use warnings;
use Data::Dumper::Simple;
use List::Util qw/shuffle/;

my @nums = (4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20);
my @shuffled_nums = shuffle(@nums);
my %extracted_nums;

for (0 .. 7) {
    $extracted_nums{$_} = shift @shuffled_nums;
}

print Dumper(%extracted_nums);
print Dumper(@shuffled_nums);
[download]

Is that what you wanted?

Cheers,
Darren

The following would do the trick:

my @selection = @nums;
for (0..7) {
   my $i = $_ + rand(@selection - $_);
   ($selection[$_], $selection[$i]) = ($selection[$i], $selection[$_])
}

splice(@selection, 8);
[download]

But it would be better (simpler, cleaner, faster) to just use List::Util's shuffle.

use List::Util qw( shuffle );

my @selection = (shuffle(@nums))[0..7];
[download]

Perfect, both worked, but yours used less code, very nice. thanks!

Depending on how big the list is, this might be more efficient than shuffling the whole list for a small number of picks:

my @a = 4..20;;
my @s = map splice( @a, rand( @a ), 1 ), 1 .. 8;;

print "@a\n@s";;
4 5 7 8 9 12 13 14 18
11 10 6 20 15 17 19 16
[download]

For long lists, that isn't more efficient than shuffling. Shuffling means going through the list once, swapping each element. Splicing means going through (on average) half the list in each iteration moving the element one to the left.

Splicing a random element out of an array takes on average linear time.

For long lists, that isn't more efficient than shuffling.

Regardless of the length of the list, which is quicker depends upon the ratio of picks.

...for a small number of picks, Ie. If the ratio of picks to list size is less than ~15%, spliceing is quicker than shuffling the whole list:

#! perl -slw
use strict;
use List::Util qw[ shuffle ];
use Benchmark qw[ cmpthese ];

our $N //= 20;
our $S //= 8;
our @nums = 0 .. $N;

cmpthese -1, {
   shuffle => q[ my @s = ( shuffle @nums )[ 0 .. $S-1 ]; ],
   splice  => q[ my @s = map splice( @nums, rand( @nums ), 1 ), 1 .. $
+S; ],
};

__END__
c:\test>868601 -N=10 -S=2
            Rate shuffle  splice
shuffle 894654/s      --    -10%
splice  993686/s     11%      --

c:\test>868601 -N=10 -S=3
            Rate  splice shuffle
splice  769417/s      --     -9%
shuffle 844675/s     10%      --

c:\test>868601 -N=100 -S=15
            Rate shuffle  splice
shuffle 196571/s      --     -5%
splice  207873/s      6%      --

c:\test>868601 -N=100 -S=17
            Rate  splice shuffle
splice  186995/s      --     -3%
shuffle 192359/s      3%      --

c:\test>868601 -N=1000 -S=169
           Rate shuffle  splice
shuffle 19552/s      --     -2%
splice  19968/s      2%      --

c:\test>868601 -N=1000 -S=170
           Rate  splice shuffle
splice  20274/s      --     -1%
shuffle 20569/s      1%      --

c:\test>868601 -N=10000 -S=1998
          Rate shuffle  splice
shuffle 1578/s      --     -6%
splice  1674/s      6%      --

c:\test>868601 -N=10000 -S=1999
          Rate  splice shuffle
splice  1601/s      --     -1%
shuffle 1625/s      2%      --
[download]

---

Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.

"Science is about questioning the status quo. Questioning authority".

In the absence of evidence, opinion is indistinguishable from prejudice.

RIP an inspiration; A true Folk's Guy

use strict;
use warnings;

my $nRepeats = 1;
my @sSet = (4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20);
my $nLength = 8;

my @sAll;
for (1..$nRepeats) {
    push (@sAll, @sSet);
}

if ($nLength - 1 > $#sAll) {die "Don't be silly"}

my $sString;
for (1..$nLength) {
    my $i = int(rand(@sAll));
    $sString .= $sAll[$i];
    $sAll[$i] = $sAll[-1];
    pop(@sAll);
}

print "$sString \n";
[download]

perl -le '$n=10; $min=5; $max=15; $, = " "; print map { int(rand($max-
+$min))+$min } 1..$n'
[download]

These random numbers would not necessarily be unique

> perl -le "$n=10;$min=5;$max=15;$,=qq( );print map {int(rand($max-$mi
+n)+$min)} 1..$n"

9 9 12 10 11 12 9 5 10 9
[download]

#!/usr/bin/perl

use 5.010;
use strict;
use warnings;
use random qw(integer);
use Data::Dumper::Concise;

my @array = (4 .. 20);
for (0 .. 7) {
    my $array = 4 + rand 20;
    print Dumper($array);
}
[download]

#!/usr/bin/env perl

my $k = shift @ARGV;
srand;
while (<>) {
    $. <= $k and do { push @lines, $_; next; };
    ($a=rand($.)) < $k and ($lines[$a] = $_);
}
print @lines;
[download]

$ seq 4 20 | ./rand.pl 8
19
5
6
14
16
9
15
11
[download]

Over the years, I have found that there are three ways of looking at this problem, all three of which are appropriate in different situations:

1. “Fuhgeddaboudit!”   Don’t borrow trouble.   If the domain of random numbers is big enough (such as, “a 32-bit integer”), and the pseudo-random number generator (PRNG) is good enough (it is...), then the possibility of getting the same number twice in a reasonable length of time is near-zero.   (If it were not so, then neither Monaco nor Las Vegas would still be full of casinos.)
2. “Don’t worry about checking.”   If the domain is small, but the number-count that you actually need is also small, then the practical price to be paid by brute-force checking for dupes is also acceptably small.
3. If the problem that you are dealing with, is approximately equal to “dealing from a deck of cards,” then ... do that.   Initialize an array of “all possible values,” then shuffle it and “deal cards” from it.   (As noted, you don’t have to invent your own card-shuffling algorithm.)

#!/usr/bin/perl

use strict;
use warnings;

my $length  = 1;
my $max     = 1;
my @strings;
for ( 1 .. $max ) {
    push @strings, rand_nums($length);
}
print "@strings", "\n";

{
my %cache; 

sub rand_nums {
    my %local_cache;  
    my ($length) = 8; 
    my $lower    = 4;
    my $upper    = 21;   
    my $serial = int( rand($upper - $lower) ) + $lower;  
        $local_cache{$serial} = 1;  
        for ( 2 .. $length ) {
            my $num = int( rand($upper - $lower) ) + $lower;    
            redo if exists $local_cache{$num};
            $local_cache{$num} = 1;  
            $serial .= "-$num";      
        }
        rand_nums($length) if exists $cache{$serial};    
        $cache{$serial} = 1; 
        return $serial;
    }
}
[download]