Welcome SayWhat?!,

Rather than debug your script for you, I hope I can make some suggestions for you to learn to better debug your scripts. Note: these are suggestions and after some years of doing your own debugging your suggestions could be very different than mine.

If your Perl supports it, use the 3 parameter version of open:

  open (my $FALSEF, "<", "FalseFriendsList.txt");
[download]

  my %ExistingFalseFriend;    #  or
  my %existing_false_friend;  #  or
  my %Existing_False_Friend;
[download]

  my $Debug = 3;     # 0 - production, 1 - minor debugging, 2 .. 9 for
+ different levels
[download]

This leads to what is needed most in your script -- self-help debugging information. For example why not use a 'foreach' on the hash(or array) to see exactly what you just created.

#while the FF input exists
while (my $line = <FALSEF> )
{
                   # chomp off the new line
    chomp $line;   # chomp could be part of while statement
                   # increment $line
    $falsef{$line}++;
}
  ### Now during debugging print to open log file
  if ( $Debug )        # this could be 'if ( 1==1 )' for testing, your
+ call
  {
        foreach my $key ( sort keys $falsef )
        {     print $LOG "$key\t$falsef{$key}
        }
  }
[download]

In general, I like your style and I'm sure it will get better and better.

Good Luck...Your on your way!

I have already done that and added the changes like suggested, but I'm still stuck. Someone called Athanasius suggested that I should start a new question in which I clarify what I would like my program to do. So that's what I did. :) I personally think this question explains in more detail than my previous one, though..

Hello again, SayWhat?!,

Good job on clarifying the question. I’m getting some idea of what you want to achieve. However, from your statement:

I want the matching lines to be written to OutputFalseFriends.txt, and the non-matching lines to be written to OutputUnsortedWorldList.txt

I would not expect the second output file to contain the line goed braaf, since this appears in both the input files. Is this a mistake, or am I missing something?

(Incidentally, a large part of ‘programming’ is really sorting out requirements, independently of the actual code. This is just something we all need to get used to.)

I think that, if you re-examine your code in light of your sample input, you will see that the requirements have evolved. For example, as RichardK observes, there are no commas, etc., to be cleaned up. Also, %hash is not being used for anything. Rather than fix your main loop — the loop beginning while (<BILWL>) — it will probably be easier if you re-think the logic of what you are doing and re-write this part from scratch.

flexvault has given some excellent advice. In addition, it will help you if you include the line:

use autodie;
[download]

near the top of your script, as this will tell you when files cannot be opened, etc. Also, if you:

use Data::Dumper;
[download]

this will make the debugging task easier. (Data::Dumper is a core module, so it will already be in your Perl installation. See http://perldoc.perl.org/Data/Dumper.html for details.) For example, you can print the contents of %falsef with just:

print Dumper(\%falsef);
[download]

You’re making progress!

Athanasius <°(((>< contra mundum

Your requirements aren't quite clear (at least to me). You say lines don't have to match 100%, but then, how exactly do they have to match? Is it enough for the first columns to match, or does the second column have to match partly in some way? In the example you give (repeated below), the first column values are identical, but in the second column, one is a substring of the other, and your attempt to tokenize makes me think you might be trying to match more than just the first column. Can you clarify?

# these should match, but why exactly?
#FileA
irriterend    vervelend
#FileB
irriterend    irritant//vervelend
[download]

You could always step through you code with the debugger 'perl -d' to see what it's really doing.

But a first glance you don't actually clean up the word list as your comment suggests

What do you think this does?

for (my $x = 0; $x <= $#wordlist; $x++)
    {
        my $token = $wordlist[$x];
        
        if ($token =~ /(['\-\w]+)/)
[download]

Hello to you too, Athanasius! :)

I have to thank you though, you're giving me such helpful advice - in a language I can understand! I hope you will continue doing so, if you don't mind.. :)

aaron_baugher The first columns definitely have to match and the second column has to match partly, yes. The reason for this is because they are false friends of one another.

In the first column we have the Afrikaans word 'irriterend'. In Dutch, the word for 'irriterend' can either be 'irritant OR vervelend'

Like in English and German: 'Chef' in English means ‘someone who cooks for a living’ but a 'Chef' in German in the 'director or boss of a company'.. Does that make better sense now? I don’t really know how else to explain it, I'm afraid..

Thanks for all the advice, though! You're really helping me to make progress! :)

And I would also like to apologise to anyone that I might have annoyed by posting a new question.. I'm still new at this whole posting thing. Hopefully it will improve just like my coding hopelfully will!

Thanks for the clarification. In that case, I think you're on the right track: put fileB in a hash, then go through fileA checking each key from fileA for existence as a key in fileB. That's the standard idiom for this kind of thing, but in your case there will be the extra step that once you find a match on the keys from the first column, you'll also need to check for a match on the second column. That might look something like the code below (untested). The tricky part may be that inner if comparison. In mine, I'm just testing to see if either value is found as a substring in the other. If you need something more sophisticated, you'll have to adjust that there.

# %b is a hash already containing the values from fileB, with the 
# first column as keys and the second column as values.
# $file_of_matches is a file descriptor opened to one output file
# $file_of_misses is a file descriptor for the other output file
open my $fileA, '<', 'fileA' or die $!;
while( my $line = <$fileA> ){               # get a line from fileA
  chomp $line;
  my( $k, $v ) = split /\t/, $line;         # split the line on tab
  if( $b{$k} ){                             # do first columns match?
    if( $b{$k} =~ /$v/ or $v =~ /$b{$k}/ ){ # does one second column v
+alue contain
                                            # the other as a substring
+?
      print $file_of_matches "$line\n";     # yes, so print it to the 
+match file
      next;                                 # and loop to the next lin
+e
    }
  }
  print $file_of_misses "$line\n";          # no, so print it to the n
+on-match file
}
[download]

By the way, note that this:

while( my $line = <$fileA> ){
   # do stuff with $line

# replaces this:

while( <$fileA> ){
  my $line = $_;
  # do stuff with $line
[download]

It saves a line and avoids potential bugs that may be caused by using $_ sort of halfway.

Aaron B.
Available for small or large Perl jobs; see my home node.