Olhei para o Github de um certo mestre nos últimos dois dias e sabia que ele estava mais interessado em algoritmos. Depois de ler um dos algoritmos de etapa para calcular números, senti que isso era um pouco interessante, então percebi um sozinho.
Descrição do algoritmo e princípio de implementação
Dado um número inteiro, conte quantas maneiras de se mover pode atingir a meta, como um número 4, existem as seguintes maneiras de se mover
A cópia do código é a seguinte:
[1, 3]
[4]
[1, 1, 2]
[ vinte e dois ]
[1, 1, 1, 1]
De fato, as seguintes conclusões podem ser tiradas através da combinação acima.
1. Primeira lista todos os itens são combinações de 1
2. Combinação de 1 da esquerda para a direita
3. Encontre recursivamente o índice de 1 no item e calcule o valor de 2 itens da esquerda e recursivamente esta operação
4. Exclua situações de 1 e 2
Aqui estão três funções da ferramenta:
A cópia do código é a seguinte:
// Calcule os valores na matriz
função calcule (arg) {
retornar avaliar (arg.join ('+'));
}
// emitir o valor da matriz
função print (arg) {
for (var i = 0; i <arg.length; i ++) {
console.log (arg [i]);
}
}
// Verifique se é o caminho certo ou errado
função hasrepeat (src, dist) {
if (dist.length! = 2) retorna false;
for (var i = 0, len = src.length; i <len; i ++) {
if (dist.length == src [i] .Length) {
if (dist [0] == src [i] [1]) {
retornar true;
}
}
}
retornar falso;
}
A seguir, é apresentada uma implementação do algoritmo:
A cópia do código é a seguinte:
funções CountSteps (n) {
var contagem = 0, i, j = 0;
var resultado = [];
var newResult = [];
Var Source = [];
var temparg = [];
// gerar uma matriz com todos os itens de 1
para (i = 1; i <= n; i ++) {
fonte.push (1);
}
if (n> 2) {
for (j = 1; j <n - 1; j ++) {
temparg.length = 0;
if (j <n - 1) {
// gera uma matriz com 1 incrementos da esquerda para a direita
// 1 .. 11 .. 111 ..
Array.prototype.push.apply (temparg, fonte.slice (0, j));
temparg.push (calcular (fonte.slice (j, n)));
resultado.push (temparg.slice (0));
// o conteúdo na matriz recursiva até que não haja 1 no item
Combine (temparg.slice (0));
}
}
}
// combina itens de matriz contendo 1
// 111-> 21-> 3
Função Combine (arg) {
var linearg = [];
for (var i = 0; i <arg.length; i ++) {
if (arg [i] == 1) {
if (i == 0 || i == 1) {
linearg.push (calcule (arg.slice (0,2)));
Array.prototype.push.apply (linearg, arg.slice (2, arg.length));
if (! hasrepeat (resultado, linearg)) {
resultado.push (linearg);
Combine (linearg.slice (0));
}
retornar;
}
}
}
}
// Quando é 2, há mais de 1
if (n == 2) {
resultado.push ([2]);
}
// Adicione tudo 1
resultado.push (fonte);
// Saída de todas as etapas
impressão (resultado);
console.log ('Existem' no total: ' + resultado.length +' s de caminhar ');
}
// Correr
CountSteps (4);
// emitir o seguinte conteúdo
/*
[1, 3]
[4]
[1, 1, 2]
[ vinte e dois ]
[1, 1, 1, 1]
Existem 5 tipos de caminhada no total
*/
Resumir
Esse algoritmo pode realmente ser aplicado a certos tipos de jogos. Quando a distância entre dois objetos é certa, todo o processamento possível pode ser realizado e, é claro, também pode ser aplicado a outros locais. Embora a maioria dos engenheiros de front-end tenha menos práticas com algoritmos, ele ainda tem valor. Muitos detalhes da interface do usuário realmente usam algoritmos. Vou postar mais artigos sobre algoritmos quando tiver tempo. Todos são convidados a me dar algumas sugestões valiosas.