2


4

Boucle imbriquée dynamique

Je suis relativement nouveau en programmation. Comme le titre le suggère, j’ai besoin d’un algorithme qui me permet d’obtenir la même fonction d’une boucle imbriquée variable. i.e.

for(..)
{ for(..){
for(..){....}
.
.
}}

Le nombre de boucles imbriquées varie en fonction de l’entrée utilisateur. Ce que j’essaie de réaliser, c’est de trouver toutes les combinaisons de nombres (10,9,8,7,6,5,4). Maintenant j’en ai lu beaucoup. Soit je ne les comprends pas complètement (je suis nouveau dans le monde de la programmation), soit cela ne sert pas mon but. J’ai besoin de ces combinaisons plus tard dans certains calculs et pas seulement d’imprimer toutes les combinaisons. Une façon, comme je l’ai appris, est d’utiliser la récursivité. Je ne le comprends pas bien. J’ai essayé de créer une fonction récursive mais j’ai échoué lamentablement. C’est ce que je veux

10 10 10
10 10 9
10 10 8
.
.
.
4  4  4

Le nombre peut changer (comme 10 10 10 10, 10 10 10 9 .. ) Ces combinaisons doivent être stockées dans un tableau car j’ai besoin qu’elles soient manipulées plus tard. Veuillez rester simple et commenter.

La langue préférée sera java. N’importe quelle langue fera l’affaire. Un algorithme général est fortement recommandé. P.S. Ce n’est pas un devoir.

Merci à amit. Voici le code de travail

def findcombinations(array,n,sol,tt=[]):
    if (n== 0):
        tt.append(sol[:])
        return
    for x in array:
        sol.append(x)
        findcombinations(array,n-1,sol,tt)
        del sol[-1]
    return tt

Pour appeler la fonction, utilisez print (findcombinations ([1,2], 3, []))

3 Answer


3


Habituellement, lorsque vous avez besoin de "boucles dynamiques" - c’est une forte indication que vous avez réellement besoin de recursion.

Par exemple, trouver toutes les combinaisons possibles de taille «n» de chiffres dans le tableau [pseudo-code]:

findCombinations(array,n,sol):
   if (sol.size == n): //stop condition for the recursion
      print sol
      return
   for each x in array:
      sol.append(x)
      findCombinations(array,n-1,sol) //recursive call
      sol.removeLast() //cleaning up environment

Le pseudo-code ci-dessus trouvera et imprimera toutes les séquences de longueur «n» faites à partir d’éléments de «tableau» [chaque élément peut apparaître plus d’une fois]


3


Vous avez donc un ou plusieurs (enfin, peut-être trois ou plus) numéros, qui devraient pouvoir aller de 4 à 10? Une façon de le faire serait d’avoir un simple compteur et une fonction transformant votre compteur en un tableau de nombres.

En pseudo-code:

counter_to_array(counter, positions):
  var array = new array(positions)

  for 0 <= i < positions:
    n = counter % 7
    counter = counter // 7  # INTEGER DIVISION
    array[i] = 4 + n

  return array

Autrement dit, votre tableau est implicite dans un compteur et vous pouvez le recréer au besoin. Ce n’est peut-être pas ce dont vous avez réellement besoin et comme écrit, les tableaux iraient "4 4 4" "5 4 4" "6 4 4" …​ "10 10 9" "10 10 10", mais changer cet ordre est aussi aussi simple que de changer l’ordre dans lequel les positions du tableau sont remplies.

Exemple travaillé: Nous voulons générer un compteur à 4 éléments, le 11ème.

  1. Nous créons un tableau à 4 éléments, appelé tableau.

  2. Nous parcourons les positions du tableau:

  3. Nous mettons le tableau [0] à 8 (4 + (11 mod 7)))

  4. Nous mettons le compteur à 1 (11 div 7)

  5. Nous mettons le tableau [1] à 5 (4 + (1 mod 7))

  6. Nous mettons le compteur à 0 (1 div 7)

  7. Nous mettons le tableau [2] à 4

  8. Nous mettons le tableau [3] à 4

Ainsi, le 11e tableau serait [8 5 4 4]


1


Une solution qui utilise une boucle while est donnée ci-dessous. Le code est en C ++ et nécessite # pour les instructions include et define

include
define MAXROWS 9
define MAXVALUES 9

using namespace std;
char display[] = {'1','2','3','4','5','6','7','8','9'};

int main() {

int arrs[MAXROWS];  // represent the different variables in the for loops

bool status = false;

for (int r=0;r=0) {
        // increment the innermost variable and check if spill overs
        if (++arrs[r] > MAXVALUES-1) {
            arrs[r] = 0;  // reintialize loop variable
            // Change the upper variable by one
            // We need to increment the immediate upper level loop by one
            change = true;
        }
        else
            change = false; // Stop as there the upper levels of the loop are unaffected

        // We can perform any inner loop calculation here arrs[r]

        r=r-1;  // move to upper level of the loop

    }

}

[Link]http://www.codeproject.com/Tips/759707/Generating-dynamically-nested-loops Il montre comment une simple boucle imbriquée multiple peut être convertie en une boucle dynamique sans utiliser de récursivité.