Miré el Github de cierto maestro en los últimos dos días y supe que estaba más interesado en los algoritmos. Después de leer uno de los algoritmos de paso para calcular los números, sentí que esto era un poco interesante, así que me di cuenta de uno solo.
Algoritmo Descripción e principio de implementación
Dado un número entero, cuente cuántas formas de moverse puede alcanzar la meta, como un número 4, hay las siguientes formas de moverse
La copia del código es la siguiente:
[1, 3]
[4]
[1, 1, 2]
[ Veintidós ]
[1, 1, 1, 1]
De hecho, las siguientes conclusiones se pueden sacar a través de la combinación anterior.
1. Primera lista Todos los elementos son combinaciones de 1
2. Combinación de 1 de izquierda a derecha
3. Encierre recursivamente el índice de 1 en el elemento, y luego calcule el valor de 2 elementos desde la izquierda, y recursivamente esta operación
4. Excluir situaciones de 1 y 2
Aquí hay tres funciones de herramientas:
La copia del código es la siguiente:
// Calcule los valores en la matriz
función calcular (arg) {
return eval (arg.join ('+'));
}
// emite el valor de la matriz
function print (arg) {
para (var i = 0; i <arg.length; i ++) {
console.log (arg [i]);
}
}
// Verifique si es de la manera correcta o incorrecta
function hasrepeat (src, dist) {
if (dist.length! = 2) return false;
para (var i = 0, len = src.length; i <len; i ++) {
if (dist.length == src [i] .length) {
if (dist [0] == src [i] [1]) {
devolver verdadero;
}
}
}
devolver falso;
}
La siguiente es una implementación del algoritmo:
La copia del código es la siguiente:
function CountSteps (n) {
VAR cuenta = 0, i, j = 0;
resultado var = [];
var newResult = [];
var fuente = [];
var temperg = [];
// Generar una matriz con todos los elementos de 1
para (i = 1; i <= n; i ++) {
fuente.push (1);
}
if (n> 2) {
para (j = 1; j <n - 1; j ++) {
TEMPARG.LENGHT = 0;
if (j <n - 1) {
// Generar una matriz con 1 incrementos de izquierda a derecha
// 1 .. 11 .. 111 ..
Array.prototype.push.apply (temperg, fuente.slice (0, j));
TEMPARG.PUSH (calculación (fuente.slice (j, n)));
result.push (tempg.slice (0));
// El contenido en la matriz recursiva hasta que no haya 1 en el artículo
combinar (tempg.slice (0));
}
}
}
// Combinar elementos de matriz que contienen 1
// 111-> 21-> 3
función combinar (arg) {
var linealg = [];
para (var i = 0; i <arg.length; i ++) {
if (arg [i] == 1) {
if (i == 0 || i == 1) {
linealg.push (calcular (arg.slice (0,2)));
Array.prototype.push.apply (linealg, arg.slice (2, arg.length));
if (! HasRepeat (resultado, linealg)) {
resultado.push (linealg);
combinar (linealg.slice (0));
}
devolver;
}
}
}
}
// Cuando son 2, hay más de 1
if (n == 2) {
resultado.push ([2]);
}
// Agregar todo 1
resultado.push (fuente);
// emitir todos los pasos
imprimir (resultado);
console.log ('Hay' en total: ' + resultado.length +' s forma de caminar ');
}
// Correr
countsteps (4);
// emite el siguiente contenido
/*
[1, 3]
[4]
[1, 1, 2]
[ Veintidós ]
[1, 1, 1, 1]
Hay 5 tipos de caminata en total
*/
Resumir
Este algoritmo en realidad se puede aplicar a ciertos tipos de juegos. Cuando la distancia entre dos objetos es cierta, se puede realizar todo el procesamiento posible y, por supuesto, también se puede aplicar a otros lugares. Aunque la mayoría de los ingenieros front-end tienen menos prácticas con los algoritmos, todavía tiene valor. Muchos detalles de la UI realmente usan algoritmos. Publicaré más artículos sobre algoritmos cuando tenga tiempo. Todos son bienvenidos a darme algunas sugerencias valiosas.