2
votes

Récursif pour la boucle For

J'ai un scénario pour obtenir une sortie comme celle-ci.

value1 = 2, value2 = 2, value3 = 2;
my function () {
    for(var i = 0; i<this.value1; i++) { 
      for(var j = 0; j < this.value2; j++) { 
        for(var k = 0; k < this.value3; k++) { 
           console.log(i,j,k);
        }
      }
    }
}

Quand l'entrée est 3, cela donnerait 8 combinaisons comme ci-dessus. Si l'entrée est 4, il y aurait 16 combinaisons. Je peux y parvenir en utilisant la boucle imbriquée for comme ci-dessous.

C'est bien si c'est pour l'entrée 3, mais je dois obtenir la sortie pour l'entrée 10. Donc J'ai besoin d'écrire 10 boucles for imbriquées comme ci-dessus. Je sais que c'est une mauvaise pratique, je ne sais pas comment utiliser le récursif ici. Veuillez m'aider à ce sujet.

javascript arrays

2 commentaires

Utilisez un tableau. Incrémentez l'élément actuel du tableau, quand il atteint la valeur maximale, enroulez-le autour de 0, puis faites de même pour l'élément suivant.

Array (Math.pow (2,4)). fill (0) .forEach ((_, i) => console.log (i.toString (2))); presque produit la sortie souhaitée pour l'entrée 4. Cette approche pourrait être modifiée pour donner la sortie exacte.

5 Réponses :

2
votes

Voici une fonction récursive qui peut faire le travail requis.

function solveUtil(limits, index, cur) {
    if (index === limits.length) {
        console.log(cur.join(' '));
    } else {

        for (let i = 0; i < limits[index]; i++) {
            cur.push(i);
            solveUtil(limits, index + 1, cur);
            cur.pop();
        }
    }
}

function solve(limits) {
    solveUtil(limits, 0, []);
}

solve(new Array(10).fill(2));

0 commentaires

2
votes

L'approche récursive ressemblerait à ceci:

function recursive(n, range, prefix) {
  prefix = prefix || "";
  if (n == 0)
    console.log(prefix);
  else
    for (let i = 0; i < range; i++)
      recursive(n - 1, range, prefix + " " + i);
}

recursive(10, 2);

0 commentaires

2
votes

Vous pouvez profiter du fait que vous recherchez des combinaisons en binaire et simplement compter à partir de 0 en binaire et ajouter un remplissage.

Cela utilise générateurs de fonctions , mais il est facile de le convertir en une fonction simple.

function * findCombinations(n){
  for(let i = 0; i < Math.pow(2, n); i++){
    const c = i.toString(2);
    const padding = new Array(n - c.length + 1).join('0');
    yield padding + c;
  }
  return null;
}

const iterator = findCombinations(4);
console.log(
  Array.from(iterator)
)

0 commentaires

0
votes

Dans les navigateurs plus récents (qui prennent en charge . padStart ), ce qui suit produit la sortie souhaitée (mais contourne plutôt que résout le problème de récursivité):

let n = 4; //or any other value
    
Array(Math.pow(2,n)).fill(0).forEach((_,i) => console.log(i.toString(2).padStart(n,'0').split('').join(' ')));

0 commentaires

0
votes

Vous pouvez utiliser un Generator avec function * et prenez la combinaison à la volée.

.as-console-wrapper { max-height: 100% !important; top: 0; }

function* binary(length, array = []) {
    if (--length) {
        yield* binary(length, [...array, 0]);
        yield* binary(length, [...array, 1]);
    } else {
        yield [...array, 0];
        yield [...array, 1];
    }
}

[...binary(3)].map(a => console.log(...a));

0 commentaires