Do you have something else in mind?

Cheers - L~R

Update: I was looking for an iterative solution an tye recommended Algorithm::Loops. Even though he hasn't uploaded it yet, the source is available here. My original sentiment stands, but this is how I would do it if I could think of a legitimate reason to do it.

On my Mom's mediocre computer, this would take 555 years to complete - give or take a few months :-)

In any case, I think you're mistaken about preferring the use of hashes. Unless I misunderstood your post, the app you're talking about is just a matter of nested loops, one loop for each character position in the string. The inner-most loop prints the concatenation of all the loop iterators. The number of iterations on each loop is simply the number of possible characters to use at the corresponding position. It could be structured recursively to support handling strings of various lengths. But using hashes would be a waste of time, and a vast waste of memory.

And now for my attempt to reinvent this wheel:

my @alpha = ('a'..'c');
my @counter = ();

sub get_next {
  for (@counter) { 
    $_++;
    last if ($_ <= $#alpha);
    $_ = 0;
  }
  push @counter,0 unless grep($_>0,@counter);
  return join"",map($alpha[$_],@counter);
}

for ($_ = get_next();4 > @counter ;$_ = get_next()) {
  print "$_ ";
}
__DATA__
output: a b c aa ba ca ab bb cb ac bc cc aaa baa caa aba bba cba aca b
+ca cca aab bab cab abb bbb cbb acb bcb ccb aac bac cac abc bbc cbc ac
+c bcc ccc
[download]

Of course, maybe it was a silly try. But still, I like it :)

Hope this helps.

antirice    
The first rule of Perl club is - use Perl
The ith rule of Perl club is - follow rule i - 1 for i > 1

if you just want the 3 letter combinations of the 26 lowercase letters in the English alphabet, this is pretty simple and probably very fast:

#!/usr/bin/perl -w
use strict;
my $size = 3; # number of characters in the target string.
my $string = 'a' x $size;
my $end = 'z' x $size;
do {
  print $string++, "\n";
} while $string ne $end;
[download]

This would also work for uppercase, but as soon as you want to mix cases, add numbers, and add punctuation it falls short as a solution.

The mechanism used here is the automagical increment operator (++) which does cool stuff when applied to a string starting with a letter and consisting of letters and numbers.

Update: If you want to start with 1 character strings and go up to N characters, just change the initialization to:

my $string = 'a';
[download]

use Algorithm::FastPermute;
my @c = 'a'..'c';
permute {print "@c\n"} @c;

__END__
a b c
a c b
c a b
b a c
b c a
c b a
[download]

chunlou,
Permutations are not combinations. For instance - say I wanted to find all combinations of 4 character strings with each position able to be 26 different letters. This is what I believe is being asked for. I am pretty sure there is an iterative solution - but all I can come up with right now are recursive ones.

Cheers - L~R