I can indeed use these answers in *most* cases, however, all answers given to that question seem to assume that the maximum index is the same in all cases. I do not have the luxury of this assumption.

Considering a simple case of three bonds. "a" and "c" may be rotated 3 times, "b" only twice. i.e.:

a -> 3
b -> 2
c -> 3

which yields the strings

111
112
113
121
122
123
211
212
213
221
222
223
311
312
313
321
322
323
[download]

That is to say, "3" is not a legal value in the second column. Or phrased another way, I need to do the same thing as anon, but set a (possibly different) limit on each digit making up the string.

#! perl -slw
use strict;

sub nFor(&@) {
    my $code = shift;
    die "First argument must be a code ref" unless ref( $code ) eq 'CO
+DE';
    my @limits = @_;

    my @indices = ( 0 ) x @limits;

    for( my $i = $#limits; $i >= 0; ) {
        $i = $#limits;
        $code->( @indices ), ++$indices[ $i ]
            while $indices[ $i ] < $limits[ $i ];
        $i = $#limits;
        $indices[ $i ] = 0, ++$indices[ --$i ]
            while $i >= 0 and $indices[ $i ] == $limits[ $i ];
    }
}

my @digits = 1 .. 3; ## Set this to the maximum set 

nFor {
   my @numbers = @digits[ @_ ];
   my $name = join'', @numbers;
   print $name;
} 3, 2, 3; ## Set these to the individual limits.

__END__
c:\test>nFor.pl
111
112
113
121
122
123
211
212
213
221
222
223
311
312
313
321
322
323
[download]

---

Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.

"Science is about questioning the status quo. Questioning authority".

In the absence of evidence, opinion is indistinguishable from prejudice.

"I'd rather go naked than blow up my ass"

You might still use one of the algorithms proposed in the previous thread. However you need to add an additional check on validity (e.g. don't use the value if the second digit is a 3).
HTH, Rata

Ah, madd, I appreciate when people answer me directly, if possible, without complaining that I've phrased my question poorly. So, I'm slow to criticize your question. But after some thought, I'm not entirely sure you're well served by the answers you're getting (or would have gotten from me). I'd like to talk about your question a little.

Your question appears to be very simple -- the sort of thing that is posed in the first week of a freshman programming class. Here's a freshman answer:

Read more... (Code and Discussion) (2 kB)

To solve a person's problem, we need to find out more about that person. Often the technical issues are trivial. The only thing apparent to me is that you are a chemist, or work in that field. Like me, you're a PerlMonks novice; unlike me, perhaps, you may have very little programming experience. Maybe the freshman solution is just what you want. At the very least, it's easy to understand. I just don't know; and I'm not sure anyone else does, either.

I absolutely do not want to make you feel awkward; I feel awkward myself, often, when asking for help. I'm going to return to this node and I'll do my best to help (provided others don't do or haven't done much better than I can). But I'd appreciate knowing more about why you want this problem solved; how you intend to apply it; in what setting (school, industry, lab) the question arose. What will make the solution work for you?

use strict;
use warnings;
use 5.010;

use Algorithm::Loops qw(NestedLoops);

NestedLoops [([1..3]) x 5], sub { say @_ };
[download]

NestedLoops [[1..3], [1..5], [1..3]], sub { say @_ };
[download]

(use 5.010; is only required for say, not for NestedLoops).

tye++ for such a useful module.

Again, using glob seems simplest.

use strict;
use warnings;

use 5.010;

my %molecules = (
   a => 3,
   b => 2,
   c => 3,
   );

my $globStr =
   join
      q{},
      map { qq{{@{ [ join q{,}, 1 .. $molecules{ $_ } ] }}} }
      sort keys %molecules;

say for glob $globStr;
[download]

Produces.

111
112
113
121
122
123
211
212
213
221
222
223
311
312
313
321
322
323
[download]

I hope this is helpful.

00000
00001
00002
00010
...
22222
[download]

Take a look at Math::BaseArith

Just for completeness sake here is my slighty modified solution from the previous question, the changes are marked:

#!/usr/bin/perl
use warnings;
use strict;

my (@limits)= reverse (3,2,3); #changed
my $length= @limits;           #changed

my @number= (1) x $length;

while (@number) {
    printnumber(@number);
    @number= addto(@number); 
}



sub addto {
    my @number= @_;
    while (1) {
    my $carry=1;
    my $i=0;                     #changed
    foreach (@number) {    
        $_+= $carry; $carry=0;
        if ($_>$limits[$i++]) {  #changed
        $_=1;
        $carry=1;
        }
    }
    @number=() if ($carry==1);
    return(@number);
    }
}

sub printnumber {
    my @number= @_;
    print reverse(@number),"\n";
}


#prints
111
112
113
121
122
123
211
212
213
221
222
223
311
312
313
321
322
323
[download]

Note that the length (number of digits) is now derived from the length of the limits array

Iterator::Array::Jagged

use Iterator::Array::Jagged;

my @data = (
    [ 1, 2, 3 ],
    [ 1, 2,   ],
    [ 1, 2, 3 ],
);

my $iter = Iterator::Array::Jagged->new( data => \@data );
while (my @set = $iter->next) {
    print join("", reverse @set)."\n";
}
[download]