fonction récursive pour obtenir des combinaisons de nombre dynamique de la liste

Kumaran Ragunathan:

Je suis en train d'écrire une fonction récursive pour obtenir toutes les combinaisons de nombre dynamique posible de la liste. Par exemple, si je 3 listes

List 1 : {A,B}
List 2 : {B,C}
List 3 : {D}

Même si dans la sortie de chaque élément se produit une fois que je voudrais garder la sortie dans la structure de

List<List<List<elements>>>

Mon résultat attendu sera

L1 : A, L2 : B, L3 : D
L1 : A, L2 : C, L3 : D
L1 : B, L2 : B, L3 : D
L1 : B, L2 : C, L3 : D

Voici le numéro de la liste peut changer dynamiquement. Donc je besoin d'un numéro dynamique de boucles imbriquées pour trouver des combinaisons.

Voici ce que je cherche. Juste ignorer mon code terrible.

public List<List<List<elements>>> combinations(int depth, List<List<elements>> allLists,List<List<List<elements>>> answerList){

if(depth==allList.size())
 return answerList
 }
else{ 
 for(List<element> e : answerList){
    for(int j=0; j<e.size();j++){
      answerList.get(depth).get(j).add(allList.get(depth).get(j));
combinations (depth+1,allLists,answerList)
}
}
}

S'il vous plaît aidez-moi où je fais mal?

ÉDITER:

mon idée est de garder toutes les combinaisons ensemble afin que

{UNE}

sera la plus profonde dans la liste réponse

{L1, L2, L3}

sera le deuxième niveau de la liste.

{L1, L2, L3}, {L1, L2, L3}

sera la liste de l'extérieur. Ainsi, le nombre de listes commets question ici. tous seront couverts par la structure ci-dessus. ma sortie finale dans la structure ci-dessus est donnée ci-dessous

 {
   {
     {A},
     {B},
     {D}
   },
   {
     {A},
     {C},
     {D}
   },
   {
     {B},
     {B},
     {D}
   },
   {
     {B},
     {C},
     {D}
   }
 }

Marcin Zukowski:

Vous avez besoin d'un modèle récursif assez commun, où vous maintenez une variable contenant l'état construit au niveau actuel. Voici un code pour vous.

import java.util.Arrays;
import java.util.List;
import java.util.ArrayList;

public class Main 
{
  public static void recurse(int depth,
                      List<List<String>> current,
                      List<List<List<String>>> result,
                      List<List<String>> lists)
  {
    if (depth == lists.size()) {
      // Copy the list to the result
      result.add(new ArrayList<List<String>>(current));
      return;
    }
    // Iterate over the current-depth list
    List<String> list = lists.get(depth);
    for (String str: list) {
      List<String> elem = Arrays.asList(str);
      current.add(elem);   // Add the next element to the list
      recurse(depth + 1, current, result, lists);
      current.remove(depth);  // Clean up this element
    }
  }

  public static List<List<List<String>>> combinations(List<List<String>> allLists) 
  {
      // We'll fill it in
      List<List<List<String>>> result = new ArrayList<>();

      // Current, partial row in the final result
      List<List<String>> current = new ArrayList<>();

      recurse(0, current, result, allLists);

      return result;
  }

  public static void main(String[] args) {

    System.out.println("Hello World!");

    List<String> list1 = Arrays.asList("A", "B");
    List<String> list2 = Arrays.asList("B", "C", "E");
    List<String> list3 = Arrays.asList("D", "X");

    List<List<String>> allLists = Arrays.asList(list1, list2, list3);

    List<List<List<String>>> result = combinations(allLists);

    // Print
    for (List<List<String>> list: result) {
      System.out.print("{ ");
      for (List<String> elem: list)
        System.out.print("{" + elem.get(0) + "} ");
      System.out.println("}");
    }
  }
}

BTW, vous pouvez simplifier un peu sans le 3ème niveau des listes, comme suggéré @dasblinkenlight