Discussion :

[Isima]

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 :

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

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

[pseudocode]

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 java :

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
 
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 :

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

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]

[souviron34]

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

Code :

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

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

[Trap D]

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 :

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
 
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.

[Isima]

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!