Bonjour.
J'ai déjà posté sur ce sujet, mais je pense que je m'y suis mal pris, vu les orientations dans les réponses...
J'ai un problème d'ordre algorithmique.
J'arrive pas à écrire un algorithme qui me retourne toutes mes valeurs.
Je vais d'abord expliquer ce que j'ai envie de faire, de façon globale, puis sur un exemple je vais détailler ce que j'ai envie d'obtenir, et enfin proposer l'algorithme que j'ai implémenté, qui ne marche pas.
Donc, je dispose d'éléments, qui peuvent par exemple être des lettres de l'alphabet a, b, c ...sont des éléments.
Je peux donc avoir des listes d'éléments l1 = abc l2= cde l3= fghij ....
mon problème:
Je voudrais partir d'une liste initiale qui contient toutes ces listes (liste_initiale = (l1, l2, l3...), et obtenir une liste finale avec d'autres listes liste_finale = (l10, l11, l12,....).
Les listes de la liste finale sont construites de façon incrémentale, en respectant l'algorithme que je vais détailler ci dessous pour 3 listes par exemple. De façon générale, quand le constructeur prend un élément d'une liste, il se rappelle sur toutes les listes, mais en ne considérant plus l'élément qu'il vient de prendre...
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
liste_initiale = (l1, l2, l3) avec l1 = ab  l2 = def  et l3 = g
Mon constructeur de la liste finale fonctionne ainsi:
constructeur(ab, def, g) 

aconstructeur(b, def, g), dconstructeur(ab, ef, g), gconstructeur(ab, def)

abconstructeur(def, g), adconstructeur(b, ef, g), agconstructeur(b, def), daconstructeur(b, ef, g), deconstructeur(ab, f, g), dgconstructeur(b, ef), gaconstructeur(b, def), gdconstructeur(ab, ef)

abdconstructeur(ef, g), abgconstructeur(def), adbconstructeur(ef, g), adeconstructeur(b, f, g), adgconstructeur(b, ef), agbconstructeur(def), agdconstructeur(b, ef), dabconstructeur(ef, g), daeconstructeur(b,f,g), dagconstructeur(b, ef), deaconstructeur(b, f, g), defconstructeur(ab, g), degconstructeur(ab, f), dgbconstructeur(ef), dgeconstructeur(b, f), gabconstructeur(def), gadconstructeur(b, ef), gdaconstructeur(b, ef), gdeconstructeur(ab, f)

abdeconstructeur(f, g), abdgconstructeur(ef), abgdconstructeur(ef), adbeconstructeur(f, g), adbgconstructeur(ef), adebconstructeur(f, g), adefconstructeur(b, g), adegconstructeur(b, f), adgbconstructeur(ef), adgeconstructeur(b, f), agbdconstructeur(ef), agdbconstructeur(ef), agdeconstructeur(b, f), dabeconstructeur(f, g), dabgconstructeur(ef), daebconstructeur(f, g), daefconstructeur(b, g), daegconstructeur(b, f), dagbconstructeur(ef), dageconstructeur(b, f), deabconstructeur(f, g), deafconstructeur(b, g), deagconstructeur(b, f), defaconstructeur(b, g), defgconstructeur(ab), degaconstructeur(b, f), degfconstructeur(ab), dgbeconstructeur(f), dgebconstructeur(f), dgefconstructeur(b), gabdconstructeur(ef), gadbconstructeur(ef), gadeconstructeur(b, f), gdabconstructeur(ef), gdaeconstructeur(b, f), gdeaconstructeur(b, f), gdefconstructeur(ab)

abdefconstructeur(g), abdegconstructeur(f), abdgeconstructeur(f), abgdeconstructeur(f), adbefconstructeur(g), adbegconstructeur(f), adbgeconstructeur(f), adebfconstructeur(g), adebgconstructeur(f), adefbconstructeur(g), adefgconstructeur(b), ...............................
....................................................

abdefg, abdegf, abdgef, abgdef, adbefg, adbegf, adbgef, adebfg, adebgf, adefbg, adefgb..............................................................................
...................................................................................
Maintenant que j'ai détaillé l'algorithme, voici ce que je propose pour son implémentation.
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
 
liste_liste_element est ma structure qui contient les listes d'éléments;
liste_element est ma structre qui contient les éléments;
 
Mon constructeur renvoie donc une liste_liste_element (la liste finale). Il prend en entrée une liste_liste_element (la liste initiale).
 
//j'initialise liste_finale à vide;
//pour chaque liste linit de la liste initiale, j'initialise une liste d'élément lelt, //j'ajoute le premier élément de linit à lelt, j'appelle le constructeur sur la //nouvelle liste initiale (qui est l'ancienne liste, moins le premier élément de la //liste traitée) et j'ajoute lelt à liste_finale
 
liste_liste_element constructeur(liste_liste_element liste_initiale)
{
    liste_liste_element liste_initiale = 
    enlever_listes_vide_de_la_liste_initiale(liste_initiale);
 
    liste_liste_element liste_finale = vide;
    pour linit dans liste_initiale faire
        liste_element lelt = vide;
        lelt = ajoute_element(lelt, premier_element(linit);
        liste_finale = ajouter_liste(liste_finale, lelt);
        liste_finale = constructeur(nouvelle_liste(liste_initiale));
    finpour;
 
    retourne liste_finale;
}
maintenant j'explique les fonctions utilisées

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
 
enlever_listes_vide_de_la_liste_initiale est une fonction qui prend en entrée une liste_liste_element et renvoie une liste_liste_element sans les liste_element vides.
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
 
ajoute_element ajoute un élément à une liste d'éléments, et retourne la nouvelle liste d'élements
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
 
ajouter_liste ajoute une liste d'éléments à une liste de liste d'éléments et retourne la nouvelle liste de liste d'éléments.
Cet algorithme ne marche pas.
Je vois bien par exemple que je n'ajoute que le premier élément, raison pour laquelle j'obtiens à la fin une liste finale dont les listes ont un seul élément...
Je ne vois vraiment pas comment écrire cet algorithme pour obtenir toutes mes listes...
D'avance merci..