Längste gemeinsame Teilfolge (LCS) in PHP

Längste gemeinsame Teilfolge – Rekursive Umsetzung des LCS Problems in PHP – 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;

?>

Erklärung der Pfeile

Rekonstruktion der Ergebnisreihenfolge

Längste gemeinsame Teilfolge (LCS) in PHP
https://algorithms.tutorialhorizon.com/dynamic-programming-longest-common-subsequence/

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%

Bewerte diesen Artikel

0 Bewertung(en), Durchschnitt: 0 von 5

Dieser Artikel wurde noch nicht bewertet.

Es tut uns leid, dass dir der Beitrag nicht gefallen hat.

Lass uns diesen Artikel überarbeiten.

Erzähle uns, was dir nicht gefallen hat.

Verwandte Beiträge
PHP XPATH – Select multiple classes

How to select multiple css classes in PHP XPATH: To parse the marked line at the

Yahoo Finance – Parse stock name

How to parse the stock name in Yahoo Finance? Yahoo Finance Script This script will open

Yahoo Finance – Parse Stock Currency

How to parse the stock currency in Yahoo Finance? You can use the following script This

Linux Server – Kill Switch per HTTP

Anleitung: Den kompletten Linux Server per einfachem HTTP Browser Aufruf herunterfahren (Kill Switch). Funktioniert auch aus

Matrix Kettenmultiplikation in PHP

Umsetzung der Matrix Kettenmultiplikation in der Programmiersprache PHP. Beispiele Klammerungen, Feststellungen, Laufzeit und Programmcode. Wenn man

Matrix Multiplikation in PHP inklusive Code

Zwei Matrizen miteinander Multiplizieren in PHP. Unterschiedliche Dimensionen, Laufzeitbetrachtung und Ausgabe des zweidimensionalen Arrays. Hier der

Hinterlasse einen Kommentar

  Abonnieren  
Benachrichtige mich bei
Scroll to Top