java - sumar - recursividad ejemplos

¿Cómo hacer n anidados para bucles recursivamente?

Question

Tengo un método que debe hacer lo siguiente:

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

Me gustaría especificar el número de anidados para (en el caso anterior, quiero 15 anidados para). ¿Hay alguna manera de usar programación recursiva aquí?

Answer 1

Creé este programa para mostrar todas las diferentes combinaciones posibles de tarjetas (no se repiten). Utiliza recursivo para loops. Puede que esto te ayude.

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

Answer 2

Sí. Esto se puede realizar mediante programación recursiva.

Supongo que no te gusta ESCRIBIR ESTOCIDOS en el código fuente, como en tu ejemplo, porque esta es una programación realmente fea, como explican los comentaristas.

El siguiente código (pseudo Java) lo ilustra. Asumo una profundidad fija para el anidamiento. Entonces, realmente le gusta hacer un bucle sobre un vector entero de profundidad de dimensión.

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

Los counters matriz deben inicializarse a 0 ( Arrays.fill(counters,0) ). La length matriz debe inicializarse al número de iteraciones para el respectivo bucle for.

Supongo que te gusta realizar una determinada operación dentro del bucle interno. Llamaré a esto performOperation(int[] counters); - Depende del contador multidimensional, es decir, los contadores de los for for externos.

Entonces puedes ejecutar los bucles anidados llamando

nestedLoopOperation(counters, length, 0);

dónde

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

En su caso, su System.out.println () sería

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