Since wordmask() is a non-trivial subroutine I've included a few tests for it...

Run it like so:

% match_word.pl abcdee
% match_word.pl elephant
% match_word.pl run_tests

#!/usr/bin/perl -wT
use strict;

my $word = shift || 'abcdee';
my $dict = '/usr/dict/words';
run_tests() if $word eq 'run_tests';
my $mask = wordmask($word);

open(my $in, '<', $dict) or die "cant open $dict : $!";

while(<$in>) {
  chomp;
  next unless length($_) eq length($mask);
  my $wordmask = wordmask($_);
  print "$_\n" if $wordmask eq $mask;
}

sub wordmask {
  my $word = shift;
  $word =~ tr/a-z/A-Z/;
  return 'ERROR' unless $word =~ /^[A-Z]+$/;

  my $letter = 'a';
  while ($word =~ /([A-Z])/) {
    $word =~ s/$1/$letter/g;
    $letter++;
  }
  return $word;
}

sub run_tests {
  eval "use Test::More tests => 4";
  is( wordmask('abc'),  'abc' );
  is( wordmask('ally'), 'abbc' );
  is( wordmask('ggl'),  'aab' );
  is( wordmask('*()'),  'ERROR' );
  exit;
}
[download]

-Blake

-- Randal L. Schwartz, Perl hacker
Be sure to read my standard disclaimer if this is a reply.

Some day when i have some free time (it does exist doesnt it?) i want to expand that pat to take a crypto string of words and find the possible char -> char mappings that produce feasable word dict matched words.

-Waswas

Gee, it seems as if everyone has done this at one time or another... :-)

My approach avoided regular expressions. I just attempted to build a one-to-one mapping between two words. If I could do it, they "matched" in the sense that one could be transformed to the other. When successful, the following function returns a reference to a hash that shows the mapping required to get from the first word to the second. It returns undef on failure.

sub possible_match {
    my ($word1, $word2) = @_;
    return undef unless length( $word1 ) == length( $word2 );
    my ( %one, %two );
    for ( 0 .. length( $word1 ) - 1) {
        my $c1 = substr($word1, $_, 1);
        my $c2 = substr($word2, $_, 1);
        return undef if exists $one{ $c1 } and $one{ $c1 } ne $c2;
        return undef if exists $two{ $c2 } and $two{ $c2 } ne $c1;
        $one{ $c1 } = $c2;
        $two{ $c2 } = $c1;
    }
    return \%one;
}
[download]

-sauoq
"My two cents aren't worth a dime.";

Here's my crack at building your regexes.

sub genRegex{
    my $word = shift;

    my $re = '(.)';
    my @c =  split '', $word ;
    for my $c ( 1 .. $#c ) {
        my $match = 1+index $word, $c[$i], 0;
        $re .= $match <= $c[$i] 
             ? '($' . ($match - 1) . ')'
             : '([^$' . join( '$', 1..$i ) . '])';
        }
    }
    return qr[$re];
}
...

# Build a hash relating cryptoword with a regex to find possible match
+es.
$soln{$_}{regex} = genRegex $_ for @crypts;

open WORDS, '<words.txt' or die $!;

# build an HoA of all the possible matches
while( chomp( my $word = <WORDS> ) ) {
    print $word;
    for( keys %soln ) {
        push @{ $soln{ $_ }{ possibles } }, $word
            if $word =~ $soln{$_}{regex};
    }
}
[download]

Of course, once you have all the possible matches for each of the words in the cryptoquote, then comes the fun of trying to weed out the set(s) of words that use the same mapping function. That's left as an excersise for the reader...mostly because my first attempt would require a Cray to solve it in my lifetime:)