Algo affichage combinaison de p elemt parmi n

Bonjour,

je ne sais pas si vous attendez toujours une réponse mais j'ai une proposition de solution basée sur l'emploi d'un algorithme récursif codée en langage c.

Bonne journée.

merci beaucoup proto ;
dans ce programme, le nombre d'éléments de tab (n) est choisie arbitrairement(si je écrit 3 le programme fais les combinaisons possibles avec 1 2 et 3 et si je écrit n=4 (1 2 3 et 4)
est que se possibles de ecrire moi meme les n elements( par exemple si je ecrit 3 je doit obligatoirement choisit 3 entiers avec lesquels je fait les combinaisons possibles) c-a-d il faut lorsque je clic sur Run le programme doit m'écrit :
definir n (nombre d'elements de tab ):
saisir les n éléments:
définir p ( nombre d'éléments à combiner ):
et après le programme affiche les combinaisons possibles de n éléments a base de p

remarques:
par exemple si j'ecrit n=3 et p = 8 lorsque le conteur tourne au début je voit les premiers combinaisons et lorsqu'il s'arrête je voit seulement les derniers combinaisons c-a-d le programme n'affiche pas tout les combinaisons si p>=6 et n= 3 et dans beaucoup d'autre cas lorsque je agrandit n et p
et d'autre par le programme n'affiche pas les combinaisons si p>10 parce que les éléments de tableau sont un peut décalé
en conclusion le programme que je suit entraine de recherchée semble beaucoup au programme que tu m'envoie avec seulement n , les n éléments et p saisie au clavier et le programme affiche tout les combinaisons possibles même si n et p sont grande
si n'est pas possible de réaliser ce programme je fixe n = 3 et je laisse p variable(saisie au clavier).

ce qui concerne la récursivité je ne sait pas qu'est que sa fait dire récursivité et à quoi ça sert?

je vous remercie une autre fois proto et a bientôt

Voici un programme tres court et tres efficace:

#include <stdio.h>
void main(int argc, char *argv[]) {
const int n = 5; const int k = 3;
int comb[40] = {0};
int i = 0;
while (i >= 0) {
if (comb[i] < n + i - k + 1) { comb[i]++;
if (i == k - 1) {
for (int j = 0; j < k; j++) printf("%d ", comb[j]); printf("\n");
} else { comb[++i] = comb[i - 1]; }
} else i--; } }

Oups je me suis trompé
les combinaisons de 1.2.3 avec p=2 sont :
12
13
23

Bonjour à tous je me suis à mon tour, penché sur cette question et je suis tombé sur ce post.
J'ai donc pris mon mal en patiente et tenté d'en faire un moi même. ce code est en Action script 2.0 (langage de flash) mais je pense que la syntaxe est proche du C à la déclaration de quelques variables près. j'ai tenté de commenter le code et je demeure ouvert à toute suggestion/optimisation:

//pour connaitre le nombre de combinaisons possibles
function c(k,n){
tot=1;
for(r=n;r>k;r--){tot*=r;}
for(r=(n-k);r>1;r--){tot/=r;}
return(tot);
}

//la fonction suivante retourne un tableau de longueur c(k,n),ou k représente la longueur du tableau passé en //paramètre, contenant pour chaque indice un tableau contenant n elements constituant une combinaison unique

function combi(arr_in,n){

//initialisation du tableau detiné à recevoir une combinaison par indice
//pour les languages n'autorisant pas la création de tableaux de longueur dynamique: //C(k,n)=n!/(k!(n-k)!),cf:fonction donnée plus haut
comb=[];

fini=false;
//initialisation d'un tableau de longueur n destiné à recevoir les n indices du tableau d'entrée reçu en paramètre //constituant un élément de la combinaison en cours
id=Array(n);
//affectation de valeurs croissantes -1 pour le dernier indice
for(cptid=0;cptid<n;cptid++){id[cptid]=cptid;}
id[n-1]=id[n-1]-1;

//l'algorithme avec k fixé prendrait l'allure de k boucles for imbriquées
//j'ai ici simulé un tel comportement par l'utilisation d'une boucle parcourant k avec une structure conditionnelle //testant le non dépassement des indices:
//incrémentation si non dépassement,changement de dimension de la boucle dans la clause else

while(!fini){
exit=false;
for(i=n-1;i>=0 && !exit;i--){
if(id[i]<arr_in.length-n+i){
id[i]++;
exit=true;
}else{
fini=(i==0);
first=true;
for(cpt=(n-i);cpt>0;cpt--){
id[n-cpt]=id[(n-1)-cpt]+((first)?2:1);
first=false;
}
}
}
if(!fini){
//construction du tableau contenant la combinaison en cours
arr_aux=Array(n);
for(cptid=0;cptid<n;cptid++){arr_aux[cptid]=arr_in[id[cptid]];}

//ajout de cette combinaison au tableau en contenant l'intégralité
comb.push(arr_aux);
}
}
return comb;
}

//test de la fonction
trace("["+combi(["A","B","C","D","E","F","G"],5).join("]"+chr(13)+"[")+"]");

voilà ceci fonctionne aussi avec un tableau d'entiers, ou même d'objets
attention, je n'ai pas mis de gestion d'erreur dans le cas ou le tableau serait plus petit que k, sous flash cela retourne un tableau vide, mais génèrera sans doute des erreurs dans un langage tel que C

Je ne sais pas si tu as trouvé ta solution mais j'ai fais un petit algo qui fait ca...
J'ai posté un petit résumé sur mon site : http://www.ogulrok.com/post/Petit_algo_pour_me_faire_perdre_mon_temps/102/default.aspx
Comme je dis dans mon "résumé", c'est pas l'algo du siècle mais bon ca fait la job (et c'est du C#)...
J'espère que ca t'aidera...

salut
sais-tu ce qu'est la récursivité ? à quoi ça sert ? comment s'en servir ?

Voilà un algorithme possible mais qui ne me satisfait pas vraiment car il faut éliminer les doublons, ce que fait la ligne "Instr......"

en VB

Sub Form_Load()

combinaison mot
End Sub

Sub combinaison(mot)

If Len(mot) = 1 Then Exit Sub
For i = 1 To Len(mot)
tmp = Left(mot, i - 1) & Mid(mot, i + 1)
If InStr(1, x, " " & tmp & " ") = 0 Then x = x & tmp & " ": Msgbox tmp :combinaison tmp
Next
End Sub