Introduction
Dans ce labo, vous allez apprendre à compter le nombre de bits actifs (1) dans un entier en utilisant des opérations au niveau des bits en programmation C. Le labo se compose de trois étapes : lire une entrée entière, utiliser des opérations au niveau des bits pour compter les bits actifs et afficher le nombre de bits actifs. À la fin de ce labo, vous aurez une meilleure compréhension des concepts de théorie des nombres et de mathématiques discrètes, ainsi que de leur application en programmation C.
Le labo commence par montrer comment lire une entrée entière de l'utilisateur, qui est la première étape de l'exercice de comptage des bits. Ensuite, il présente une fonction qui utilise des opérations au niveau des bits pour compter le nombre de bits actifs dans l'entier donné. Enfin, le programme affiche le nombre de bits actifs à l'utilisateur.
Lire un entier
Dans cette étape, vous allez apprendre à lire une entrée entière en programmation C pour compter les bits actifs. Nous allons créer un programme simple qui montre comment lire une entrée entière.
Tout d'abord, créons un fichier source C pour notre programme de comptage de bits :
cd ~/project
nano bit_counter.c
Maintenant, ajoutez le code suivant au fichier :
#include <stdio.h>
int main() {
int number;
// Demande à l'utilisateur d'entrer un entier
printf("Enter an integer: ");
// Lit l'entrée entière
scanf("%d", &number);
// Affiche le nombre entré
printf("You entered: %d\n", number);
return 0;
}
Compilons et exécutons le programme :
gcc bit_counter.c -o bit_counter
./bit_counter
Exemple de sortie :
Enter an integer: 42
You entered: 42
Explication du code :
#include <stdio.h>inclut la bibliothèque standard d'entrée/sortiescanf("%d", &number)lit une entrée entière de l'utilisateurprintf()est utilisé pour afficher les invitations et le nombre entré%dest le spécificateur de format pour les entiers
Ce simple programme montre comment lire une entrée entière, qui est la première étape de notre exercice de comptage de bits actifs.
Utiliser des opérations au niveau des bits pour compter les uns
Dans cette étape, vous allez apprendre à compter le nombre de bits actifs (1) dans un entier en utilisant des opérations au niveau des bits en C.
Modifions le fichier bit_counter.c précédent pour implémenter le comptage des bits :
cd ~/project
nano bit_counter.c
Remplacez le contenu précédent par le code suivant :
#include <stdio.h>
// Fonction pour compter les bits actifs en utilisant l'opération ET au niveau des bits
int countSetBits(int number) {
int count = 0;
while (number) {
// Vérifie le bit de poids faible
count += number & 1;
// Décalage à droite du nombre
number >>= 1;
}
return count;
}
int main() {
int number;
// Demande à l'utilisateur d'entrer un entier
printf("Enter an integer: ");
scanf("%d", &number);
// Compte et affiche le nombre de bits actifs
int setBitCount = countSetBits(number);
printf("Number of set bits in %d: %d\n", number, setBitCount);
return 0;
}
Compilez et exécutez le programme :
gcc bit_counter.c -o bit_counter
./bit_counter
Exemple de sortie :
Enter an integer: 42
Number of set bits in 42: 3
Explication du code :
- La fonction
countSetBits()utilise des opérations au niveau des bits pour compter les bits actifs number & 1vérifie le bit de poids faible (renvoie 1 si le bit est actif, 0 sinon)number >>= 1décale le nombre vers la droite, passant au bit suivant- La boucle continue jusqu'à ce que tous les bits aient été vérifiés
Détail des opérations au niveau des bits :
- 42 en binaire est 101010
- Positions des bits : 1 0 1 0 1 0
- Nombre de bits actifs : 3
Cette méthode compte efficacement le nombre de 1 dans un entier en utilisant un minimum d'étapes de calcul.
Afficher le nombre de bits actifs
Dans cette étape finale, nous allons améliorer notre programme de comptage de bits pour fournir une sortie plus détaillée et montrer différentes manières d'afficher le nombre de bits actifs.
Modifions le fichier bit_counter.c pour ajouter un affichage plus complet :
cd ~/project
nano bit_counter.c
Mettez à jour le code avec l'implémentation suivante :
#include <stdio.h>
// Fonction pour compter les bits actifs en utilisant l'opération ET au niveau des bits
int countSetBits(int number) {
int count = 0;
while (number) {
count += number & 1;
number >>= 1;
}
return count;
}
int main() {
int number;
// Demande à l'utilisateur d'entrer un entier
printf("Enter an integer: ");
scanf("%d", &number);
// Compte le nombre de bits actifs
int setBitCount = countSetBits(number);
// Affiche le nombre de bits actifs dans différents formats
printf("Decimal Number: %d\n", number);
printf("Binary Representation: ");
// Affiche la représentation binaire
for (int i = 31; i >= 0; i--) {
int bit = (number >> i) & 1;
printf("%d", bit);
}
printf("\n");
// Affiche les résultats du comptage des bits actifs
printf("Number of Set Bits: %d\n", setBitCount);
printf("Set Bit Percentage: %.2f%%\n",
(float)setBitCount / 32 * 100);
return 0;
}
Compilez et exécutez le programme :
gcc bit_counter.c -o bit_counter
./bit_counter
Exemple de sortie :
Enter an integer: 42
Decimal Number: 42
Binary Representation: 00000000000000000000000000101010
Number of Set Bits: 3
Set Bit Percentage: 9.38%
Explication du code :
- Ajout de l'affichage de la représentation binaire
- Inclusion du calcul du pourcentage de bits actifs
- Utilisation d'opérations au niveau des bits pour extraire les bits individuels
- Mise en forme de la sortie pour fournir différentes perspectives sur le comptage des bits
Le programme offre maintenant une vue complète de la composition binaire de l'entier, montrant :
- La valeur décimale
- La représentation binaire sur 32 bits complète
- Le nombre total de bits actifs
- Le pourcentage de bits actifs
Résumé
Dans ce labo, vous avez d'abord appris à lire une entrée entière en programmation C. Cela impliquait d'utiliser la fonction scanf() pour capturer l'entrée de l'utilisateur et la fonction printf() pour afficher le nombre entré. Ensuite, vous avez implémenté une fonction appelée countSetBits() qui utilise des opérations au niveau des bits pour compter le nombre de bits actifs (1) dans l'entier donné. Cette fonction parcourt les bits du nombre, vérifie le bit de poids faible en utilisant l'opération ET au niveau des bits, puis décale le nombre vers la droite pour passer au bit suivant. Le nombre de bits actifs est accumulé et renvoyé.
