I don't know what algorithms there are for doing N-way diffs, but this came up with something sane for your example:

use strict;
use warnings;

use Algorithm::Diff qw( );

my @seqs = (
   [qw( A B C )],
   [qw( A D C )],
   [qw( A B C )],
);

my @combined;
my @grid;

for my $col_idx (0..$#seqs) {
   my $seq = $seqs[$col_idx];

   my $diff = Algorithm::Diff->new(\@combined, $seq);

   my @new_combined;
   my @new_grid;
   while ($diff->Next()) {
      if ($diff->Same()) {
         for ($diff->Range(1)) {
            push @new_combined, $combined[$_];
            push @new_grid,     $grid[$_];

            $new_grid[-1][$col_idx] = 1;
         }
      } else {
         for ($diff->Range(1)) {
            push @new_combined, $combined[$_];
            push @new_grid,     $grid[$_];
         }

         for ($diff->Range(2)) {
            push @new_combined, $seq->[$_];
            push @new_grid,     [];

            $new_grid[-1][$col_idx] = 1;
         }
      }
   }

   @combined = @new_combined;
   @grid     = @new_grid;
}

for my $row_idx (0..$#combined) {
   my $ch = $combined[$row_idx];

   for my $col_idx (0..$#seqs) {
      print($grid[$row_idx][$col_idx] ? $ch : " ", " ");
   }

   print("\n");
}
[download]

A A A
B   B
  D
C C C
[download]

Cool! That is exactly what I need. Had I just known that there exists a solution already x).
Thanks, Jan

Me again I have another problem with the script and since I frankly don't fully understand it, I ask again here:
Please look at the output of:

use strict;
use warnings;
use Algorithm::Diff qw( );

my @seqs = (
   [qw( A B C D E F G H I )],
   [qw( A D C X F G H I )],
#   [qw( A  )],
  # [qw( A B C )],
);

my @combined;
my @grid;

for my $col_idx (0..$#seqs) {
   my $seq = $seqs[$col_idx];

   my $diff = Algorithm::Diff->new(\@combined, $seq);

   my @new_combined;
   my @new_grid;
   while ($diff->Next()) {
      if ($diff->Same()) {
         for ($diff->Range(1)) {
            push @new_combined, $combined[$_];
            push @new_grid,     $grid[$_];

            $new_grid[-1][$col_idx] = 1;
         }
      } else {
         for ($diff->Range(1)) {
            push @new_combined, $combined[$_];
            push @new_grid,     $grid[$_];
         }

         for ($diff->Range(2)) {
            push @new_combined, $seq->[$_];
            push @new_grid,     [];

            $new_grid[-1][$col_idx] = 1;
         }
      }
   }

   @combined = @new_combined;
   @grid     = @new_grid;
}

for my $row_idx (0..$#combined) {
   my $ch = $combined[$row_idx];

   for my $col_idx (0..$#seqs) {
      print($grid[$row_idx][$col_idx] ? $ch : " ", " ");
   }

   print("\n");
}
[download]

It outputs

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

What I want is:

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

The rows must be, so to say, unique, meaning that there must not be a "C" in line 3 and one in line "6". What I also wonder is: The Documentation of Algorithm:Diff reads that if finds the LCS. But for my example it finds 6 common rows while I find 7 ...
Greetings,
Jan

Have you tried to sort your vectors before combining them? That should solve your issue ... (being a kind of the "look forward" you were asking for)

HTH, Rata

Update: Sorting (of course) changes the order of the elements (that made the proposed solution so elegant ;-) ... when proposing it I wasn't aware of a requirement to preserve the order ... so with the clarification below the simple solution won't work ...

Hi,
well, what exactly do you mean by "sorting"? The order of the entries must be preserved, e.g.

['A','C','B'] ne ['A','B','C']
[download]

So it means that the result of the above should be

A     A
C    
B     B
      C
[download]

or

A     A
B    
C     C
      B
[download]

If I understood you correctly, sorting would result in

A     A
B     B
C     C
[download]

Or not? This I don't want ;P
Jan

my @TwoD = ( ['A','B','C'], ['A','D','C'], ['A','B','C'] );
my ( $slotH, %slotH ) = (-1,());
my @result = ();
for ( my $i1 = 0; $i1 <= $#TwoD; $i1++ ) {
    for ( my $i2 = 0; $i2 <= $#{ $TwoD[ $i1 ]}; $i2++ ) {
        my $v = $TwoD[ $i1 ][ $i2 ];
        defined( $slotH{ $v } ) or $slotH{ $v } = ++$slotH;
        $result[$i1][$slotH{ $v }] = $v;
    }
    for ( my $i2 = 0; $i2 <= $slotH; $i2++ ) {
        $i2 and print "\t";
        print ( $result[$i1][$i2] || '' );
    }
    print "\n";
}
[download]

A       B       C
A               C       D
A       B       C
[download]

use strict;
 
my @AoA=(
      ['A','B','C'],
      ['A','D','C'],
      ['A','B','C'],
     );
 
my (%join,@AoH);
 
for (@AoA) {
  @join{@$_}=();
  my %set;
  @set{@$_}=(); 
  push @AoH,\%set;  
}
 
for my $elem (sort keys %join) {
  for (@AoH){
    print "$elem" if exists $_->{$elem};
    print "\t";
  }
  print "\n";
}
[download]

prints

A	A	A	
B		B	
C	C	C	
	D		

Oh, I didn't see the previous two posts.
They find indeed the correct number of common "rows". There is however the problem that the order is not fully conserved.

[qw( A B C D E F G H I )],[qw( A D C X F G H I )]
[download]

With "conserved" I mean, that in the second vector, the "X" comes after the "C" and in front of "F".
The last two versions output the aligned vectors such that the "X" is at the end, i.e. after the "I".

The letters stand for a process flow and its order must be conserved (and there is no way of sorting them as the names are arbitrary human readable things) ;)
Greetings, Jan

You can use my code with which ever order you want, just provide a sorted array to loop through.

UPDATE: you might think that the wanted sorting is obvious, but that's wrong.

take  [[qw/A X C/][qw/A Y C/] and find a heuristic that decides the order of X and Y.

You must be explicit about the order!!!

Cheers Rolf