Codewars Lösung | The observed PIN

Als Erstes brauchen wir eine Hilfsfunktion um die Nachbar-Ziffern zu bekommen. Man könnte das auch hardcoden, aber ich entscheide mich für die gecodete Version.

In der Hilfsfunktion definieren wir uns erst mal das Keypad mit den Zahlen. Z.B. als 2-dimensionales Array.

Dann können wir durch das Keypad loopen. Wenn wir die Reihe mit der gesuchten Zahl gefunden haben geht’s weiter.

Dann schnappen wir uns die beiden Zahlen links und rechts davon und dann die Zahlen drüber und drunter.

Das kommt alles in ein Array, das wir dann zurückgeben.

Zurück in unserer Hauptfunktion loopen wir als Erstes durch die beobachteten Input-Ziffern.

Für jede Ziffer lassen wir unsere Hilfsfunktion laufen und speichern sämtliche Ziffern mit ihren Nachbarn in einem 2-dimensionalen Array.

Dann loopen wir durch dieses 2-dimensionale Array.

Im ersten Schritt kombinieren wir das erste Innere-Array mit dem zweiten inneren Array. So dass wir danach ein Array mit 2-stelligen Zahlen erhalten.

Im nächsten Schritt kombinieren wir dieses Array mit dem nächsten inneren Array bis wir durch alle inneren Arrays durch sind. Es bietet sich wahrscheinlich an diese Kombinations-Arie in eine weitere Hilfsfunktion auszulagern.

Nach dem Loop können wir dann einfach das Ergebnis-Array mit den Kombinationen zurückgeben.

function getNeighbours(key) {

const keypad = [
  ["1", "2", "3"],
  ["4", "5", "6"],
  ["7", "8", "9"],
  ["", "0", ""],
];

    .reduce((acc, row, i) => {

Hier bietet sich ein .reduce() mit einem Array als Startwert an. Du kannst es aber auch gerne mit einem .forEach() und einem Ergebnis-Array machen.

      if (row.includes(key)) {

const j = row.indexOf(key);
const prevRow = keypad[i - 1];
const nextRow = keypad[i + 1];

const numLeft = row[j - 1];
const numRight = row[j + 1];
const numUp = prevRow ? prevRow[j] : null;
const numDown = nextRow ? nextRow[j] : null;

Der Lesbarkeit halber erstelle ich mir zuerst ein paar Variablen.

Den Index der gefunden Zahl in der aktuellen Reihe speichern wir uns als j. Außerdem können wir uns die vorige und die nächste Reihe speichern.

Dann schnappen wir uns die eigentlichen Nachbarn. Wenn es keinen linken oder rechten Nachbarn gibt, bekommen wir undefined zurück. Das ist erst mal OK und sogar so gewollt.

Für den oberen bzw. unteren Nachbarn müssen wir erst mal checken, ob die jeweilige Reihe überhaupt existiert. Wenn nicht, speichern wir uns null an diese Stelle.

        acc.push(key, numLeft, numRight, numUp, numDown);
      }

      return acc;
    }, [])

    .filter((num) => num);
}

Auch leere Strings (””) sind möglich, wenn der Nachbar in der letzten Reihe gesucht wurde.

Mit .filter((num) => num) behalten wir nur die Werte, die nicht falsy sind. Damit fliegen alle undefineds, nulls und ””s raus. Perfekt!

Das war das getNeighbours-Helferlein, weiter geht’s mit der Hauptfunktion:

function getPINs(observed) {

const allPossibleDigits = [...observed].map((digit) => getNeighbours(digit));

Für jede Ziffer lassen wir unsere Hilfsfunktion laufen und speichern die Ziffer mit ihren Nachbarn in einem Array.

Wir erhalten also ein Array mit Arrays. Ein ein 2-dimensionales Array.

if (observed.length === 1) return allPossibleDigits[0];

Wenn es nur eine war, brauchen wir gar nicht weiter rumrödeln. Dann geben wir direkt diese Zahl mit ihren Nachbarn zurück und beenden damit die Funktion. Diese stecken im ersten inneren Array unseres 2-dimensionalen Arrays.

Ansonsten geht’s weiter!

let pins;

  for (let i = 0; i < allPossibleDigits.length - 1; i++) {

Zur Erinnerung: Wir loopen hier durch ein 2-dimensionales Array.

Da wir uns immer das aktuelle und das nächste Array schnappen und zusammenführen wollen, müssen wir 1x weniger loopen, als wir Elemente in allPossibleDigits haben. Denn in der letzten Iteration gibt es kein nächstes Element mehr. Und das würde fieses Kuddelmuddel geben...

const currArr = pins || allPossibleDigits[i];
const nextArr = allPossibleDigits[i + 1];

Wenn wir zwei Arrays miteinander kombiniert haben, wollen wir immer das neu entstandene Array als Grundlage für unsere nächste Kombination verwenden.

Das erreichen wir, indem wir unser aktuelles Array currArr immer auf unser Ergebnis-Array setzen. Außer in der ersten Runde, wenn unser Ergebnis-Array pins noch leer bzw. undefined ist. Da setzen wir es auf das erste Array von unseren allPossibleDigits.

    pins = getAllCombosFrom2Arrs(currArr, nextArr);
  }

  return pins;
}

Müssen wir also nur noch unsere zweite Hilfsfunktion getAllCombosFrom2Arrs- basteln. Easy. Endspurt - los geht’s!

function getAllCombosFrom2Arrs(strs1, strs2) {

Ich habe die Parameter hier strs1 und strs2 genannt, weil diese Funktion beliebige Strings kombinieren kann.

const newStrs = [];

  strs1.forEach((str1) => {

    strs2.forEach((str2) => newStrs.push(str1 + str2));
  });

Alles klar? Gut!

Für jedes Element in strs2 hängen wir jetzt die Kombination des jeweils aktuellen Elements aus strs1 und strs2 an unser Ergebnis-Array. Cool!

  return newStrs;
}

Aber geschafft!

Respekt wenn du bis hier durchgehalten hast!

Fragen?