¿Cómo puedo obtener toda la combinación de símbolos (cómo iterar estas matrices)?

Tengo esta lista de símbolos

    public ArrayList<ArrayList<Letter>> setLetters() {
    ArrayList<ArrayList<Letter>> letters = new ArrayList<>();
    ArrayList<Letter> letter = new ArrayList<>();

    letter.add(new Letter('r', 0, 0));
    letter.add(new Letter('r', 1, 6));
    letter.add(new Letter('r', 3, 9));
    letters.add(letter);

    letter = new ArrayList<>();
    letter.add(new Letter('e', 4, 1));
    letter.add(new Letter('e', 4, 3));
    letters.add(letter);

    letter = new ArrayList<>();
    letter.add(new Letter('s', 4, 6));
    letter.add(new Letter('s', 4, 7));
    letter.add(new Letter('s', 5, 1));
    letters.add(letter);

    letter = new ArrayList<>();
    letter.add(new Letter('o', 5, 4));
    letters.add(letter);

    letter = new ArrayList<>();
    letter.add(new Letter('r', 5, 5));
    letter.add(new Letter('r', 5, 9));
    letters.add(letter);

    letter = new ArrayList<>();
    letter.add(new Letter('s', 6, 2));
    letter.add(new Letter('s', 8, 2));
    letter.add(new Letter('s', 8, 3));
    letters.add(letter);

    letter = new ArrayList<>();
    letter.add(new Letter('e', 6, 5));
    letter.add(new Letter('e', 6, 7));
    letter.add(new Letter('e', 6, 8));
    letter.add(new Letter('e', 7, 3));
    letter.add(new Letter('e', 7, 8));
    letter.add(new Letter('e', 9, 2));
    letter.add(new Letter('e', 9, 3));
    letters.add(letter);

    letter = new ArrayList<>();
    letter.add(new Letter('s', 7, 1));
    letter.add(new Letter('s', 9, 4));
    letters.add(letter);

 return letters;
}

¿Cómo puedo obtener la combinación de símbolos 1512, en ArrayList así:

r {0,0} e {4,1} s {4,6} o {5,4} r {5,5} s {6,2} e {6,5} s {7,1}; r {0,0} e {4,1} s {4,6} o {5,4} r {5,5} s {6,2} e {6,5} s {9,4}; ....

otras 1510 combinaciones

Idk cómo iterar estas matrices> <

Respuesta 1

Calcule el número de permutaciones (en su caso 1510, multiplique los tamaños de todos los conjuntos individuales).

Luego, para cada índice de iteración, simplemente realice una aritmética de módulo para agregar un elemento de cada conjunto, y luego divida por el mismo tamaño de conjunto antes de elegir el siguiente elemento del conjunto.

Algo como esto:

long permutations = 1;

for (int i = 0; i < letter.size(); i++)
{
    int setcount = letter[i].size();
    if (setcount == 0)
    {
       continue;
    }
    permutations *= setcount;
}

for (long p = 0; p < permutations; p++)
{
    long index = p;
    String s = "";

    for (int i = 0; i < letter.size(); i++)
    {
        if (letter[i].size() > 0)
        {
            ArrayList<Letter> innerIndex = index % letter[i].size();
            index /= letter[i].size();

            // append letter[i].get(innerIndex) to s, then append a semi-colon 
        }
    }

    System.out.println(s);
}
Respuesta: 2

Aquí hay un algoritmo recursivo:

public static void generateCombinations(
        List<List<Letter>> letters, Consumer<List<Letter>> handler) {
    List<List<Letter>> combinations = new ArrayList<>();
    addCombinations(letters, new ArrayList<>(), handler);
}

private static void addCombinations(List<List<Letter>> letters,
        List<Letter> current, Consumer<List<Letter>> handler) {
    int currentIndex = current.size();
    if (currentIndex >= letters.size()) {
        handler.accept(new ArrayList<>(current));
    } else {
        for (Letter letter: letters.get(currentIndex)) {
            current.add(letter);
            addCombinations(letters, current, handler);
            current.remove(currentIndex);
        }
    }
}

Lo usarías así:

List<List<Letter>> letters = setLetters();
generateCombinations(letters, list -> System.out.println(list));
Respuesta: 3

Puede hacerlo de forma recursiva sin tener que evaluar primero el número de combinaciones:

ArrayList<ArrayList<Letter>> combinations(ArrayList<ArrayList<Letter>> source, int step, ArrayList<ArrayList<Letter>> currentCombinations) {

    if( step == 0 ) {
        // init first pass because there are no current combinations.
        ArrayList<Letter> lettersAtStep = source.get(step);
        ArrayList<ArrayList<Letter>> nextCombinations = new ArrayList<>();

        for (Letter l : lettersAtStep) {
            ArrayList<Letter> firstLetter = new ArrayList<>();
            firstLetter.add(l);
            nextCombinations.add(firstLetter);
        }
        return combinations(source, step+1, nextCombinations);
    }
    else if( step == source.size() ) {
        // No more letters to add.
        return currentCombinations;
    }

    ArrayList<Letter> lettersAtStep = source.get(step);
    ArrayList<ArrayList<Letter>> nextCombinations = new ArrayList<>();

    for( ArrayList<Letter> comb : currentCombinations) {
        for (Letter l : lettersAtStep) {
            // Add each new Letter to each existing combination.
            ArrayList<Letter> item = new ArrayList(comb);
            item.add(l);
            nextCombinations.add(item);
        }
    }

    return combinations(source, step+1, nextCombinations);
}

Entonces, lo llamas:

 combinations(setLetters(), 0, new ArrayList<>());

Le devuelve todas las combinaciones en una ArrayList como asistió.

Respuesta: 4

Estoy evaluando Node.js para el posible reemplazo de mi funcionalidad de inserción actual en una aplicación web Java. Escribí un servidor de sondeo largo y simple que funciona como un intermediario entre el cliente y Java ...

Estoy trabajando en una función que desglosa la entrada dada en denominaciones usando una llamada recursiva. En cada paso se repite en dos variantes: continuar con la moneda actual: agregarla a la lista ...

La documentación de GAE para JPA 2.0 establece que el objetivo mejorar_guerra para el archivo hormiga debería ser este: <target name = "datanucleusenhance" depende = "compilar" description = "Realiza mejoras en ...

Si tengo la interfaz: public interface Val {public NilVal NIL; } Y una clase singleton que lo implementa: la clase pública NilVal implementa Val {private static NilVal nil = null; ...