Bonjours!
Je cherche un algorithme permettant de faire ceci :

Boucle(1)
{
Boucle(2)
{
Boucle(...)
{
Boucle(k)
{
//Affichage d´un nombre a l´aide des parametres de chacunes des variables
}
}
}
}

Un systeme de recursivitée doit surement etre utilisé ici pour obtenir un resultat.
Vous pourriez m´aider un peu pour trouver une solution a ce probleme ?

La seule que j´ai trouvé pour l´instant fonctionnerait a l´aide d´une infinitée de "Si" en fonction de k, pas du tout pratique.

Merci

tu pourrais donner ce que tu as au depart, et à l´arrive stp ?

J´ai trouvé le moyen de gérer a peu pres ca, en C++, bien que je compte pas coder ceci en C++, mais bon, c´est plus clair comme ca :

1. include <iostream>

using namespace std;

void fonction(int a)
{
cout << "Debut " << a << endl;
if(a<5) {fonction(a+1);}
else {cout << "Calcul..." << endl;}
cout << "Fin " << a << endl;
}

int main(void)
{
fonction(1);
return 0;
}

Affichage:
Debut 1
Debut 2
Debut 3
Debut 4
Debut 5
Calcul...
Fin 5
Fin 4
Fin 3
Fin 2
Fin 1

Faut que j´y implemente un systeme de boucle et que je gere les calculs maintenant.

je n´ai pas compris. Peux tu expliquer plus clairement ce que tu cherche a faire ?

il te suffit de faire un truc dans le genre :

fonction recBoucle(int profondeur, liste trace)
{
...si la profondeur est bonne : tu fait ton traitement
...sinon de i=0 a limite
......{
.........recBoucle( profondeur+1, trace::[i])
......}
}

et tu demmares de la maniere suivante :

de i=0 a limite
{
...recBoucle(1, [i])
}

----- lexique:
[i] : liste contenant uniquement l´element i
toto::[i] : ajout de l´element i a la fin de la liste toto

je pense que ça devrait pouvoir le faire

c´est en langage C mélangé caml mais l´important c´est l´idée.
j´espere que tu sais te servir des listes. Sinon je pense que tu peux t´en sortir avec des tableau de taille dynamique.

En fait, c´est un programme qui calcul au départ les diviseurs premiers n´un entier naturel, il les affiche dans un tableau a une dimension.

Ensuite, il regroupe les données dans un tableau a deux dimensions, dans la premiere colonne, les differents entiers naturels premiers, dans l´autre colonne, leur nombre.

A partir de là, j´obtient le nombre de diviseurs possibles pour ce nombre de depart.

Et je compte ensuite fournit tous ces diviseurs differents.
Je sais tres bien que l´on peut afficher ces diviseurs un par un, mais ca prend plus de temps, et je veut utiliser ce que j´ai déja.

(Nombre 1982540 a la base)
1982540 = 2*2*5*7*7*7*17*14

Voici le tableau a deux dimensions :

Colonne1 - Colonne2
2 2
5 1
7 3
11 2

1982540 = 2² * 5 * 7(exposant3) * 17²

Il admet d diviseurs tel que :
d = (2+1) * (1+1) * (3+1) * (2+1) = 3*2*4*3 = 72

Et la je recherche ses diviseurs, on peut faire un arbre pour tous les trouver.

Argh, erreurs ->

(Nombre 1982540 a la base)
1982540 = 2*2*5*7*7*7*17*17

Voici le tableau a deux dimensions :

Colonne1 - Colonne2
2 2
5 1
7 3
17 2

Merci guyver2 pour cette réponse.
C´est un peu la meme methode que j´utilise, les listes en plus.
Et faut que j´implémente les boucles for.
Je vais gerer toutes les données par des tableaux dynamiques en effet.

Terminé!

1. include <iostream>
2. include <math.h>
3. include <stdlib.h>

using namespace std;

int tableau[4][2]={ {2,2} , {5,1} , {7,3} , {17,2} };
int tableau2[4]={0};
int v=0;

void fonction(int a)
{
...for(int i=0 ; i<tableau[a][1]+1 ; i++)
...{
......tableau2[a]=i;
......if(a<3)
......{
.........fonction(a+1);
......}
......else
......{
.........int n=1;
.........for(int j=0 ; j<4 ; j++)
.........{

............n*=static_cast<int>(pow(tableau[j][0],
tableau2[j]));
.........}
.........v=v+1;
.........cout << "Diviseur " << v << " : " << n << "." << endl;
.........system("PAUSE");
......}
...}
}

int main(void)
{
...fonction(0);
...cout << "Nombre d´actions : " << v << endl;
...return 0;
}

Par conter, ils sont dans le désordre.
Je devrais pas avoir trop de mal a remettre en ordre.
La ca fonctionne que pour un exemple, mais j´ai les valeurs initiales avant de toutes facons, et j´ai le nombre de lignes, donc pas de problemes.

Pfff, dégouté...

J´ai retranscrit ca sur ma Graph35+, résultat, ca fonctionne pas, j´aurais dû m´en douter...
J´utilise un programme comme fonction, mais bon toutes les variables sont globales, alors forcement, le debut fonctionne, mais apres c´est du bon n´importe quoi

Dans le prog ANNEXE, je faisait comme ca pour tenter de gerer :

A++;
prog "ANNEXE"
A--;

Au moins, j´aurai utiliser la récursivitée, et je saurai mieux m´en servir la prochaine fois.