Längste gemeinsame Teilfolge (LCS) in PHP

Rekursive Umsetzung des LCS Problems in PHP (Längste gemeinsame Teilfolge) – Hauptprogramm, Initialisierung, Berechnung der LCS Anzahl und Ausgabe der Folge.

https://en.wikipedia.org/wiki/Longest_common_subsequence_problem

https://de.wikipedia.org/wiki/Optimierungsproblem

https://de.wikipedia.org/wiki/Dynamische_Programmierung

Hauptprogramm – lcs.php

  • Einbinden aller Hilfsfunktionen
  • Deklaration der LCS Folgen $x und $y
  • LCS Indizes sollen mit 1 und nicht mit 0 starten
  • Deswegen Leerzeichen und Trennung des Strings in ein Array
  • Aufruf der Initialisierungsmethode
  • Ausgabe der zweidimensionalen Matrix $c und $b
  • $c enthält die Anzahl an gefundenen LCS (Integer)
  • $b enthält den Pfad / Pfeile zur Ausgabe der Zeichenkette der Lösung
  • Funktionsaufruf zur Ausgabe der Lösung
<?php

include("Gib_LCS_aus.php");
include("LCS_initial.php");
include("LCS_rekursiv.php");

// First Element must be empty space
$x = " ABCBDAB";
$y = " BDCABA";

// Convert String to Array
$x = str_split($x, 1);
$y = str_split($y, 1);
// Delete the first Element - empty space
// Let the Array beginn with index 1 - first character
unset($x[0]);
unset($y[0]);

LCS_initial($x, $y, $c, $b);

print_r($c);
print_r($b);


$ausgabe = Gib_LCS_aus($x, $b, sizeof($x), sizeof($y));
echo $ausgabe;

?>

Initialisierungsprogramm – LCS_initial.php

  • Zweidimensionales Array $c initialisieren (Speicherung der Anzahl an gefundenen LCS)
  • Erste Spalte und Zeile des Arrays $c muss 0 sein, da hieraus alle anderen Werte abgeleitet werden
  • und zudem es bei der Länge 0 keine gefundene LCS geben kann, erst ab Länge 1
  • Alle anderen Werte mit -1 initialisieren (Normaler Wertebereich ab 0)
  • Ausgabe der Arrays mit den beiden LCS Folgen $x und $y
  • Aufruf der LCS_rekursiv Funktion zur Ermittlung der Anzahl an gefundenen Übereinstimmungen
  • Ausgeben des Integer Wertes (Anzahl gefundene LCS)
<?php

function LCS_initial($x, $y, $c, $b) {

  echo "Funktionsaufruf LCS_initial mit Parametern x $x y $y c $c b $b\n";

  // Erste Spalte ist Null
  // Bei Laenge 0 gibt es keine LCS
  for($i = 0; $i < sizeof($x); $i++) {
    $c[$i][0] = 0;
  }

  // Erste Zeile ist Null
  for($j = 1; $j < sizeof($y); $j++) {
    $c[0][$j] = 0;
  }

  // Alle anderen Werte werden mit -1 initialisiert
  for($i = 1; $i < sizeof($x); $i++) {
    for($j = 1; $j < sizeof($y); $j++) {
      $c[$i][$j] = -1;
    }
  }

  echo "Funktionsaufruf LCS_rekursiv mit Parametern x $x y $y c $c b $b\n";
  echo "sizeof x ".sizeof($x)." sizeof y ".sizeof($y)."\n";

  print_r($x);
  print_r($y);

  $anzahl = LCS_rekursiv($x, $y, $c, $b, sizeof($x), sizeof($y));
  echo "LCS Anzahl ist $anzahl\n";

}

?>

Berechnung der LCS Anzahl – LCS_rekursiv.php

  • Wenn der Wert von $c[$i][$j] bereits bestimmt wurde, ist dieser größer als -1
  • dann kann man sich die erneute Berechnung sparen
  • $i und $j dürfen nicht negativ sein, da $i die aktuelle Position auf Array $x und $j für $y widerspiegelt
  • Wenn die beiden realen LCS Zeichen übereinstimmen wurde ein Ergebnis gefunden
  • erhöhe die Anzahl in Ergebnismatrix $c um eins (bei jeder Erhöhung wurde eine weitere LCS gefunden)
  • Wenn Zeichen übereinstimmen berechnet sich der Wert aus dem Zeichen oben links (diagonal davon) + 1
  • Speichere den Pfeil als „d“ ab – diagonal / oben links
  • Wird für die Rückführung auf die Ergebnis Zeichenkette benötigt
  • Wenn Zeichen nicht übereinstimmen prüfe den Wert links und überhalb – der eigentliche Rekursionsschritt
  • Übernehme das Maximum aus Zeichen links und überhalb (Speichere Pfeil links oder oben)
  • Schritt weiter bis wieder ein übereinstimmendes Zeichen gefunden wurde oder die ursprüngliche Zeichenkette endet
<?php

// Komplexitaet Theta n mal m

// Kodierung der Pfeile / Pfade - b
// links - l
// oben - o
// links oben / diagonal - d

// x ist Zeichenkette / eindimensionales Array Nummer 1
// y ist Zeichenkette / eindimensionales Array Nummer 2
// c ist das zweidimensionale Array mit der Laenge der LCS (integer Werte)
// b ist das zweidimensionale Array mit Richtungen der Pfeile (links, oben, oben links / diagonal)
// Die Pfeile werden benoetigt um die Ergebnis Folge korrekt auszugeben
// i ist die aktuelle Position auf dem Array x
// j ist die aktuelle Position auf dem Array y

function LCS_rekursiv($x, $y, $c, $b, $i, $j) {

  global $c, $b;

  echo "Funktionsaufruf LCS_rekursiv mit Parametern x $x y $y c $c b $b i $i j $j\n";
  //print_r($c);

  // Wenn Wert schon berechnet - direkt zurueckgeben ohne erneute Berechnung
  if($c[$i][$j] > -1) {
    return $c[$i][$j];
  }

// i oder j darf nicht negativ sein - echt groesser
if($i > 0 && $j > 0) {
  // Wenn Zeichen uebereinstimmen - LCS gefunden - Wert oben links + 1 und in c abspeichern
  // In b wird Nummer 3 abgespeichert - Nummer 3 steht fuer einen Pfeil nach oben links
  if($x[$i] == $y[$j]) {
   $c[$i][$j] = LCS_rekursiv($x, $y, $c, $b, $i - 1, $j - 1) + 1;
   echo "Zeichen gleich i $i j $j c i j ".$c[$i][$j]."\n";
   $b[$i][$j] = "d";
  }
  // Wenn Zeichen nicht uebereinstimmen
  else {
    // Berechne Wert links davon
    $a = LCS_rekursiv($x, $y, $c, $b, $i - 1, $j);
    // Berechne Wert oberhalb
    $d = LCS_rekursiv($x, $y, $c, $b, $i, $j - 1);

    // Wenn linker Wert groesser als Wert oberhalb
    if($a >= $d) {
      $c[$i][$j] = $a;
      // Speichere Pfeil nach links - Kodiert als 1
      $b[$i][$j] = "l";
    }
    else {
      $c[$i][$j] = $d;
      // Speichere Pfeil nach oben - Kodiert als 2
      $b[$i][$j] = "o";
    }
}
  return $c[$i][$j];

  }

}

?>

Ausgabe der LCS Folge

  • Aus der Matrix mit den Pfeilen $b kann die Ergebnisfolge extrahiert werden
  • Nullen müssen nicht betrachtet werden – keine LCS gefunden
  • Wenn ein diagonaler Pfeil gefunden wurde (zeigt nach oben links) wurde der erste LCS Wert gefunden (Char aus Array $x)
  • Sonst wird bei einem linken Pfeil weiter nach links gelaufen ($i – 1)
  • oder bei einem Pfeil nach oben dieser Weg weiter gegangen
<?php

// Komplexitaet Theta n + m

function Gib_LCS_aus($x, $b, $i, $j) {

  echo "Funktionsaufruf Gib_LCS_aus x $x b $b i $i j $j\n";

  if($i == 0 OR $j == 0) {
    return;
  }

  if($b[$i][$j] == "d") {
    Gib_LCS_aus($x, $b, $i - 1, $j - 1);
    echo $x[$i];
  }
  else {
    if($b[$i][$j] == "l") {
      Gib_LCS_aus($x, $b, $i - 1, $j);
    }
    else {
      Gib_LCS_aus($x, $b, $i, $j - 1);
    }
  }

}

?>

Programmausgabe

  • Ausgabe der ursprünglichen Zeichenfolge $x und $y beginnend mit Stelle 1
  • Viele rekursive Funktionsaufrufe
  • Finden eines doppelt vorkommenden Zeichens
  • Ausgabe der LCS Anzahl 4 – in diesem Fall mit den $x und $y Werten
  • Ausgabe der Matrix $c mit der Anzahl an gefundenen LCS
  • Ausgabe der Matrix $b mit den Pfeilen / dem Weg zur Ergebnisfolge der Char Stellen des Arrays
  • Ausgabe der Funktionsaufrufe / dem Weg zum Ziel der Pfeile
  • Ausgabe der Lösung BCBA – in diesem Fall $x und $y
mathias@Mathiass-MacBook-Pro ALGORI % php -f lcs.php
Funktionsaufruf LCS_initial mit Parametern x Array y Array c  b
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b
sizeof x 7 sizeof y 6
Array
(
    [1] => A
    [2] => B
    [3] => C
    [4] => B
    [5] => D
    [6] => A
    [7] => B
)
Array
(
    [1] => B
    [2] => D
    [3] => C
    [4] => A
    [5] => B
    [6] => A
)
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c  b  i 7 j 6
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c  b  i 6 j 6
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c  b  i 5 j 5
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c  b  i 4 j 5
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c  b  i 3 j 4
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c  b  i 2 j 4
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c  b  i 1 j 4
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c  b  i 0 j 3
Zeichen gleich i 1 j 4 c i j 1
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 2 j 3
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 1 j 3
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 0 j 3
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 1 j 2
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 0 j 2
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 1 j 1
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 0 j 1
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 1 j 0
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 2 j 2
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 1 j 2
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 0 j 2
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 1 j 1
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 0 j 1
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 1 j 0
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 2 j 1
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 1 j 0
Zeichen gleich i 2 j 1 c i j 1
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 3 j 3
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 2 j 2
Zeichen gleich i 3 j 3 c i j 2
Zeichen gleich i 4 j 5 c i j 3
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 5 j 4
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 4 j 4
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 3 j 4
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 4 j 3
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 3 j 3
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 4 j 2
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 3 j 2
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 2 j 2
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 3 j 1
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 2 j 1
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 3 j 0
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 4 j 1
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 3 j 0
Zeichen gleich i 4 j 1 c i j 1
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 5 j 3
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 4 j 3
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 5 j 2
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 4 j 1
Zeichen gleich i 5 j 2 c i j 2
Zeichen gleich i 6 j 6 c i j 4
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 7 j 5
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 6 j 4
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 5 j 3
Zeichen gleich i 6 j 4 c i j 3
Zeichen gleich i 7 j 5 c i j 4
LCS Anzahl ist 4
Array
(
    [1] => Array
        (
            [4] => 1
            [1] =>
            [2] =>
            [3] =>
        )

    [2] => Array
        (
            [1] => 1
            [2] => 1
            [3] => 1
            [4] => 1
        )

    [3] => Array
        (
            [3] => 2
            [4] => 2
            [1] => 1
            [2] => 1
        )

    [4] => Array
        (
            [5] => 3
            [1] => 1
            [2] => 1
            [3] => 2
            [4] => 2
        )

    [5] => Array
        (
            [2] => 2
            [3] => 2
            [4] => 2
            [5] => 3
        )

    [6] => Array
        (
            [6] => 4
            [4] => 3
        )

    [7] => Array
        (
            [5] => 4
            [6] => 4
        )

)
Array
(
    [1] => Array
        (
            [4] => d
            [1] => l
            [2] => l
            [3] => l
        )

    [2] => Array
        (
            [1] => d
            [2] => o
            [3] => o
            [4] => l
        )

    [3] => Array
        (
            [3] => d
            [4] => o
            [1] => l
            [2] => l
        )

    [4] => Array
        (
            [5] => d
            [1] => d
            [2] => l
            [3] => l
            [4] => l
        )

    [5] => Array
        (
            [2] => d
            [3] => l
            [4] => l
            [5] => l
        )

    [6] => Array
        (
            [6] => d
            [4] => d
        )

    [7] => Array
        (
            [5] => d
            [6] => l
        )

)
Funktionsaufruf Gib_LCS_aus x Array b Array i 7 j 6
Funktionsaufruf Gib_LCS_aus x Array b Array i 6 j 6
Funktionsaufruf Gib_LCS_aus x Array b Array i 5 j 5
Funktionsaufruf Gib_LCS_aus x Array b Array i 4 j 5
Funktionsaufruf Gib_LCS_aus x Array b Array i 3 j 4
Funktionsaufruf Gib_LCS_aus x Array b Array i 3 j 3
Funktionsaufruf Gib_LCS_aus x Array b Array i 2 j 2
Funktionsaufruf Gib_LCS_aus x Array b Array i 2 j 1
Funktionsaufruf Gib_LCS_aus x Array b Array i 1 j 0
BCBA%

Test mit anderen Folgen

Hauptprogramm wird für $x und $y angepasst. Andere Funktionsdateien bleiben gleich.

<?php

include("Gib_LCS_aus.php");
include("LCS_initial.php");
include("LCS_rekursiv.php");

// First Element must be empty space
//$x = " ABCBDAB";
//$y = " BDCABA";

$x = " 10010101";
$y = " 010110110";

// Convert String to Array
$x = str_split($x, 1);
$y = str_split($y, 1);
// Delete the first Element - empty space
// Let the Array beginn with index 1 - first character
unset($x[0]);
unset($y[0]);

LCS_initial($x, $y, $c, $b);

print_r($c);
print_r($b);


$ausgabe = Gib_LCS_aus($x, $b, sizeof($x), sizeof($y));
echo $ausgabe;

?>

Ergebnis der anderen Folgen

mathias@Mathiass-MacBook-Pro ALGORI % php -f lcs.php
Funktionsaufruf LCS_initial mit Parametern x Array y Array c  b
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b
sizeof x 8 sizeof y 9
Array
(
    [1] => 1
    [2] => 0
    [3] => 0
    [4] => 1
    [5] => 0
    [6] => 1
    [7] => 0
    [8] => 1
)
Array
(
    [1] => 0
    [2] => 1
    [3] => 0
    [4] => 1
    [5] => 1
    [6] => 0
    [7] => 1
    [8] => 1
    [9] => 0
)
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c  b  i 8 j 9
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c  b  i 7 j 9
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c  b  i 6 j 8
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c  b  i 5 j 7
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c  b  i 4 j 7
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c  b  i 3 j 6
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c  b  i 2 j 5
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c  b  i 1 j 5
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c  b  i 0 j 4
Zeichen gleich i 1 j 5 c i j 1
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 2 j 4
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 1 j 4
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 0 j 3
Zeichen gleich i 1 j 4 c i j 1
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 2 j 3
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 1 j 2
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 0 j 1
Zeichen gleich i 1 j 2 c i j 1
Zeichen gleich i 2 j 3 c i j 2
Zeichen gleich i 3 j 6 c i j 3
Zeichen gleich i 4 j 7 c i j 4
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 5 j 6
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 4 j 5
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 3 j 4
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 2 j 4
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 3 j 3
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 2 j 2
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 1 j 2
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 2 j 1
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 1 j 0
Zeichen gleich i 2 j 1 c i j 1
Zeichen gleich i 3 j 3 c i j 2
Zeichen gleich i 4 j 5 c i j 3
Zeichen gleich i 5 j 6 c i j 4
Zeichen gleich i 6 j 8 c i j 5
Zeichen gleich i 7 j 9 c i j 6
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 8 j 8
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 7 j 7
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 6 j 7
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 5 j 6
Zeichen gleich i 6 j 7 c i j 5
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 7 j 6
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 6 j 5
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 5 j 4
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 4 j 4
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 3 j 3
Zeichen gleich i 4 j 4 c i j 3
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 5 j 3
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 4 j 2
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 3 j 1
Funktionsaufruf LCS_rekursiv mit Parametern x Array y Array c Array b Array i 2 j 0
Zeichen gleich i 3 j 1 c i j 1
Zeichen gleich i 4 j 2 c i j 2
Zeichen gleich i 5 j 3 c i j 3
Zeichen gleich i 6 j 5 c i j 4
Zeichen gleich i 7 j 6 c i j 5
Zeichen gleich i 8 j 8 c i j 6
LCS Anzahl ist 6
Array
(
    [1] => Array
        (
            [5] => 1
            [4] => 1
            [2] => 1
        )

    [2] => Array
        (
            [3] => 2
            [4] => 2
            [5] => 2
            [1] => 1
            [2] => 1
        )

    [3] => Array
        (
            [6] => 3
            [3] => 2
            [4] => 2
            [1] => 1
        )

    [4] => Array
        (
            [7] => 4
            [5] => 3
            [4] => 3
            [2] => 2
        )

    [5] => Array
        (
            [6] => 4
            [7] => 4
            [3] => 3
            [4] => 3
        )

    [6] => Array
        (
            [8] => 5
            [7] => 5
            [5] => 4
        )

    [7] => Array
        (
            [9] => 6
            [6] => 5
            [7] => 5
        )

    [8] => Array
        (
            [8] => 6
            [9] => 6
        )

)
Array
(
    [1] => Array
        (
            [5] => d
            [4] => d
            [2] => d
        )

    [2] => Array
        (
            [3] => d
            [4] => o
            [5] => o
            [1] => d
            [2] => l
        )

    [3] => Array
        (
            [6] => d
            [3] => d
            [4] => l
            [1] => d
        )

    [4] => Array
        (
            [7] => d
            [5] => d
            [4] => d
            [2] => d
        )

    [5] => Array
        (
            [6] => d
            [7] => l
            [3] => d
            [4] => l
        )

    [6] => Array
        (
            [8] => d
            [7] => d
            [5] => d
        )

    [7] => Array
        (
            [9] => d
            [6] => d
            [7] => l
        )

    [8] => Array
        (
            [8] => d
            [9] => l
        )

)
Funktionsaufruf Gib_LCS_aus x Array b Array i 8 j 9
Funktionsaufruf Gib_LCS_aus x Array b Array i 7 j 9
Funktionsaufruf Gib_LCS_aus x Array b Array i 6 j 8
Funktionsaufruf Gib_LCS_aus x Array b Array i 5 j 7
Funktionsaufruf Gib_LCS_aus x Array b Array i 4 j 7
Funktionsaufruf Gib_LCS_aus x Array b Array i 3 j 6
Funktionsaufruf Gib_LCS_aus x Array b Array i 2 j 5
Funktionsaufruf Gib_LCS_aus x Array b Array i 2 j 4
Funktionsaufruf Gib_LCS_aus x Array b Array i 2 j 3
Funktionsaufruf Gib_LCS_aus x Array b Array i 1 j 2
Funktionsaufruf Gib_LCS_aus x Array b Array i 0 j 1
100110%

Hinterlasse einen Kommentar

  Abonnieren  
Benachrichtige mich bei
Scroll to Top