Here is a one-at-a-time Fisher-Yates shuffle but using an array of indices instead of modifying your array of numbers directly (if even avoids having to move around half of the extra array via splitsplice):

#!/usr/bin/perl -lw
use strict;

my @inviolable= getNumbers();
my $pickNext= genPickWNoReplace( \@inviolable );
while(  1  ) {
    print $pickNext->();
}

sub genPickWNoReplace
{
    my( $av )= @_;
    my @idx= 0..$#$av;
    return sub {
        die "No more items left to pick from"
            if  ! @idx;
        my $o= int rand @idx;
        my $pick= $av->[ $idx[$o] ];
        $idx[$o]= $idx[-1];
        pop @idx;
        return $pick;
    };
}
[download]

(update above thanks to fenLisesi's correction)

Why not copy the array and destroy the copy? Is it big?

An easy solution would involve List::Util::shuffle. Just shuffle the (copied) array and pop n items off of it.

If you really can't copy the array, maybe this would work:

# 20 random integers, 0-99
my @orig_list = map { int rand 100 } 0 .. 20;
my @selected = ();   # items selected
my $desired = 10;    # how many items to select
my %found = ();      # indexes already used
while ( scalar @selected < $desired ) {
    my $index;
    $index = int rand @orig_list until ! $found{$index}++;
    push @selected, $orig_list[$index];
}
[download]

Note that this is not very efficient when the number of items desired approaches the size of the original list. However, it avoids copying the whole list or modifying any part of it.

The traditional way to do this task is to shuffle the array and then just select sequential values from it. See How do I shuffle an array?

If you need to preserve the order then you just shuffle a temporary array (that initially held sequential index values) and select sequential values from that to get random index values to your original array.

My suggestion is to use hash:

my %already_selected;

......
unless ( $already_selected{$find} ) {
    $already_selected{$find}++;
    #this number is selecting first time
    ....
}
[download]

And of course don't use splice if you don't want destroy original array.

my @picked    = @list.pick(3); # randomly pick 3 elements;
my @shuffled  = @list.pick(*); # same as List::Util::shuffle
[download]

use strict;
use warnings;

## How many elements to pick
use constant N => 10;

## The original array that must not be altered
my @letters = ('a'..'z');

##-----------------------------------------------------+
## Generate code that will pick an element from
##     @letters at each iteration without repeating
##-----------------------------------------------------+
my $picker_of_next_rand = gen_picker( \@letters );

## Now execute (iterate) that code N times
for (1..N) {
    print $picker_of_next_rand->();
}
print "\n";            ## look nice
print @letters, "\n";  ## original untouched
exit( 0 );

##-----------------------------------------------------+
## This sub generates and returns code that will pick
##     a random element from @$aref at each iteration
##     without repeating
##-----------------------------------------------------+
sub gen_picker {
    my ($aref) = @_;
    my @indices = 0 .. $#$aref;

    ## closes on @indices
    return sub {
        if (! @indices) {
            die "No more items left to pick from";
        }

        ##---------------------------------------------+
        ## pick an int in the range (0 .. $#$aref),
        ## the range of the array's indices
        ##---------------------------------------------+
        my $random_index = int rand @indices;

        ## $pick is the element at the random_index
        my $pick = $aref->[ $indices[ $random_index ] ];

        ##---------------------------------------------+
        ## We are about to pop the index array.  Save
        ## the element at the pop-end of the index array
        ## by copying it into the position of the $pick
        ## (clobber index of $pick, won't be used again)
        ##---------------------------------------------+
        $indices[ $random_index ] = $indices[ -1 ];

        ## Now it is safe to pop the index array
        pop @indices;

        return $pick;
    };
}
[download]

which prints something like the following:

vkdbfymxie
abcdefghijklmnopqrstuvwxyz
[download]

I agree that this solution is going to suit my needs. The code works really well, but I don't understand a part of it.

my $picker_of_next_rand = gen_picker( \@letters );

print $picker_of_next_rand->();
[download]

I under stand that is is a reference/dereference type thing.

What I don't understand is how to use the variable $pick in a meaningful (non-global) way. i.e. $var_to_use_later = $list[$pick]; I have had trouble with reference/dereference structure before, and I have tried to use the camal book. It is not sinking in, and combined with a bit of code I am not familar with...it is a headache for me.

I appreciate all that has been done to this point for me, it is just that last little push in the right direction I need.

Thanks...Bio.

Even a blind squirrel finds a nut sometimes.