Pb de Boucles "Pour" (nombre variable)

Bonjour,

J'ai un problème d'algorithmique par rapport au parcours de dossiers et fichiers mais plus particulièrement pour coder un nombre variable de boucles "pour".

Mon Problème :

J'ai à ma disposition n dossiers contenant chacun k(n) fichiers. (Chaque dossier ne contient pas forcément le même nombre de fichiers)

Je voudrais à partir de ces fichiers créer toutes les combinaisons possibles de fichiers en prenant un fichier dans chaque dossier.
Cependant la fonction que je chercher à coder devra pouvoir prendre le nombre de dossiers en paramètre. Mon problème se trouve donc à cet endroit la. En effet, avec un nombre de dossiers fixe j'avais pensé à la solution suivante :

Pour 3 dossiers A,B,C contenant respectivement Nb_fichiers_A, Nb_fichiers_B et Nb_fichiers_C fichiers :

Code:

---

1 2 3 4 5 6 7

Pour a de 1 à Nb_fichiers_A Pour b de 1 à Nb_fichiers_B Pour c de 1 à Nb_fichiers_C .... Fait Fait Fait

---

En partant des dossiers :
A : FichierA_1 FichierA_2 FichierA_3 (3 fichiers)
B : FichierB_1 FichierB_2 (2 fichiers)
C : FichierC_2 FichierC_3 (2 fichiers)

Je voudrais donc obtenir les (3*2*2=12) combinaisons :
A1-B1-C1 A1-B1-C2
A1-B2-C1 A1-B2-C2
A2-B1-C1 A2-B1-C2
A2-B2-C1 A2-B2-C2
A3-B1-C1 A3-B1-C2
A3-B2-C1 A3-B2-C2
afin de réutiliser ces fichiers pour une utilisation ultérieure.

Comment faire pour avoir un nombre de dossiers variable sans recourir à une solution "moche" consistant à poser un nombre max de dossiers et faire des tests ...
Si cela peut vous être utile, j'utilise le language R pour programmer mais une solution algorithmique me permettrait d'avancer.

En espérant avoir été assez clair, Merci par avance de votre aide!

Bonne journée

Citation:

---

Envoyé par Isima

J'ai un problème d'algorithmique par rapport au parcours de dossiers et fichiers mais plus particulièrement pour coder un nombre variable de boucles "pour".

---

Les langages impératifs précompilés ne supportent pas la génération dynamique de code. Impossible dont de créer "a la volée" des boucles imbriquées.

Solution 1: Prendre un langage interprété (javascript, ...) possèdant une fonction "eval()" qui permet d'executer du code dynamiquement

Solution 2: Prendre un langage non impératif (cf. langages fonctionnels)

Aucune de ces 2 solutions, ne convient dans ton cas. Heureusement, il y a une autre solution:

Solution 3: Créer une relation d'ordre sur les solutions et iterer.

C'est à dire, en clair, créer un "compteur" qui représente les solutions possibles. Dans ton exemple avec les 3 dossiers, le compteur est un vecteur à 3 dimension:

La solution "Ax-By-Cz" est représentée par le vecteur (x,y,z).

Comme tu veux toutes les combinaisons, il faut passer par toutes les valeurs possibles de x,y,z.

Il faut donc créer une fonction "Suivant(v)" qui pour un vecteur "v" donné renvoie la "prochaine" solution, c'est à dire le vecteur suivant dans notre relation d'ordre.

Par exemple, on incrément la 1ere coordonnée. Si on arrive à la limite haute pour cette coordonnée, on la remet à zéro et on incrémente la coordonnée suivante (et ainsi de suite). C'est le principe du compteur kilometrique dans une voiture.

En Java, ca donnerait quelquechose comme cela:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

public static boolean next(int[] number, int[] limit) { int i=0; while(i<number.length && number[i]==limit[i]) number[i++]=1; if (i>=number.length) return false; number[i]++; return true; }   public static void main(String[] args) { int[] number = new int[]{1,1,1}; // valeur de départ int[] limit = new int[]{3,2,2}; // limite pour chaque coordonnée do { System.out.println( Arrays.toString(number) ); } while(next(number,limit)); // tant qu'il y a un suivant }

---

Résultat:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

[1, 1, 1] [2, 1, 1] [3, 1, 1] [1, 2, 1] [2, 2, 1] [3, 2, 1] [1, 1, 2] [2, 1, 2] [3, 1, 2] [1, 2, 2] [2, 2, 2] [3, 2, 2]

---

il y a egalement la solution (celle de pseudocode exprimee differemement) :

Code:

---

1 2 3 4 5 6 7

tant que fichier1 = get_fichier(rep1) non vide tant que fichier2 = get_fichier(rep2) non vide tant que fichier3 = get_fichier(rep3) non vide imprime fichier1, fichier2, fichier3 fin tant que fin tant que fin tant que

---

qu'on peut egalement generaliser a N repertoires et faire par une fonction recursive

On peut aussi faire comme celà :
Un seul indice t, un tableau Cur(N) qui mémorisera la position dans les différents tableaux k(N), et un tableau Max(N) qui mémorise le nombre maximum d'éléments du tableau K(n).
t sert à se promener dans les différents tableaux Cur(N) au moment de l'incrémentation

Code:

---

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

Initialisation On est au premier élément de tous les tableaux pour i de 1 à N faire Cur(i) = 1 fin pour   On balaie le premier tableau t = 1 faire construire la chaine courante indicée par t (par exemple K(1)(Cur(1)) + K(2)(Cur(2)) + K(3)(Cur(3))+ ...) Cur(t) <- Cur(t) + 1 tant que t <= N et Cur(t) > Max(t) faire On remet le compteur au départ pour ce tableau Cur(t) <- 1 on passe au tableau suivant t <- t + 1 On vérifie qu'on n'a pas dépasser le nombre de tableaux si t <= N alors on augmente l'indice courant de ce tableau Cur(t) <- Cur(t) + 1 Si on ne dépasse l'indice maxi du tableau courant si Cur(t) <= Max(t) on repart pour un tour t = 1 fin si fin si fin tant que tant que t <= N

---

les tableaux peuvent bien sur se générer à la volée.

Merci à vous!
J'ai eut ma petite préférence pour l'idée de compteur kilométrique! Faut dire c'est la première que j'ai essayé et ca fonctionne très bien pour ce dont j'ai besoin!

Merci donc a pseudocode pour son idée!
et Merci aux autres également!