Now imagine that each time one of the dials changes, all the dials to the right of it can be remade. For example, each dial could exclude any numbers that exist on any dial to its left.

New update: In Re: Efficient Unique Nested Combinations, FFRANK points out that my "I think you want" is not the correct algorithm. A corrected solution is posted in reply thereto.
Update: I think you just want to ensure that each element is greater-than-or-equal-to the previous one, so:

#!perl
use warnings;
use strict;

use Algorithm::Loops 'NestedLoops';
my @symbol = (
   [ 'a', 'b', 'c' ],
   [ 'a', 'b', 'c'  ],
   [ 'a', 'b', 'c'  ],
   [ 'c', 'd', 'e'  ],
);

my $combos = NestedLoops([
  $symbol[0],
  map {
    my $_hold = $_;
    sub {
      [grep {$_ ge $_[$#_]} @{$symbol[$_hold]}]
    }
  } 1..$#symbol
]);

my @result;
print "@result\n" while @result = $combos->();
[download]

Roy Johnson,
I think you just want to ensure that each element is greater-than-or-equal-to the previous one, so:

That's exactly one the shortcuts I used in Challenge: Number of unique ways to reach target sum. I am going to update Arbitrarily Nested Loops to mention NestedLoops and the Odometer Model fwiw. Everytime I refer to someone to one of them, I have to look up the other.

Cheers - L~R

#!/usr/bin/perl -w
use strict;
use Algorithm::Loops qw(NestedLoops);


my @symbol = (
   [ 'a', 'b', 'c' ],
   [ 'a', 'b', 'c'  ],
   [ 'a', 'b', 'c'  ],
   [ 'c', 'd', 'e'  ],
);

my $iter = NestedLoops(\@symbol);
my %seen;

while (my @list = $iter->()) {
    my $listString = join ('',sort @list);
    $seen{$listString}++
}

my @sortedUniq = sort (keys %seen);

foreach my $sortedUniq (@sortedUniq) {
    print $sortedUniq,"\n";
}
[download]

Clint

UPDATE - Benchmarks added

                 Rate array_diff array_same  hash_diff  hash_same
    array_diff  916/s         --       -10%       -16%       -25%
    array_same 1012/s        11%         --        -7%       -18%
    hash_diff  1092/s        19%         8%         --       -11%
    hash_same  1229/s        34%        21%        13%         --
[download]

Code for benchmarks:

use strict;
use warnings;
use List::Compare;

my @symbol = (
   [ 'a', 'b', 'c' ],
   [ 'a', 'b', 'c'  ],
   [ 'a', 'b', 'c'  ],
   [ 'c', 'd', 'e'  ],
);

my $lCmp = List::Compare->new(@symbol);
my @unique = $lCmp->get_symmetric_difference ();
my @union =$lCmp->get_union ();

print "Unique: @unique\n";
print "Union: @union\n";
[download]

Unique: d e
Union: a b c d e
[download]

Update: completely missed the point!

True, except that M::C doesn't support the operation being described: combinations generated by taking one member from each of N (possibly) distinct sets.

---

Caution: Contents may have been coded under pressure.

Au contraire, M::C supports nCk and the described operation can be expressed as a two-deep explicit nested loop of nCk next-combination calls, the lower layer being nC1.

Update: because selecting a single member from a set is the semi-degenerate nC1 case of an nCr.

__________________________________________________________________________________

^M Free your mind!

my @symbols=(
['c','b','e'],
['a','f','d'],
);
    
hash(\@symbols);
ab
ac
ae
bd
bf
cd
cf
de
ef

combo(\@symbols);
c f
c d
b f
b d
e f
[download]

I resorted to using a hash to catch what had been seen. The model still offers some short-circuiting, and is moderately faster than "hash" in my benchmarking (the more duplicates there are to avoid, the better "combo" does). Note also that you didn't change my code to use the passed-in array ref. I have done so here.

sub combo {
    my $symbols = shift;
    my %seen;

    my $combos = NestedLoops([
      $symbols->[0],
      map {
        my $_hold = $_;
        sub {
          [grep {!$seen{join(':', sort @_, $_)}++} @{$symbols->[$_hold
+]}]
        }
      } 1..$#$symbols
    ]);

    while (my @result = $combos->()) {
        print "@result\n";
    }
    print "\n";
}
[download]

---

Caution: Contents may have been coded under pressure.