Introduction
Dans ce laboratoire, vous apprendrez à déterminer la mode d'un jeu de données en C. Le laboratoire couvre les étapes suivantes :
Lecture du tableau de nombres : Vous apprendrez à lire un tableau de nombres en C, ce qui est la première étape cruciale pour déterminer la mode d'un jeu de données. Le programme permet d'entrer un ensemble de nombres et les prépare pour l'analyse de fréquence.
Compter les fréquences pour trouver la valeur la plus fréquente : Vous modifierez le programme précédent pour compter les fréquences de chaque nombre dans le tableau et identifier la valeur la plus fréquente (mode).
Afficher la mode : Enfin, vous afficherez la mode, qui est la valeur apparaissant le plus fréquemment dans le jeu de données.
Lecture du tableau de nombres
Dans cette étape, vous apprendrez à lire un tableau de nombres en C, ce qui est la première étape cruciale pour déterminer la mode d'un jeu de données. Nous allons créer un programme C qui permet d'entrer un ensemble de nombres et les prépare pour l'analyse de fréquence.
Tout d'abord, créons un nouveau fichier C pour notre programme de calcul de mode :
cd ~/project
nano mode_calculation.c
Maintenant, ajoutez le code suivant au fichier :
#include <stdio.h>
#define MAX_SIZE 100
int main() {
int numbers[MAX_SIZE];
int n, i;
// Saisie du nombre d'éléments
printf("Entrez le nombre d'éléments (max %d) : ", MAX_SIZE);
scanf("%d", &n);
// Saisie des éléments du tableau
printf("Entrez %d entiers :\n", n);
for (i = 0; i < n; i++) {
scanf("%d", &numbers[i]);
}
// Affichage du tableau saisi pour vérification
printf("Tableau saisi : ");
for (i = 0; i < n; i++) {
printf("%d ", numbers[i]);
}
printf("\n");
return 0;
}
Compilez et exécutez le programme :
gcc mode_calculation.c -o mode_calculation
./mode_calculation
Exemple de sortie :
Entrez le nombre d'éléments (max 100) : 5
Entrez 5 entiers :
3 4 2 4 1
Tableau saisi : 3 4 2 4 1
Décomposons les parties clés de ce code :
#define MAX_SIZE 100définit une limite maximale pour le tableau afin d'éviter les dépassements.scanf()est utilisé pour saisir le nombre d'éléments et les valeurs du tableau.- Nous affichons le tableau pour vérifier que l'entrée a été correctement capturée.
Ce code démontre la saisie de base d'un tableau en C, essentielle pour notre processus de calcul de mode. Dans les étapes suivantes, nous allons construire sur cette base pour compter les fréquences et déterminer la mode.
Compter les fréquences pour trouver la valeur la plus fréquente
Dans cette étape, nous allons modifier notre programme précédent pour compter les fréquences de chaque nombre dans le tableau et identifier la valeur la plus fréquente (mode).
Ouvrez le fichier existant et mettez à jour le code :
cd ~/project
nano mode_calculation.c
Remplacez le code précédent par la mise en œuvre suivante :
#include <stdio.h>
#define MAX_SIZE 100
int main() {
int numbers[MAX_SIZE];
int frequencies[MAX_SIZE] = {0};
int n, i, j, mode = 0, max_frequency = 0;
// Saisie du nombre d'éléments
printf("Entrez le nombre d'éléments (max %d) : ", MAX_SIZE);
scanf("%d", &n);
// Saisie des éléments du tableau
printf("Entrez %d entiers :\n", n);
for (i = 0; i < n; i++) {
scanf("%d", &numbers[i]);
}
// Comptage des fréquences de chaque nombre
for (i = 0; i < n; i++) {
int count = 1;
for (j = 0; j < n; j++) {
if (i != j && numbers[i] == numbers[j]) {
count++;
}
}
frequencies[i] = count;
// Suivi de la mode
if (count > max_frequency) {
max_frequency = count;
mode = numbers[i];
}
}
// Affichage des fréquences
printf("\nFréquences :\n");
for (i = 0; i < n; i++) {
printf("Le nombre %d apparaît %d fois\n", numbers[i], frequencies[i]);
}
// Affichage de la mode
printf("\nMode : %d (apparaît %d fois)\n", mode, max_frequency);
return 0;
}
Compilez et exécutez le programme :
gcc mode_calculation.c -o mode_calculation
./mode_calculation
Exemple de sortie :
Entrez le nombre d'éléments (max 100) : 6
Entrez 6 entiers :
2 3 4 2 2 5
Fréquences :
2 apparaît 3 fois
3 apparaît 1 fois
4 apparaît 1 fois
2 apparaît 3 fois
2 apparaît 3 fois
5 apparaît 1 fois
Mode : 2 (apparaît 3 fois)
Points clés de cette implémentation :
- Nous créons un tableau
frequenciespour stocker le compte de chaque nombre. - Des boucles imbriquées comptent les occurrences de chaque nombre unique.
- Nous suivons la mode en conservant la fréquence maximale.
- Le programme gère les cas avec un seul mode.
Afficher la Mode
Dans cette dernière étape, nous allons améliorer notre programme de calcul de mode pour gérer plusieurs modes et fournir une sortie plus complète d'informations statistiques.
Ouvrez le fichier existant et mettez à jour le code :
cd ~/project
nano mode_calculation.c
Remplacez le code précédent par la mise en œuvre suivante :
#include <stdio.h>
#define MAX_SIZE 100
int main() {
int numbers[MAX_SIZE];
int frequencies[MAX_SIZE] = {0};
int unique_numbers[MAX_SIZE];
int n, i, j, unique_count = 0, max_frequency = 0;
// Saisie du nombre d'éléments
printf("Entrez le nombre d'éléments (max %d) : ", MAX_SIZE);
scanf("%d", &n);
// Saisie des éléments du tableau
printf("Entrez %d entiers :\n", n);
for (i = 0; i < n; i++) {
scanf("%d", &numbers[i]);
}
// Recherche des nombres uniques et de leurs fréquences
for (i = 0; i < n; i++) {
int is_unique = 1;
for (j = 0; j < unique_count; j++) {
if (numbers[i] == unique_numbers[j]) {
is_unique = 0;
break;
}
}
if (is_unique) {
unique_numbers[unique_count] = numbers[i];
// Comptage de la fréquence pour ce nombre unique
int count = 0;
for (j = 0; j < n; j++) {
if (numbers[i] == numbers[j]) {
count++;
}
}
frequencies[unique_count] = count;
// Mise à jour de la fréquence maximale
if (count > max_frequency) {
max_frequency = count;
}
unique_count++;
}
}
// Affichage des informations détaillées sur la mode
printf("\nAnalyse statistique :\n");
printf("Nombres totaux : %d\n", n);
printf("Nombres uniques : %d\n", unique_count);
printf("\nDistribution des fréquences :\n");
for (i = 0; i < unique_count; i++) {
printf("Nombre %d : %d fois\n",
unique_numbers[i], frequencies[i]);
}
// Affichage des modes
printf("\nMode(s) :\n");
for (i = 0; i < unique_count; i++) {
if (frequencies[i] == max_frequency) {
printf("- %d (apparaît %d fois)\n",
unique_numbers[i], frequencies[i]);
}
}
return 0;
}
Compilez et exécutez le programme :
gcc mode_calculation.c -o mode_calculation
./mode_calculation
Exemple de sortie :
Entrez le nombre d'éléments (max 100) : 7
Entrez 7 entiers :
2 3 4 2 2 5 5
Analyse statistique :
Nombres totaux : 7
Nombres uniques : 4
Distribution des fréquences :
Nombre 2 : 3 fois
Nombre 3 : 1 fois
Nombre 4 : 1 fois
Nombre 5 : 2 fois
Mode(s) :
- 2 (apparaît 3 fois)
Améliorations clés de cette version :
- Gère plusieurs modes s'ils existent.
- Fournit une vue d'ensemble statistique complète.
- Identifie les nombres uniques dans l'ensemble de données.
- Affiche la distribution des fréquences.
Résumé
Dans ce laboratoire, vous apprendrez à lire un tableau de nombres en C et à compter les fréquences de chaque nombre pour déterminer la mode, qui est la valeur la plus courante dans l'ensemble de données. Tout d'abord, vous créerez un programme C qui permet d'entrer un ensemble de nombres et de les préparer pour l'analyse de fréquence. Ensuite, vous modifierez le programme pour compter les fréquences de chaque nombre et identifier la mode. Enfin, vous afficherez la mode sur la console.
Les points clés d'apprentissage des étapes complétées sont :
- Comment lire un tableau de nombres en C à l'aide de la fonction
scanf(). - Comment afficher le tableau entré pour vérifier l'entrée.
- Comment compter les fréquences de chaque nombre dans le tableau pour trouver la valeur la plus courante (mode).
