Ich schaute mir den GitHub eines bestimmten Meisters in den letzten zwei Tagen an und wusste, dass er mehr an Algorithmen interessiert war. Nachdem ich einen der Stufenalgorithmen für die Berechnung der Zahlen gelesen hatte, war dies ein bisschen interessant, also erkannte ich eine alleine.
Algorithmus Beschreibung und Implementierungsprinzip
Angesichts einer Ganzzahlnummer, zählen Sie, wie viele Möglichkeiten zum Umzug das Ziel erreichen können, z.
Die Codekopie lautet wie folgt:
[1, 3]
[4]
[1, 1, 2]
[Zweiundzwanzig]
[1, 1, 1, 1]
Tatsächlich können die folgenden Schlussfolgerungen durch die obige Kombination gezogen werden.
1. Erstens Liste Alle Elemente sind Kombinationen von 1
2. Kombination von 1 von links nach rechts
3. Ermitteln
4. Ausschließen von Situationen von 1 und 2
Hier sind drei Werkzeugfunktionen:
Die Codekopie lautet wie folgt:
// Berechnen Sie die Werte im Array
Funktion berechnen (arg) {
return eval (arg.join ('+'));
}
// den Wert des Arrays ausgeben
Funktion print (arg) {
für (var i = 0; i <arg.length; i ++) {
console.log (arg [i]);
}
}
// Überprüfen Sie, ob es sich um den richtigen oder falschen Weg handelt
Funktion hasRepeat (src, dist) {
if (dist.length! = 2) return false;
für (var i = 0, len = src.length; i <len; i ++) {
if (dist.length == src [i] .Length) {
if (dist [0] == src [i] [1]) {
zurückkehren;
}
}
}
false zurückgeben;
}
Das Folgende ist eine Implementierung des Algorithmus:
Die Codekopie lautet wie folgt:
Funktion countsteps (n) {
var zählt = 0, i, j = 0;
var result = [];
var newResult = [];
var source = [];
var temparg = [];
// generieren Sie ein Array mit allen Elementen von 1
für (i = 1; i <= n; i ++) {
Source.Push (1);
}
if (n> 2) {
für (j = 1; j <n - 1; j ++) {
temparg.length = 0;
if (j <n - 1) {
// Generieren Sie ein Array mit 1 Schritten von links nach rechts
// 1 .. 11 .. 111 ..
Array.Prototype.push.Apply (temparg, source.slice (0, j));
temparg.push (berechnen (source.slice (j, n)));
result.push (temparg.slice (0));
// Der Inhalt im rekursiven Array, bis es keine 1 im Artikel gibt
kombinieren (temparg.slice (0));
}
}
}
// Array -Elemente mit 1 kombinieren 1
// 111-> 21-> 3
Funktion kombinieren (arg) {
var linearg = [];
für (var i = 0; i <arg.length; i ++) {
if (arg [i] == 1) {
if (i == 0 || i == 1) {
linearg.push (berechnen (arg.slice (0,2)));
Array.prototype.push.apply (linearg, arg.slice (2, arg.length));
if (! hasrepeat (Ergebnis, linearg)) {
result.push (linearg);
kombinieren (linearg.slice (0));
}
zurückkehren;
}
}
}
}
// Wenn es 2 ist, gibt es mehr als 1
if (n == 2) {
result.push ([2]);
}
// Alle 1 hinzufügen
result.push (Quelle);
// Alle Schritte ausgeben
Druck (Ergebnis);
console.log ('Es gibt' insgesamt: ' + result.Length +' S -Weg zum Gehen ');
}
// Laufen
Countsteps (4);
// den folgenden Inhalt ausgeben
/*
[1, 3]
[4]
[1, 1, 2]
[Zweiundzwanzig]
[1, 1, 1, 1]
Insgesamt gibt es 5 Arten des Gehens
*/
Zusammenfassen
Dieser Algorithmus kann tatsächlich auf bestimmte Arten von Spielen angewendet werden. Wenn der Abstand zwischen zwei Objekten sicher ist, kann jede mögliche Verarbeitung durchgeführt werden und kann natürlich auch an andere Orte angewendet werden. Obwohl die meisten Front-End-Ingenieure weniger Praktiken mit Algorithmen haben, hat es immer noch Wert. Viele UI -Details verwenden tatsächlich Algorithmen. Ich werde weitere Artikel über Algorithmen veröffentlichen, wenn ich Zeit habe. Jeder ist herzlich eingeladen, mir einige wertvolle Vorschläge zu geben.