Benchmark: timing 2500 iterations of grepGen, mapGen, smartGen...
   grepGen: 34 wallclock secs (34.35 usr +  0.00 sys = 34.35 CPU) @ 72.78/s (n=2500)
    mapGen: 14 wallclock secs (14.09 usr +  0.00 sys = 14.09 CPU) @ 177.47/s (n=2500)
  smartGen:  1 wallclock secs ( 0.95 usr +  0.00 sys =  0.95 CPU) @ 2628.81/s (n=2500)
           Rate  grepGen   mapGen smartGen
grepGen  72.8/s       --     -59%     -97%
mapGen    177/s     144%       --     -93%
smartGen 2629/s    3512%    1381%       --
loop counts - grep: 805000, map: 805000, smart: 495000
array sizes - num: 1000000; grep: 100; map: 100; smart: 100
grep:
1 12 15 18 19 20 21 22 23 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 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 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 104 105 106 107 108 109 110 111 112 113 114 116 117 118 119
map:
1 12 15 18 19 20 21 22 23 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 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 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 104 105 106 107 108 109 110 111 112 113 114 116 117 118 119
smart:
0 1 2 3 5 7 8 9 12 13 15 16 18 19 21 22 23 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 42 43 44 45 46 47 48 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 68 69 70 71 72 73 74 75 76 77 78 79 81 83 84 85 86 87 89 90 91 92 93 94 95 96 97 98 100 101 102 104 105 106 107 108 109 110 111 112 113 116 117 118 119

##</code><code>##

#!/usr/bin/perl

use strict;
use warnings;
use Benchmark qw( timethese cmpthese );

my @doCount = (0);           # total loops until unique array generated
my $range = 120;             # numbers range from 0 to $range
my $aSize = 1000000;         # random pool array size
my $uSize = 100;             # unique array size
my ( @grep, @map, @smart );
my @nums = arrGen();         # generate huge pool of random numbers

my $r = timethese( 2500, {
    grepGen  => sub{ @grep  = grepGen();  },
    mapGen   => sub{ @map   = mapGen();   },
    smartGen => sub{ @smart = smartGen(); },
} );
# show results
cmpthese $r;
print "loop counts - grep: $doCount[0], map: $doCount[1], smart: $doCount[2]\n";
print "array sizes - num: ",  scalar(@nums),  # should all == $uSize
                 "; grep: ",  scalar(@grep),
                 "; map: ",   scalar(@map),
                 "; smart: ", scalar(@smart), "\n";
# show sorted generated arrays to check for a rare duplicate
print "grep:\n@{[sortIt(@grep)]}\nmap:\n@{[sortIt(@map)]}\nsmart:\n@{[sortIt(@smart)]}\n";

sub arrGen {
    my @nArray;
    for ( 1..$aSize ) {
        my $rInt = int(rand($range));
        push @nArray, $rInt;
    }
    return @nArray;
}

sub sortIt {
    return sort { $a <=> $b } @_;
}

sub grepGen {
    my $idx = 0;
    my @gArray;
    for ( 1..$uSize ) {
        $doCount[0]++;
        my $rInt = $nums[$idx++];
        redo if ( @gArray && grep { /$rInt/ } @gArray );
        push @gArray, $rInt;
    }
    return @gArray;
}

sub mapGen {
    my $idx = 0;
    my @mArray;
    for ( 1..$uSize ) {
        $doCount[1]++;
        my $rInt = $nums[$idx++];
        redo if ( @mArray && map { /$rInt/ } @mArray );
        push @mArray, $rInt;
    }
    return @mArray;
}

sub smartGen {
    my $idx = 0;
    my @sArray;
    for ( 1..$uSize ) {
        $doCount[2]++;
        my $rInt = $nums[$idx++];
        redo if ( @sArray && $rInt ~~ @sArray );
        push @sArray, $rInt;
    }
    return @sArray;
}