use Strict;
$dict="<untitled:Desktop Folder:WORD.LST";
$adda=">untitled:Desktop Folder:addagram.lst";

####
#Open the dictionary file and read each word into @words
####

open (DICT, $dict) or die ("Can't open $dict: $!\n");
while(defined($line=readline(*DICT))) {
    chomp $line;
    push @words, $line;
}
close (DICT);

####
#Create a hash (%wordpl) of arrays, where each element in each array is
#the same length, and the keys represent those lengths
####

foreach $word (@words) {
    push @{ $wordpl{length($word)} }, $word;
}

####
#Read the keys of %wordpl, i.e. the lengths of the elements in the array
#@{ $wordpl{length($word)} } in @lengths and sort @length numerically
#in descending order
####

foreach $k (keys %wordpl ) {
    push @lengths, $k;
}
@lengths = sort {$b <=> $a} @lengths;

####
#Start a loop where $l is the length, or the key, for %wordpl.
####


foreach $l (@lengths) {
    word();
}

####
#Start a loop where you pick the a word in @{ $wordpl{$l} }
#and pass that word and $l-1 (index of array of words with one
#less character then aforementioned word) to word1()
####

sub word {
    my $word;
    foreach $word ( @{ $wordpl{$l} } ) {
        $oword=$word; #define original word
        my $p=$l-1;
        word1($p, $word);
    }
}

####
#Split $word from sub word into an @a, do the same for the word
#picked by WO. If the two words differ by one character, and the
#newest word ($sword) is greater then 3 characters, pass $sword
#and $p-1 (index of array of words with one less character then
#aforementioned word) to word2(). When word2() exits, exit WO
#and return to word(). If the newest word is equal to three 
#characters in length, push that word into the array of 
#add-a-grams and exit WO to word() to restart process
####


sub word1 {
    my $p=@_[0];
    my @a=split(//,@_[1]);
    my $sword;
    WO: foreach $sword ( @{ $wordpl{$p} } ) {
        my @b=split(//,$sword);
        my %seen = ();
        my @aonly = ();
        my $item;
        @seen{@b}=();
        foreach $item (@a) {
            push (@aonly, $item) unless exists $seen{$item};
        }
        if (length(@aonly)==1) {
            if ($p==3) {
                push @addw, $oword;
                last WO;
            }
            $p--;
            word2($p, $sword);
            last WO;
        }
    }
}


####
#Split $sword from sub word1 into an @a, do the same for the word
#picked by WT. If the two words differ by one character, and the
#newest word ($sword) is greater then 3 characters, pass $sword
#and $p-1 (index of array of words with one less character then
#aforementioned word) to word1(). When word1() exits, exit WT
#and return to word(). If the newest word is equal to three 
#characters in length, push that word into the array of 
#add-a-grams and exit WT to word() to restart process
####

sub word2 {
    my $p=@_[0];
    my @a=split(//,@_[1]);
    my $sword;
    WT: foreach $sword ( @{ $wordpl{$p} } ) {
        @b=split(//,$sword);
        %seen = ();
        @aonly = ();
        @seen{@b}=();
        foreach $item (@a) {
            push (@aonly, $item) unless exists $seen{$item};
        }
        if (length(@aonly)==1) {
            if ($p==3) {
                push @addw, $oword;
                last WT;
            }
            $p--;
            word1($p, $sword);
            last WT;
        }
    }
}

####
#determine the longest add-a-gram and print it and the
#others to a file
####


$lo="";
foreach $i (@addw) {
    if ( length($lo)<length($i) ) {
        $lo=$i;
    }
}




open (ADD, $adda) or die ("Cant open $adda: $!\n");
foreach $i (@addw) {
    if ($i ne $lo) {
        print ADD "$i\n";
    } else {
        print ADD "longest: $i\n";
    }
}
close (ADD);