Something sounds fishy, probability wise if you are saving hands, and reassigning them, with a "known cards" factor. Maybe you could amplify on what you are trying to test?

From my limited understanding of your description, wouldn't it be easier to approach it from another angle? Instead of trying to "remove known cards so they can't be reassigned", start with a hash of cards as keys, with the values being the number of that card in the deck, then decrement 1 each time the card is dealt?

YuckCall

#!/usr/bin/perl

  use strict;
  use Storable qw(dclone);
  use Data::Dumper;

  my $players  = {
    big_slicks => {
      list => [qw(AsKs AhKh AdKd AcKc)],
    },
    big_hearts => {
      list => [qw(AhKh KhQh QhJh JhTh)],
    },
    ace_ragman => {
      list => [qw(As7c Ah6d Ac8s Ad9h)],
    },
  };

  my $my_hand = 'AcAs';

  for (1..10) {
    my $hands = iterate($players, $my_hand);
    $hands->{my_hand} = $my_hand;

    print Dumper $hands;
  }

#-----------------------------------------------------------
sub iterate {

  my $players = shift;
  my $my_hand = shift;

  $players = dclone($players);

  for my $card ($my_hand =~ /(.{2})/g) {
    update($players, $card);
  }

  my $player_hands = {};

  my @player_keys = keys(%$players);

  while (@player_keys) {

    my $player    = splice(@player_keys, rand(@player_keys), 1);
    my $hand_list = $players->{$player}{list};
    my $pick      = splice(@$hand_list, rand(@$hand_list), 1);

    for my $card ($pick =~ /(.{2})/g) {
      update($players, $card);
    }

    $player_hands->{$player} = $pick;
  }

  return $player_hands;
}

#-----------------------------------------------------------
sub update {

  my $players = shift;
  my $card    = shift;

  for my $player (keys(%$players)) {
    my @new_list = grep { $_ !~ m/$card/ } @{$players->{$player}{list}
+};
    $players->{$player}{list} = \@new_list;
  }
}
[download]

If you absolutely need to do it that way, you will need to save a record of all hands dealt. Setup a hash, with keys like game_number, hand_number, etc, and store it all. Then you can reclaim it at will. Setting up your deeply nested hash structure, so it works well with the module you are using may take some ingenuity on your part. You probably want to feed a sub, the game number, player, hand number, and get back an array ref. You may even need to use a db, to prevent your hash from consuming too much memory.

---

I'm not really a human, but I play one on earth Remember How Lucky You Are

gman1983

I don't fully understand your problem, but it seems that you are having problems dealing with having duplicate cards in players hands. To avoid that, I suggest that you deal with it right from the start, that is, right when you are dealing the cards to the players. So my suggestion is:

# build the original deck of cards
my @card_values = (2, 3, 4, 5, 6, 7, 8, 9, 10, 'V', 'D', 'R', 'A');
my @hearts   = map {$_." h"} @card_values;
my @clubs    = map {$_." c"} @card_values;
my @diamonds = map {$_." d"} @card_values;
my @spades   = map {$_." s"} @card_values;

# scramble the deck of cards
sub scramble {
    my @original_deck = (@hearts, @clubs, @diamons, @spades);
    @deck = ();
    while (@original_deck) {
        push @deck, splice(@original_deck, rand(@original_deck), 1);
    }
}
[download]

Now you have a pile (array) of 52 scrambled, and not repeated, cards that you can start shifting to deal them to the players. Whenever you want to give a card, you just shift one from the @deck. For instance, if you want to give me a hand of 5 cards:

my @hand = (); 
push @hand, shift @deck for 0..4;
[download]

That was my approach when I wrote the single player Place your bets