This is likely the wrong way to go about this. I don't need to iterate over all of the poker hands to know that there are 52!/47!/5! of them, that 52-4 have 4 aces, 4*48*47/2 have 3 aces, 13*4*12*6 are full houses, 13*4*48*47/2 have 3-of-kind in them so 13*4*48*47/2-13*4*12*6 are 3-of-kind hands, etc.

Those are the types of calculations that you need to make, rather than just counting (if you want to do this fast enough to be useful in real time).

I suppose you could try doing weighted combinations where instead of combinations of cards you do combinations of classes of cards. For example, if the only types of cards that will change the standings are an ace or a spade, then you'd do combinations of the following classes: non-spade aces, ace of spades, non-ace spades, non-ace non-spades. Those combinations then lead to calculations like I was doing above. I not sure that would be any simpler.

You could look at my Permuting with duplicates and no memory (now part of Algorithm::Loops) and compare it to a standard lexicographic permutations combinations algorithm to see how my changes deal with duplicates and try to make similar changes to one of the combinations algorithms. Likely, you could search and find an algorithm for doing combinations with duplicates somewhere.

The number of truly different five card poker hands is not that large. Brute force is good enough to list all 7462 of them.

First, forget about suits, and generate all combinations of ranks. Sort them and join them in a string. Count the number of unique ranks in the hand. If it is one, the combination is no good (five aces). If it is five, a flush is possible.

Rank all hands from 0..7461 and you have a quick lookup.

Update:
Deal a few hundred random outcomes and tally the results.

YuckFold

#!/usr/bin/perl

  use strict;

  my @chars = 'a'..'m';
  my %hands;

  for my $c0 (@chars) {
    for my $c1 (@chars) {
      for my $c2 (@chars) {
        for my $c3 (@chars) {
          for my $c4 (@chars) {

            my $list = [$c0, $c1, $c2, $c3, $c4];
            my $uniq = unique_ranks($list);
            my $key = join('', sort @$list );

            # is a valid hand
            if ($uniq > 1) { $hands{$key}++; }

            # can be flushed
            if ($uniq > 4) { $hands{"$key+"}++; }
          }
        }
      }
    }
  }

  for my $key (sort(keys(%hands))) {
    $key =~ tr/a-m/AKQJT98765432/;
    print "$key\n";
  }

#-----------------------------------------------------------
sub unique_ranks {
  my $list = shift;
  my %uniq = map { ($_ => 1) } @$list;
  return keys %uniq;
}
[download]

Your ideas are truly excellent. I will need to work on it to be able to apply this at different stages in the hand lifecycle (pre-flop, flop, turn, river), but, very well done anyway - you have found a good optimisation strategy indeed!

Update: Just spotted one hole that I thought had been covered in this but seems to be there after all. For example, there are 48 ways to get four aces but only 20 7-high flushes. Therefore a holding of say full house has to take into account the number different ways to land on each rank above or below it or at least take into account the cumulative sum of all possible ways up to current rank and divide that by the (constant and known) number of all possible combinations.

But I could for example calculate the number of possible hands at each rank by a cut-down combination operation and feed that in instead of doing your ++ iterative approach - this changes things a bit so I need to do further work on this algorithm even so.

More update - actually that wasn't quite the right example. I should have been talking about exact rank, i.e. for identical hands. Here is a better one: There are only four combinations (and 480 permutations) of 7 5 4 3 2 suited, but there are 1020 combinations (and 122400 permutations) of the same hand unsuited. These might be unique by the reduced iteration but do not therefore have equal likelihood.

-M

Free your mind