Início / coding / Perguntas / 77580603
Accepted
ABGR
Asked: 2023-12-01 01:38:44 +0800 CST

Existe um bloqueio de PIN de 4 dígitos. Os dígitos a serem escolhidos de 0 a 5 para as teclas. Encontre todas as combinações possíveis de teclas

  • 772

O problema é assim:

Existe um bloqueio de PIN de 4 dígitos. Os dígitos devem ser escolhidos entre os dígitos 0-5da chave para desbloquear.

Precisamos encontrar todas as combinações possíveis 0001, 0002, 0003, 0004, como e assim por diante.

javascript

3 respostas

  1. Best Answer

    Você pode criar uma matriz para os dígitos e incrementar os dígitos anteriores até encontrar um que não seja 9, assim como incrementa números em geral:

    let array = [0, 0, 0, 0];
let output = [];
do {
    output.push(array.join(""));
    let digitIndex = 3;
    while ((digitIndex >= 0) && (!(array[digitIndex] = (array[digitIndex] + 1) % 6))) digitIndex--;
} while (array[0] + array[1] + array[2] + array[3]);

console.log(output);

    • 1

  2. Veja como abordar o problema recursivamente.

    Precisamos dividir os problemas em subproblemas e encontrar a solução para o menor subproblema que poderíamos resolver.

    Isso dá o nosso caso base, ou seja, para 0dígito pin teremos""

    Agora vamos dividir o problema em subproblemas e tentar resolvê-los. Tentamos o primeiro dígito do pino com 0, então só temos que resolver o problema para os três dígitos restantes. O mesmo acontece se tentarmos o primeiro dígito 1e assim por diante.

    Então vamos prosseguir com isso

    function findAllCombo(){    
  var res=[];
  function computeRecursively(newStr="", locks, startIndex=0){
  
     //Base case
     if(startIndex === locks.length){
        res.push(newStr);
        return res;
      }

      // The digits have to be choosen form 0-5. So we recursively call for each of the 
      // digits. We can use loop as well.

      computeRecursively(newStr+0, locks, startIndex+1);
      computeRecursively(newStr+1, locks, startIndex+1);
      computeRecursively(newStr+2, locks, startIndex+1);
      computeRecursively(newStr+3, locks, startIndex+1);
      computeRecursively(newStr+4, locks, startIndex+1);
      computeRecursively(newStr+5, locks, startIndex+1);
      
      return res;
  
  }

  //This defines the lock- place to hold each digit
  var locks = new Array(4);
  return computeRecursively("", locks, 0)
}

console.log(findAllCombo())

    • 0

  3. Aqui está a minha abordagem, provavelmente tornei isso mais complicado do que deveria ser. Concentrei-me mais em usar a recursão corretamente (sem variáveis ​​globais e a função retorna o resultado final ou uma chamada para si mesma).

    function recursion(digitsCount, range, currentCombo, results = []) {
  if (!currentCombo) {
    currentCombo = new Array(digitsCount).fill(0);
    results.push(currentCombo.join(''));
  }
  const newCombo = new Array(digitsCount);

  let flag = false;
  for (let i = digitsCount - 1; i >= 0; i--) {
    if (flag || i === digitsCount - 1 && !(i === 0 && currentCombo[0] === (range - 1))) {
      flag = currentCombo[i] === (range - 1);
      newCombo[i] = (currentCombo[i] + 1) % range;
    } else {
      newCombo[i] = currentCombo[i];
    }
  }
  results = [...results, newCombo.join('')];
  if (newCombo.every((n) => n === (range - 1))) {
    return results;
  }
  return recursion(digitsCount, range, newCombo, results);
}


const range = 6; // from 0 to 5 there are 6 digits
const digitsCount = 4;

console.log(recursion(digitsCount, range));

    O forloop ali é necessário (ou, pelo menos, outra função recursiva) se digitsCountpuder ser variável.

    O principal motivador desta abordagem é usar o módulo ( %) e a flagvariável para fazer a contagem rangebaseada (neste caso, baseada em 5 ).

    • 0

relate perguntas