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.)

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]

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

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.