Discussion :

[siempre]

Bonjour,

Je voulais stocker le résultat dans un tableau pour l'utiliser après donc ce tableau qui sera allouer dynamiquement mais le problème est combien on doit réserver des cases pour ce tableau car le résultat ne contient pas toutes les combinaisons sauf de taille 2 jusqu'à taille N?
Si on N=4 alors le nombre de toutes les combinaisons sont :

Code :

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

1
2
3
 
int nombre;
nombre=pow(2,N);

Mais en réalité la taille de tableau est inférieur que 'nombre' alors pour la libération après de ce tableau est ce que je fais jusqu'à la taille 'nombre' ou bien jusqu'à le nombre des cases réellement remplies?

Est ce que on peut déterminer par une formule ou autre ? :
- les combinaisons de taille 2: ici on a 6 si N=4
- les combinaisons de taille 3: ici on a 4 si N=4
- les combinaisons de taille 4: ici on a 1 si N=4

Quel l'équivalent de cette formule en C ?

Merci.

[SofEvans]

C'est a toi de determiner le nombre de case que tu veux avoir.

Je n'ai pas compris comment tu determine le nombre de case que tu veux, mais si tu as une formule pour connaitre cette taille, alors fais ceci :

Code :

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

1
2
3
4
5
6
 
int nombreDeCase;
 
/* Ton traitement pour savoir ton nombre de case */
 
Tableau = malloc (sizeof(/* Type */ * nombreDeCase));

Si je n'ai pas repondu a ta question, reformule la correctement s'il te plait.

[diogene]

Mais en réalité la taille de tableau est inférieur que 'nombre' alors pour la libération après de ce tableau est ce que je fais jusqu'à la taille 'nombre' ou bien jusqu'à le nombre des cases réellement remplies?

Tu dois désallouer tout ce que tu as alloué : Si tu as alloué par p = malloc(....), tu désalloues par free(p);

Est ce que on peut déterminer par une formule ou autre ? :
- les combinaisons de taille 2: ici on a 6 si N=4
- les combinaisons de taille 3: ici on a 4 si N=4
- les combinaisons de taille 4: ici on a 1 si N=4

Le nombre de combinaisons de taille p est N!/p!/(N-p)!

[siempre]

Le nombre de combinaisons de taille p est N!/p!/(N-p)!

Oui.
Quelle est l'équivalent de cette formule en C ?

Il y a des fonctions prédéfinies en C pour cette formule?

[Pouet_forever]

Il y a des fonctions prédéfinies en C pour cette formule?

Non il faut que tu les crées toi-même ...

[SofEvans]

Je ne sais plus comment on appel '!', mais elle n'est pas presente dans math.h.
Cependant, refaire cette fonction est tres facile:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
int FonctionMystere (int nombre)
{
    int resultat = nombre;
    int i;
 
    for (i=2, i<nombre ; i++)
        resultat *= i;
 
    return resultat;
}

et ensuite, il ne reste plu qu'a l'appliquer :

Code :

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

1
2
 
N!/p!/(N-p)!

Code :

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

1
2
 
FonctionMystere (N) / FonctionMystere (p) / FonctionMystere (N-p);

Ps : vous etes sur que la formule est bonne ?
Il me semblait que c'etait :

Code :

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

1
2
3
4
 
                   N!
Combinaison = -----------
              p!(N-p)!

[Pouet_forever]

C'est la factorielle
Mais bon je trouve que l'utilisation de la factorielle est assez limitée en C parce qu'on dépasse vite la capacité d'une variable