sub combinations
{
  # übernehme die Karten
  my @cards=@_;

  # wenn keine Karten an die Funktion übergeben wurden liefere eine leere Liste zurück
  return [] unless (@cards);

  wenn nur eine Karte in der Liste ist dann liefere nur die Liste zurück
  return \@cards if(@cards==1);

  # erzeuge die liste mit den restlichen Kombinationen:
  my @ret;
  # solange noch karten vorhanden sind:
  while(@cards)
  {
    # nimm die erste Karte heraus
    my $card=shift(@cards);
    
    # füge diese Karte des RückgabeArrays hinzu
    push(@ret,[$card]);

    # rufe die Funktion selber wider auf und gehe das Ergebnis durch (ist ein array)
    # das ist rekursive teil, das die Funktion sich immer wieder selber aufruft,
    # die übergebene liste ist aber immer um ein Element kürzer
    # darum kommt die Rekursion irgendwann zu einem Ende (siehe oben)
    for my $r (combinations(@cards))
    {
      # $r enthält eine Arrayrefenz!
      # füge die herausgenommene Karte wieder ein
      # und füge die das dem RückgabeArray hinzu
      push(@ret,[@$r,$card]) if(@$r);
    }
  }

  # gib das RückgabeArray zurück
  return @ret;
}

aufruf: combinations(1 2 3 4)
  bekomme: 1 2 3 4
  gehe liste durch
    noch 1 2 3 4 in der Liste
    @zurück1 += [ 1 ]

    aufruf combinations(2 3 4)
      bekomme: 2 3 4
      gehe liste durch
        noch 2 3 4 in der Liste
        @zurück2 += [ 2 ]

        aufruf combinations(3 4)
          bekomme: 3 4
          gehe liste durch
            noch 3 4 in der liste
            @zurück3 += [ 3 ]

            aufruf combinations(4)
              bekomme: 4
              gebe ( [ 4 ] ) zurück

            @zurück3 += [ 3 4 ]

            noch 4 in der liste
            @zurück3 += [ 4 ]

            aufruf combinations()
              bekomme: 
              gebe ( [  ] ) zurück
         
          gebe zurück ( [ 3 4 ] [ 4 ] )

        @zurück2 += [ 2 3 4 ]
        @zurück2 += [ 2 4 ]
      
        noch 3 4 in der liste
        @zurück2 += [ 3 ]

        aufruf combinations(4)
          bekomme: 4
          gebe ( [ 4 ] ) zurück

        @zurück2 += [ 3 4 ]

        noch 4 in der liste
        @zurück2 += [ 4 ]

        aufruf combinations()
          bekomme: 
          gebe ( [] ) zurück

       gebe zurück ([ 2 ] [ 2 3 4 ] [ 2 4 ] [ 3 4 ] [ 4 ])
     
    @zurück1 += [ 1 2 ]
    @zurück1 += [ 1 2 3 4]
    @zurück1 += [ 1 2 4 ]
    @zurück1 += [ 1 3 4 ]
    @zurück1 += [ 1 4 ]

    noch 2 3 4 in der liste
    @zurück1 += [ 2 ]

    aufruf combinations( 3 4 )
      bekomme: 3 4
      ...

sub combinations
{
  return [] unless (@_);
  my @ret;
  while(@_)
  {
    my $card=shift(@_);
    push(@ret,[@$_,$card]) for(combinations(@_))
  }
  return @ret;
}

# gegeben sei ein Array mit Arrays:
my @array=(
  [1],
  [1 3 4],
  [1 2 3 4],
  [1 2 3 4],
  [2 3 1 4],
  [4 3 1],
);

# definiere einen Hash,
# der die als Indikator für die doppelten Werte dienen soll:
my %unique;

# das Array für die Werte
# ohne die doppelten
my @unique_array;

# gehe das Array @array durch:
for my $array_ref (@array)
{
  # $array_ref ist eine referenz auf ein Array,
  # das muss etwas anders behandelt werden als ein normales Array.
  # das Array sortieren und gleichzeitig eine Kopie anlegen:
  my @copy=sort(@$array_ref);
  # wenn man ein Array in Doppelte Anführungszeichen setzt,
  # dann fügt Perl dort die elemnte der liste ein.
  # man kann also schreiben
  my $key="@copy";
  # und bekommt einen string den man als Schlüssel verwenden kann.
  # nun wird geprüft ob der String als Schlüssel noch nicht im Hash ist:
  if(!$unique{$key})
  {
    # setze den Schlüssel,
    # damit ein Array mit den selben Werten nicht nochmal eingefügt wird.
    $unique{$key}=1;
    #füge das Array @unique_array hinzu:
    push(@unique_array,\@copy);
    # hier ist es wichtig eine Refenz hinzu zu fügen!
  }
}

# in @unique_array sind nun Arrayrefenzen mit einzigartigen Wertkombinationen

# gegeben sei ein Array mit Arrays:
my @array=(
  [1],
  [1 3 4],
  [1 2 3 4],
  [1 2 3 4],
  [2 3 1 4],
  [4 3 1],
);

my %unique;
my @unique_array=grep{$unique{"".join " ", sort @$_}++}@array;

# in @unique_array sind nun Arrayrefenzen mit einzigartigen Wertkombinationen