my %file1;
  while (<FILE1>) {
    # Capture first four words, and everything after the next 3 words 
+(numbers)
    my ($k1, $k2) = /(\w+(?:\s+\w+){3})(?:\s+\w+){3}(.*)/;
    # Index by k1, store k2 and line
    $file1{$k1} = [$k2, $_];
  }
  while (<FILE2>) {
    my ($k1, $k2) = .... # same regex as before
    if ($file1{$k1}) {
       # print file1 line and file2 line
       print $file1{$k1}->[1];
       print;
       # Check if k2's are equal
       if ($file1{$k1}->[0] ne $k2) {
           print "K2's are not equal! (see lines printed above)\n";
       }
    }
  }
[download]

Update: fixed regex as per nobull's note.

/((\w+(?:\s+\w+){4})(?:\s+\w+){3}(.*)/;
[download]

I think you meant

/(\w+(?:\s+\w+){3})(?:\s+\w+){3}(.*)/;
[download]

If the input files are sorted (or if you use an external tool to sort them before running the Perl script), a very memory-efficient algorithm can be used:

my ($f1_k1, $f1_k2);
my ($f2_k1, $f2_k2);

my $f1_line;
my $f2_line;

my $regexp = qr/^((\w+(?:\s+\w+){3})(?:\s+\w+){3}(.*)/;

for (;;) {
   # Read from FILE1 if appropriate.
   if (not defined $f1_line) {
      $f1_line = <FILE1>;
      last unless defined $f1_line;

      # Extract the keys for comparison.
      ($f1_k1, $f1_k2) = $f1_line =~ $regexp;

      # Make sure the regexp matched.
      if (not defined $f1_k1) {
         undef $f1_line;
         next;
      }
   }

   # Read from FILE2 if appropriate.
   if (not defined $f2_line) {
      $f2_line = <FILE2>;
      last unless defined $f2_line;

      # Extract the keys for comparison.
      ($f2_k2, $f1_k2) = $f2_line =~ $regexp;

      # Make sure the regexp matched.
      if (not defined $f2_k1) {
         undef $f2_line;
         next;
      }
   }


   # Do the comparisons.
   my $cmp = $f1_k1 cmp $f2_k2;

   if ($cmp == 0) {
      print("Key 1 match:\n");
      print("$f1_line\n");
      print("$f2_line\n");

      if ($f1_k2 eq $f2_k2) {
         print("...and key 2 matches.\n");
      } else {
         print("...but key 2 doesn't match!\n");
      }

      # Only read from one file in case of duplicate keys.
      undef $f2_line;
   }

   # Need to read from FILE1.
   undef $f1_line if $cmp < 0;

   # Need to read from FILE2.
   undef $f2_line if $cmp > 0;
}
[download]

(The code isn't tested, but the idea is sound.)

If the input files can be reordered (sorted), then they don't have to be read entirely into memory but rather one line from each at a time. It seems at first blush that this could be another one of those "simplifying assumptions"

duff

Bows humbly, "Yes master". Mumbles "figured that out for me-self, but it was too late then".

---

Food for thought, not fuel for flames

I am resubmitting a question I posted yesterday. (I rushed to get yesterday's posting out and it looked awful--sorry about that!

You should enroll in the monastery yourself. It's quick and painless. Then you'll be able to update your nodes.

for (@file1) {
    $h{join ' ',(split / /)[0..3]} = $c++;
}
[download]

while (<DATA>) {
    $key = join ' ',(split / /)[0..3];
    if (exists $h{$key}) {
         print if $_ ne $file1[$h{$key}];
    }
}
[download]

use strict;
use warnings;

my ($c, %h, $key);
my @file1 = (
    "A B C D E F G\n",
    "A C B D E F G\n",
    "D B C A E F G\n",
    "B B C D E F G\n"
);

for (@file1) {
    $h{join ' ',(split / /)[0..3]} = $c++;
}

while (<DATA>) {
    $key = join ' ',(split / /)[0..3];
    if (exists $h{$key}) {
         print if $_ ne $file1[$h{$key}];
    }
}

__DATA__
A B C D E F G
A C B D E F H
D B C A I F G
B B C D E F G
[download]

Well yes, but what are the chances the files are sorted?

100% if the the application that produced them produces sorted files.

And if it doesn't, you could use an speed- and memory-efficient program (possibly written in C) to do the sorting beforehand.