Comment faire de la n des boucles for imbriquées de manière récursive?

J'ai une méthode qui doit faire ce qui suit:

for (int a01 = 1; a01 <= 25; a01++) {
    for (int a02 = a01 + 1; a02 <= 25; a02++) {
        for (int a03 = a02 + 1; a03 <= 25; a03++) {
            ...
            System.out.println(a01 + "," + a02 + "," + ... + "," + a015);
        }
    }
}

J'aimerais préciser le nombre de for imbriquées (dans le cas ci-dessus, je veux 15 imbriqués pour l').
Est-il un moyen de l'utilisation récursive de la programmation ici?

S'il vous plaît, non. Ne pas le faire.
Il suffit de créer une méthode et de le laisser appeler 15 fois. C'est une véritable méthode récursive.
soin d'expliquer pourquoi? 😉
Illisibles, incompréhensibles, laid, mauvais design, plein de bugs, rien de mal, vous pouvez penser à.
En général, oui, vous pouvez le faire de manière récursive, et il peut être "robuste" et compréhensible. (Notez que les fonctions récursives sont souvent utilisés pour l'arbre de recherche, qui est effectivement imbriqués pour les déclarations.) Mais notez qu'il n'est géométrique de la croissance dans le nombre total d'itérations, et, imbriqués 15 de profondeur, la routine peut ne jamais se terminer. Allez-y! Même si vous ne vous apprendra quelque chose.
Notez que la routine récursive doit simplement accepter l'index de début, la profondeur (décrémenté à chaque appel), et tout ce que vous avez besoin de l'adresse dans le code réel.
Delimanolis: je suppose qu'il n'aime pas le code de cette façon. Il aime avoir un multi-dimensionnelle avec une dimension de 25 ans. Facile à nettoyer et à l'aide de programmation récursive - comme il l'a demandé.

InformationsquelleAutor Rumpelstiltskin | 2013-10-16

java recursion

17

Oui. Ceci peut être effectué par programmation récursive.

Je suppose que vous n'aimez pas ÉCRIRE ces for imbriquées dans le code source - comme dans votre exemple, parce que c'est vraiment laid de programmation - comme les auteurs ont expliquer.

Suivantes (pseudo-Java-like) code de l'illustre. Je suppose une profondeur fixe pour la nidification. Alors vous aimez vraiment faire une boucle sur un nombre entier de vecteur de dimension de la profondeur.
```
int[] length = new int[depth];
int[] counters = new int[depth];
```
Le tableau counters doit être initialisé à 0 (Arrays.fill(counters,0)). Le tableau length doit être initialisé avec le nombre d'itérations pour la boucle for.

Je suppose que vous souhaitez effectuer une certaine opération à l'intérieur de la boucle interne. Je vais appeler cette
performOperation(int[] counters);
- cela dépend de la multi-dimensionnelle compteur, c'est à dire les compteurs de l'extérieur pour l'.

Ensuite, vous pouvez exécuter les boucles for imbriquées en appelant
```
nestedLoopOperation(counters, length, 0);
```
où
```
void nestedLoopOperation(int[] counters, int[] length, int level) {
    if(level == counters.length) performOperation(counters);
    else {
        for (counters[level] = 0; counters[level] < length[level]; counters[level]++) {
            nestedLoopOperation(counters, length, level + 1);
        }
    }
}
```
Dans votre cas votre Système.out.println() serait
```
performOperation(int[] counters) {
    String counterAsString = "";
    for (int level = 0; level < counters.length; level++) {
        counterAsString = counterAsString + counters[level];
        if (level < counters.length - 1) counterAsString = counterAsString + ",";
   }
   System.out.println(counterAsString);
}
```
- L'intérieur de votre appel de fonction est un paramètre manquant length.
- Je vous remercie. J'ai commencé à écrire le pseudo-code, c'Java, mais n'a pas vérifier si il compile - écrit directement ici sans IDE.
- J'ai essayé ce code après l'avoir convertie en Python. Si la profondeur détermine la taille du Vecteur, aka, combien de nids dans la boucle, mais que les valeurs de ces Vecteurs être? Il semble que la Longueur doit toujours être la profondeur (par exemple, [3, 3, 3]), tandis que le Compteur est juste ce que c'est dans la boucle (de [0, 1, 2] si vous voulez juste de commencer à 0 et s'arrêter après max -1)?
- Pas de. La longueur est la longueur d'une boucle for. Donc, si vous avez deux boucles imbriquées for(int i=0; i<13; i++) { for(int j=0; j<45; j++) { ... } }puis depth=2 et length = { 13, 45 }.
InformationsquelleAutor Christian Fries

J'ai créé ce programme pour afficher toutes les différentes combinaisons possibles de cartes (non répété). Il utilise récursive pour les boucles. Peut-être que cela peut vous aider.

//I'm lazy, so yeah, I made this import...
import static java.lang.System.out;
class ListCombinations {
//Array containing the values of the cards
static Symbol[] cardValues = Symbol.values();
//Array to represent the positions of the cards,
//they will hold different card values as the program executes
static Symbol[] positions = new Symbol[cardValues.length];
//A simple counter to show the number of combinations
static int counter = 1;
/*Names of cards to combine, add as many as you want, but be careful, we're
talking about factorials here, so 4 cards = 24 different combinations (4! = 24),
but 8 cards = 40320 combinations and 13 cards = 6.23 billion combinations!*/
enum Symbol {
AofSpades, TwoofSpades, ThreeofSpades, FourofSpades
}
public static void main(String args[]) {
//I send an argument of 0 because that is the first location which
//we want to add value to. Every recursive call will then add +1 to the argument.
combinations(0);
}
static void combinations(int locNumber) {
/* I use a recursive (repeating itself) method, since nesting for loops inside
* each other looks nasty and also requires one to know how many cards we will
* combine. I used 4 cards so we could nest 4 for loops one after another, but
* as I said, that's nasty programming. And if you add more cards, you would
* need to nest more for loops. Using a recursive method looks better, and gives
* you the freedom to combine as many cards as you want without changing code. */
//Recursive for loop nesting to iterate through all possible card combinations
for(int valueNumber = 0; valueNumber < cardValues.length; valueNumber++) {
positions[locNumber] = cardValues[valueNumber];
if (locNumber < (cardValues.length-1)) {
combinations(locNumber + 1);
}
//This if statement grabs and displays card combinations in which no card value
//is repeated in the current "positions" array. Since in a single deck,
//there are no repeated cards. It also appends the combination count at the end.
if (locNumber == (cardValues.length-1) && repeatedCards(positions)) {
for (int i = 0; i < cardValues.length; i++) {
out.print(positions[i]);
out.print(" ");
}
out.printf("%s", counter);
counter++;
out.println();
}
}
}
static boolean repeatedCards(Symbol[] cards) {
/*Method used to check if any cards are repeated in the current "positions" array*/
boolean booleanValue = true;
for(int i = 0; i < cardValues.length; i++) {
for(int j = 0; j < cardValues.length; j++) {
if(i != j && cards[i] == cards[j]) {
booleanValue = false;
}
}
}
return booleanValue;
}
}

InformationsquelleAutor Simon Vega-

Vous devez vous connecter pour publier un commentaire.