J'ai regardé le github d'un certain maître au cours des deux derniers jours et je savais qu'il était plus intéressé par les algorithmes. Après avoir lu l'un des algorithmes de pas pour calculer les nombres, j'ai senti que c'était un peu intéressant, donc j'en ai réalisé un seul.
Principe de description et de mise en œuvre de l'algorithme
Compte tenu d'un numéro entier, comptez le nombre de façons de déplacer peut atteindre l'objectif, comme un numéro 4, il existe les moyens suivants de déplacer
La copie de code est la suivante:
[1, 3]
[4]
[1, 1, 2]
[Vingt-deux]
[1, 1, 1, 1]
En fait, les conclusions suivantes peuvent être tirées par la combinaison ci-dessus.
1. Première liste tous les éléments sont des combinaisons de 1
2. Combinaison de 1 de gauche à droite
3. Trouvez de manière récursive l'indice de 1 dans l'élément, puis calculez la valeur de 2 éléments de la gauche, et récursivement cette opération
4. Exclure les situations de 1 et 2
Voici trois fonctions d'outil:
La copie de code est la suivante:
// Calculez les valeurs dans le tableau
Fonction Calcule (arg) {
return eval (arg.join ('+'));
}
// Sortie de la valeur du tableau
fonction print (arg) {
pour (var i = 0; i <arg.length; i ++) {
console.log (arg [i]);
}
}
// Vérifiez si c'est le bon ou le mauvais sens
fonction hasrepeat (src, dist) {
if (dist.length! = 2) return false;
pour (var i = 0, len = src.length; i <len; i ++) {
if (dist.length == src [i] .length) {
if (dist [0] == src [i] [1]) {
Retour Vrai;
}
}
}
retourne false;
}
Ce qui suit est une implémentation de l'algorithme:
La copie de code est la suivante:
fonction countSteps (n) {
var compts = 0, i, j = 0;
var result = [];
var newResult = [];
var source = [];
var temparg = [];
// générer un tableau avec tous les éléments de 1
pour (i = 1; i <= n; i ++) {
source.push (1);
}
if (n> 2) {
pour (j = 1; j <n - 1; j ++) {
TemARG.Length = 0;
if (j <n - 1) {
// générer un tableau avec 1 incréments de gauche à droite
// 1 .. 11 .. 111 ..
Array.prototype.push.apply (TemARG, source.slice (0, j));
TEMPARG.PUSH (Calculer (source.slice (J, N)));
result.push (TemARG.slice (0));
// le contenu dans le tableau récursif jusqu'à ce qu'il n'y ait pas de 1 dans l'article
combiner (temparg.slice (0));
}
}
}
// combine des éléments de tableau contenant 1
// 111-> 21-> 3
fonction combine (arg) {
var linearg = [];
pour (var i = 0; i <arg.length; i ++) {
if (arg [i] == 1) {
if (i == 0 || i == 1) {
linearg.push (calculer (arg.slice (0,2)));
Array.prototype.push.apply (linearg, arg.slice (2, arg.length));
if (! HasRepeat (résultat, linearg)) {
result.push (linearg);
combiner (linearg.slice (0));
}
retour;
}
}
}
}
// Quand il est 2, il y en a plus de 1
if (n == 2) {
résultat.push ([2]);
}
// Ajouter tous les 1
result.push (source);
// Sortie toutes les étapes
imprimer (résultat);
Console.log («Il y a« dans le total: «+ result.length +« Some de marche »);
}
// Courir
CountSteps (4);
// Sortie du contenu suivant
/ *
[1, 3]
[4]
[1, 1, 2]
[Vingt-deux]
[1, 1, 1, 1]
Il y a 5 types de marche au total
* /
Résumer
Cet algorithme peut en fait être appliqué à certains types de jeux. Lorsque la distance entre deux objets est certaine, tout le traitement possible peut être effectué, et bien sûr, il peut également être appliqué à d'autres endroits. Bien que la plupart des ingénieurs frontaux aient moins de pratiques avec des algorithmes, il a toujours de la valeur. De nombreux détails d'interface utilisateur utilisent réellement des algorithmes. Je publierai plus d'articles sur les algorithmes quand j'aurai le temps. Tout le monde est invité à me donner de précieuses suggestions.