Comment Calculer les Permutations (nPr) en C

Introduction

Dans ce laboratoire, nous apprendrons à calculer les permutations (nPr) en programmation C. Le laboratoire couvre les étapes suivantes :

Tout d'abord, nous lirons les valeurs d'entrée pour n et r, essentielles au calcul des permutations. Nous utiliserons la fonction scanf() pour obtenir les données de l'utilisateur et afficher les valeurs saisies pour confirmer l'entrée.

Ensuite, nous implémenterons des fonctions pour calculer la factorielle et la permutation (nPr) en utilisant la formule nPr = n! / (n-r)!. Nous gérerons le cas où r est supérieur à n et afficherons un message d'erreur en conséquence.

Lecture de n et de r

Dans cette étape, nous allons apprendre à lire les valeurs d'entrée pour n et r, essentielles au calcul des permutations en programmation C.

Tout d'abord, créons un nouveau fichier C pour implémenter notre programme de calcul de permutations :

cd ~/project
nano permutations.c

Maintenant, écrivons le code pour lire les valeurs d'entrée :

#include <stdio.h>

int main() {
    int n, r;

    printf("Entrez le nombre total d'éléments (n) : ");
    scanf("%d", &n);

    printf("Entrez le nombre d'éléments à sélectionner (r) : ");
    scanf("%d", &r);

    printf("Vous avez entré : n = %d, r = %d\n", n, r);

    return 0;
}

Exemple de sortie :

Entrez le nombre total d'éléments (n) : 5
Entrez le nombre d'éléments à sélectionner (r) : 3
Vous avez entré : n = 5, r = 3

Décomposons le code :

Nous utilisons scanf() pour lire les entrées entières de l'utilisateur.
%d est le spécificateur de format pour les entiers.
&n et &r sont les adresses mémoire où les valeurs d'entrée seront stockées.
Nous affichons les valeurs saisies pour confirmer l'entrée.

Compilation et exécution du programme :

gcc permutations.c -o permutations
./permutations

Calcul de nPr = n!/(n-r)!

Dans cette étape, nous allons implémenter une fonction pour calculer la permutation (nPr) en calculant les factorielles.

Modifions le fichier permutations.c précédent pour ajouter le calcul factoriel et le calcul de la permutation :

cd ~/project
nano permutations.c

Maintenant, mettons à jour le code avec les fonctions de calcul factoriel et de permutation :

#include <stdio.h>

// Fonction pour calculer la factorielle
unsigned long long factorial(int num) {
    unsigned long long result = 1;
    for (int i = 1; i <= num; i++) {
        result *= i;
    }
    return result;
}

// Fonction pour calculer la permutation (nPr)
unsigned long long permutation(int n, int r) {
    // Vérification de l'entrée invalide
    if (r > n) {
        printf("Erreur : r ne peut pas être supérieur à n\n");
        return 0;
    }

    // Calcul de nPr en utilisant la formule : n! / (n-r)!
    return factorial(n) / factorial(n - r);
}

int main() {
    int n, r;

    printf("Entrez le nombre total d'éléments (n) : ");
    scanf("%d", &n);

    printf("Entrez le nombre d'éléments à sélectionner (r) : ");
    scanf("%d", &r);

    unsigned long long result = permutation(n, r);

    if (result > 0) {
        printf("La permutation (nPr) de %d éléments pris %d à la fois est : %llu\n", n, r, result);
    }

    return 0;
}

Compilation et exécution du programme :

gcc permutations.c -o permutations
./permutations

Exemple de sortie :

Entrez le nombre total d'éléments (n) : 5
Entrez le nombre d'éléments à sélectionner (r) : 3
La permutation (nPr) de 5 éléments pris 3 à la fois est : 60

Points clés de l'implémentation :

La fonction factorial() calcule la factorielle d'un nombre donné.
La fonction permutation() implémente la formule nPr : n! / (n-r)!
Nous utilisons unsigned long long pour gérer les valeurs factorielles plus grandes.
La validation des entrées vérifie si r est inférieur ou égal à n.

Affichage du Résultat

Dans cette étape, nous allons améliorer notre programme de calcul de permutation en ajoutant des options de sortie plus détaillées et de formatage.

Modifions le fichier permutations.c pour améliorer la présentation du résultat :

cd ~/project
nano permutations.c

Mettre à jour le code avec une impression de résultat améliorée :

#include <stdio.h>

// Fonction pour calculer la factorielle
unsigned long long factorial(int num) {
    unsigned long long result = 1;
    for (int i = 1; i <= num; i++) {
        result *= i;
    }
    return result;
}

// Fonction pour calculer la permutation (nPr)
unsigned long long permutation(int n, int r) {
    // Vérification de l'entrée invalide
    if (r > n) {
        printf("Erreur : r ne peut pas être supérieur à n\n");
        return 0;
    }

    // Calcul de nPr en utilisant la formule : n! / (n-r)!
    return factorial(n) / factorial(n - r);
}

// Fonction pour afficher les détails de la permutation
void printPermutationDetails(int n, int r, unsigned long long result) {
    printf("\n--- Détails du calcul de la permutation ---\n");
    printf("Nombre total d'éléments (n) : %d\n", n);
    printf("Nombre d'éléments sélectionnés (r) : %d\n", r);
    printf("Calcul : %d P %d = %d! / (%d - %d)!\n", n, r, n, n, r);
    printf("Résultat : %llu arrangements différents possibles\n", result);
    printf("----------------------------------------\n");
}

int main() {
    int n, r;

    printf("Calculateur de permutation (nPr)\n");
    printf("Entrez le nombre total d'éléments (n) : ");
    scanf("%d", &n);

    printf("Entrez le nombre d'éléments à sélectionner (r) : ");
    scanf("%d", &r);

    unsigned long long result = permutation(n, r);

    if (result > 0) {
        printPermutationDetails(n, r, result);
    }

    return 0;
}

Compilation et exécution du programme :

gcc permutations.c -o permutations
./permutations

Exemple de sortie :

Calculateur de permutation (nPr)
Entrez le nombre total d'éléments (n) : 5
Entrez le nombre d'éléments à sélectionner (r) : 3

--- Détails du calcul de la permutation ---
Nombre total d'éléments (n) : 5
Nombre d'éléments sélectionnés (r) : 3
Calcul : 5 P 3 = 5! / (5 - 3)!
Résultat : 60 arrangements différents possibles
----------------------------------------

Améliorations clés :

Ajout d'une fonction printPermutationDetails() dédiée.
Sortie plus informative sur le calcul.
Explication de la formule de permutation et du résultat.
Interface utilisateur améliorée avec un titre et une explication détaillée.

Résumé

Dans ce laboratoire, nous avons appris à lire les valeurs d'entrée pour n et r, essentielles au calcul des permutations en programmation C. Nous avons également implémenté des fonctions pour calculer la factorielle et la permutation (nPr) en utilisant la formule n! / (n-r)!.

Les points clés de l'apprentissage sont l'utilisation de scanf() pour lire les entrées entières, l'implémentation des fonctions de calcul factoriel et de permutation, et la gestion des entrées invalides où r est supérieur à n.