Discussion :

[Wim88]

Bonjour,
je suis vraiment bloquée je n'ai pas une idée même pour développer

le fichier d'entrée est le suivant:

those , the
accidents , connection
petroleum , tankers

je veux faire toutes les combinaisons possibles entres les termes pour avoir ce résultat:

those - accidents - petroleum
those - accidents - tankers
those - connection - petroleum
those - connection - tankers
the - accidents - petroleum
the - accidents - tankers
the - connection - petroleum
the - connection - tankers

Merci de m'aider par un bout de code ou par une simple idée

[thelvin]

À mon avis, le plus simple est un raisonnement par récurrence.

Définir une méthode qui prend, en paramètres :
- une liste de mots qu'on a choisis d'utiliser, venant des premières lignes
- la liste des mots restants, avec toutes les possibilités des lignes restantes.

Et qui a pour effet : d'écrire toutes les combinaisons composées, d'abord des mots qu'on a choisis d'utiliser, puis du reste de la liste de mots.

Elle fera donc comme ça : dans la liste des mots restants, elle prend la première ligne. Elle enlève cette première ligne des lignes restantes.
Puis elle fait une boucle sur toutes les possibilités de cette ligne. Dans chaque boucle, elle s'appelle elle-même, avec comme mots choisis, les mots qui étaient déjà choisis, plus la possibilité correspondant à cette boucle, et comme liste de mots restants, ce qui reste.

[yotta]

C'est probablement plus simple dit comme ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
BufferedReader lecteur = new BufferedReader(new FileReader("fichier d'entrée"));
Vector<String[]> lignes = new Vector<String[]>();
String valeur;
while (lecteur.ready()) lignes.add(lecteur.readLine().split(","));
lecteur.close();
lignes.trimToSize();
for (int i = 0 ; i < lignes.get(0).length ; i++) {
    for (int j = 0 ; j < lignes.get(1).length ; j++) {
        for (int k = 0 ; k < lignes.get(2).length ; k++) {
            System.out.println(lignes.get(0)[i].trim() + " " + lignes.get(1)[j].trim() + " " + lignes.get(2)[k].trim());
            }
        }
    }

[Wim88]

mercii

[thelvin]

Forcément, si on connaît le nombre de lignes du fichier d'entrée la solution est plus simple -_-°.

[yotta]

Effectivement, connaissant le nombre de lignes, c'est très simple. Et je vous avoues qu'avec un nombre de lignes inconnu, et un nombre de termes inconnu par lignes, je serai totalement incapable de trouver une solution. C'est d'ailleurs votre explication, thelvin, qui m'a inspiré et permis de pondre ce petit bout de code QUI NE FONCTIONNE QUE DANS CE CAS !!!
Par contre, si vous pouviez nous montrer un code générique équivalent, je suis preneur...

[joel.drigo]

Salut,

Par contre, si vous pouviez nous montrer un code générique équivalent, je suis preneur...

Il suffit que tu généralises ta solution en utilisant une pile pour simuler les boucles. Voilà une solution qui fonctionne quelque soit le nombre de lignes, et le nombre de mots par ligne.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
public class Combinaisons {
 
    public static void main(String[] args) {
 
        String[] input = {        
        "those , the",
        "accidents , connection",
        "petroleum , tankers", 
        };
 
        List<List<String>> liste = new ArrayList<>();
 
        for(String ligne : input) {
            liste.add( Arrays.asList(ligne.split("\\s*,\\s*")) );
        }
 
        List<String> combinaisons = createCombinaisons(liste);
 
        for(String combinaison : combinaisons) {
            System.out.println(combinaison);
        }
 
    }
 
 
    public static List<String> createCombinaisons(List<List<String>> liste) {
        List<String> combinaisons = new ArrayList<>();
        createCombinaisons(liste, combinaisons, new Stack<Integer>(), new StringBuilder());
        return combinaisons;
    }
 
 
    private static void createCombinaisons(List<List<String>> liste,
            List<String> combinaisons, Stack<Integer> indexList,
            StringBuilder stringBuilder) {
 
        // la taille courante de la pile correspond au niveau de boucle imbriquée courant
        if ( indexList.size()<liste.size() ) {
            List<String> ligne = liste.get(indexList.size());
 
            // on stocke l'itération sur la ligne courante en utilisant une pile, ce qui permet
            // de simuler n boucles imbriquées
            for(int i=0; i<ligne.size(); i++) {
 
                indexList.push(i);
 
                createCombinaisons(liste, combinaisons, indexList, stringBuilder);
 
                indexList.pop();
 
            }
 
 
        }
        else {
 
            // combinaison des indices de boucle, correspondant à la dernière boucle imbriquée
            for(int i=0; i<indexList.size(); i++) {
 
                // boucle imbriquée de niveau i
 
                if ( i>0 ) {
                    stringBuilder.append(" - ");
                }
                List<String> ligne = liste.get(i); // liste de mot de niveau i 
                int indexMot = indexList.get(i); // valeur actuelle de l'indice de la boucle de niveau i
                String mot = ligne.get(indexMot); // mot correspondant
                stringBuilder.append(mot);
 
            }
            combinaisons.add(stringBuilder.toString()); // on stocke la combinaison trouvée
            stringBuilder.setLength(0); // on recycle le StringBuilder
 
        }
 
    }
 
}

[yotta]

Merci beaucoup !
On en apprend tous les jours...