n個のforループを再帰的に作る方法は？

Question

私は次の操作を行う必要があります方法があります。

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); 
     } 
    } 
} 

を私は（上記の場合には、私はのための15のネストされたたい）のために、ネストされたの数を指定したいと思います。 ここで再帰プログラミングを使用する方法はありますか？

Answer 1

はい。これは再帰的プログラミングによって行うことができる。

あなたの例のように、これらのネストされたforを書き留めたくないと思うのですが、これはコメント者の説明のように、実際は醜いプログラミングなのでです。

次の（疑似Javaのような）コードはそれを示しています。私は入れ子のための固定された深さを仮定する。次に、次元の深さの整数ベクトルをループするのが実際に好きです。

int[] length = new int[depth]; 
int[] counters = new int[depth]; 

アレイcounters 0（Arrays.fill(counters,0)）に初期化されなければなりません。配列lengthは、それぞれのforループの反復回数に初期化する必要があります。

内側のループ内で特定の操作を実行するとします。これは多次元のカウンタ、つまりforの外側のカウンタに依存します。これは performOperation(int[] counters);です。

は、次に、あなたのSystem.out.println（）は

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); 
} 

Answer 2

Iだろうあなたのケースでは

nestedLoopOperation(counters, length, 0); 

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); 
     } 
    } 
} 

を呼び出すことにより、ループのネストされたを実行することができますこのプログラムを作成して、可能なすべての異なるカードの組み合わせを表示します（繰り返さない）。再帰的なforループを使用します。たぶんあなたを助けることができます。

//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; 
    } 
}