Algorithm::Loops makes this pretty easy:

#!/usr/bin/perl -w
use strict;

use Algorithm::Loops qw( NestedLoops );

my @items= ( 1..6 );
my $choose= 3;
my $iter= NestedLoops(
    [   [ 0..$#items ],
        ( sub { [ $_+1 .. $#items ] } ) x ($choose-1),
    ],
);
my @choice;
while(  @choice= @items[$iter->()]  ) {
    print "@choice\n";
    # replace above line with your code
}
[download]

produces

1 2 3
1 2 4
1 2 5
1 2 6
1 3 4
1 3 5
1 3 6
1 4 5
1 4 6
1 5 6
2 3 4
2 3 5
2 3 6
2 4 5
2 4 6
2 5 6
3 4 5
3 4 6
3 5 6
4 5 6
[download]

The OP wanted permutations, not just combinations:

e.g. AB, AC, AD, AE, BA, BC, BD, ...

-QM
--
Quantum Mechanics: The dreams stuff is made of

I missed that "BA" in the list. The last page of Algorithm::Loops talks specifically about this problem and shows a few ways to do it. A fairly minor update to my code is one such way:

#!/usr/bin/perl -w
use strict;

use Algorithm::Loops qw( NestedLoops NextPermute );

my @items= ( 1..5 );
my $choose= 2;
my $iter= NestedLoops(
    [   [ 0..$#items ],
        ( sub { [ $_+1 .. $#items ] } ) x ($choose-1),
    ],
);
my @choice;
while(  @choice= @items[$iter->()]  ) {
    do {
        print "@choice\n";
        # replace above line with your code
    } while(  NextPermute(@choice)  );
}
[download]

produces

1 2
2 1
1 3
3 1
1 4
4 1
1 5
5 1
2 3
3 2
2 4
4 2
2 5
5 2
3 4
4 3
3 5
5 3
4 5
5 4
[download]

- tye        

I suggest a recursive approach. While this might not be the fastest one, it is easy to write:

sub vari { 
  my ($set,$num,$act)= @_; 
  my(%h,$rec,@s); 
  $h{$_}= 0 for @$set; 
  $rec= sub { 
    $_[0] or return $act->(@s); 
    $h{$_} or do {
      local $h{$_}= 1; 
      push @s, $_; 
      $rec->($_[0]-1); 
      pop @s; 
      } 
      for @$set; 
    }; 
  $rec->($num); 
  } 
vari [qw{a b c d e f g}], 3, sub 
  { print join(" ",@_), $/; };
[download]

Update: changed code to be stable.

You may find useful help in the forthcoming volume of Knuth's The Art of Computer Programming. Knuth has preprints of parts of it on his web site. You'll need a postscript viewer (or printer) to look at them.

I transcribed one of the non-recursive permutation algorithms into Perl here.

Take N items and put them in a fully connected complete graph. Everything is connected to everything. What you are asking for is all paths of length 2, in the case of nP2 I believe it's an n^3'd problem involving three for loops (update, i thought it was two, but my heart says 3).

If you don't have to store all of your text somewhere, you can probably derive the letters by their indicies (i=0 is the same as i=A, i=1 is the same as i=B).

It's not a solution, but if you take a look at some graphing algorithm chapters, it may give you some ideas.

my @arr = (1..100);
foreach my $i (0..@arr-1) {
   foreach my $j (0..@arr-1) {
      next if $i == $j;
      print "$arr[$i],$arr[$j]\n";
   }
}
[download]