Proba 5 cas

[Anonyme]

salut ; je voudrais savoir comment on peut avoir toutes combinaisions de 5 chiffres par exemple : 1,2,3,4,5

[Anonyme]

ben ca part de 00000 à 99999 donc 100000 non?
euh ca doit pas etre ca..sinon ca serait pas dans le supérieur...

[mathador]

Salut
si tu comptes les cominaisons commençant par un ou plusieurs 0, tu en as 100 000... difficile de toutes les écrire !
Après, tu peux choisir de ne pas utiliser 10 chiffres ... en base n, tu auras combinaisons (d'où le résultat en base 10 usuelle)... mais ça dépend de ce que tu veux faire ! Déjà en base 3 ça te donne 243 combinaisons, donc pas évident de dépasser la base 2 (32 combinaisons) ...
et c'est niveau lycée, pas supérieur .... hop, je déménage la convers.
Bon courage, du reste !

[Anonyme]

wé t'a raison mais c pas ca je veux visualiser tous les cas t'a une idée?

[Galt]

L'énoncé est ambigu
Comment peut-on ordoner 5 chiffres ?
Combien de nombres peut-on écrire en utilisant 5 chiffres ?
...

[mathador]

wé t'a raison mais c pas ca je veux visualiser tous les cas t'a une idée?

Quel problème t'amène à cette douloureuse épine ? Tu pourras pas visualiser 100 000 cas différents ... il faut passer par des zolies formules avec plein de zolies lettres, tu t'en sortiras pas en étudiant les cas... sinon, le seul moyen de visualiser, c'est de dessiner un arbre qui fini avec 100 000 branches ! :briques:

[Anonyme]

salut!

j'ai n chiffres, je sait que le nombre de combinaisons est (n!), mais je veux un algorithme qui me donne (visualise) ces combinaisons.
exemple :pour n=3
123
132
213
231
312
321

merci

[mathador]

Ca peut sûrement se trouver, mais c'est inutilisable ! 5! = 120; donc pour le nombre de façons d'ordonner 5 chiffres distincts, tu auras une liste relativement longue ... 4!=24 ; et t'auras déjà 24 rangements à visualiser ... et 10! = 3 628 800 ... ça grimpe trop vite pour rester visualisable (et exploitable ...)

[singleton]

Voici comment j'avais fait ça en C (tu peux en déduire l'algo)

Code: Tout sélectionner

#include 
#include 
#include 

void permute(char* const);

int main(void) {
    char s[24];
    size_t fin;

    puts("Entrer les lettres :");
    fgets(s, sizeof s, stdin);
     
    fin = strlen(s)-1;
     
    if(s[fin] == '\n')
        s[fin] = '\0';
    if(s[0] == '\0')
        return 0;

    permute(s);

    return 0;
}


void permute(char* const s) {
    char
        c,
        *pRotation;
    const unsigned
        longueurchaine = strlen(s),
        maxcurseur = longueurchaine-1;
    unsigned
        *boucle = calloc(longueurchaine, sizeof *boucle);
    size_t
        curseur=0;
    FILE
        *fSortie = fopen("bidule.txt", "w");


    if(fSortie == NULL) {
        if(boucle == NULL)
            return;
        free(boucle);
        return;
    }
    if(boucle == NULL) {
        fclose(fSortie);
        return;
    }
     
    boucle[0] = longueurchaine;


    /* c'est cette boucle qui est interessante :*/
   while(boucle[0]) { 
      if(boucle[curseur]) { 
         while(curseur < maxcurseur) { 
            ++curseur; 
            boucle[curseur] = longueurchaine-curseur; 
         }
         fputs(s, fSortie);
         fputc('\n', fSortie); 
      } 
      else {
         --curseur;
         pRotation = s+curseur;
         c = *pRotation; 
         while(*pRotation = pRotation[1]) // Attention, ceci est une affectation suivie du test logique
            ++pRotation; 
         *pRotation = c; 
      } 
      --boucle[curseur];
   }
     
    free(boucle);
    fclose(fSortie);
}


Si tu as besoin d'explication n'hésite pas

[Anonyme]

Merci pour votre aide