Exercice C++ Corrigé pour Débutant | Partie 3

#include <iostream>

int sommeChiffres(int nombre) {
    int somme = 0;

    // Tant que le nombre n'est pas nul
    while (nombre != 0) {
        // Ajoute le dernier chiffre à la somme
        somme += nombre % 10;  
        // Enlève le dernier chiffre du nombre
        nombre /= 10;          
    }

    return somme;
}

using namespace std;

int main() {
    int nombre;

    // Demander à l'utilisateur d'entrer un entier entre 0 et 1000
    cout << "Entrez un entier entre 0 et 1000: ";
    cin >> nombre;

    // Vérifier si l'entier est dans l'intervalle valide
    if (nombre < 0 || nombre > 1000) {
        cout <<"Le nombre doit être entre 0 et 1000."<< endl;
    } else {
        // Calculer et afficher la somme des chiffres
        int somme = sommeChiffres(nombre);
        cout <<"La somme des chiffres de "<< nombre <<" est: "<< somme << endl;
    }

    return 0;
}

Sortie:

Entrez un entier entre 0 et 1000: 122
La somme des chiffres de 122 est: 5

Explication:

Dans la fonction sommeChiffres:

• Calcule la somme des chiffres d'un entier donné.
• Utilise une boucle while pour extraire chaque chiffre avec l'opérateur % 10 et l'ajouter à la variable somme.
• Le nombre est ensuite divisé par 10 pour retirer le dernier chiffre jusqu'à ce que le nombre devienne zéro.

#include <iostream>

using namespace std;

void afficherFibonacci(int n) {
    int a = 0, b = 1, suivant;

    cout <<"La séquence de Fibonacci avec "<< n <<" éléments est: "<< endl;
    
    for (int i = 1; i <= n; ++i) {
        // Affiche le nombre courant de la séquence
        cout << a << " "; 
        
        // Calcul du prochain nombre de Fibonacci
        suivant = a + b;
        a = b;
        b = suivant;
    }

    cout << endl;
}

int main() {
    int nombreElements;

    // Demander à l'utilisateur le nombre d'éléments de la séquence 
    // de Fibonacci
    cout <<"Entrez le nombre d'éléments de la séquence de Fibonacci:";
    cin >> nombreElements;

    // Afficher la séquence
    afficherFibonacci(nombreElements);

    return 0;
}

Sortie:

Entrez le nombre d'éléments de la séquence de Fibonacci: 10
La séquence de Fibonacci avec 10 éléments est: 
0 1 1 2 3 5 8 13 21 34

Explication:

Dans la fonction afficherFibonacci():

• Affiche la séquence de Fibonacci avec n éléments.
• Les deux premiers nombres de la séquence sont a = 0 et b = 1.
• À chaque itération de la boucle, le prochain nombre est la somme des deux précédents.
• Les variables a et b sont mises à jour pour les prochains calculs.

#include <iostream>

using namespace std;

void fizzBuzz(int nombre) {
    if (nombre % 3 == 0 && nombre % 5 == 0) {
        // Multiples de 3 et 5
        cout << "FizzBuzz" << endl; 
    } else if (nombre % 3 == 0) {
        // Multiples de 3
        cout << "Fizz" << endl; 
    } else if (nombre % 5 == 0) {
        // Multiples de 5
        cout << "Buzz" << endl; 
    } else {
        // Ni multiple de 3, ni de 5
        cout << nombre << endl; 
    }
}

int main() {
    int nombre;

    // Demander à l'utilisateur d'entrer un nombre
    cout << "Entrez un nombre: ";
    cin >> nombre;

    // Appeler la fonction FizzBuzz pour ce nombre
    fizzBuzz(nombre);

    return 0;
}

Sortie:

Entrez un nombre: 15
FizzBuzz

Explication:

La fonction fizzBuzz() vérifie le nombre saisi par l'utilisateur:

• Si le nombre est divisible par 3 et 5, elle affiche « FizzBuzz ».
• Si le nombre est divisible par 3, elle affiche « Fizz ».
• Si le nombre est divisible par 5, elle affiche « Buzz ».
• Si aucune de ces conditions n'est remplie, elle affiche le nombre lui-même.

#include <iostream>
#include <string>

using namespace std;

string convertirEnBinaire(int nombre) {
    string binaire = "";

    if (nombre == 0) {
        return "0"; // Le binaire de 0 est 0
    }

    while (nombre > 0) {
        // Ajouter le reste de la division à gauche de la chaîne
        binaire = to_string(nombre % 2) + binaire; 
        nombre /= 2; // Diviser le nombre par 2
    }

    return binaire;
}

int main() {
    int nombre;

    // Demander à l'utilisateur d'entrer un entier
    cout << "Entrez un nombre entier: ";
    cin >> nombre;

    // Appeler la fonction pour convertir en binaire et afficher le 
    // résultat
    string resultat = convertirEnBinaire(nombre);
    cout <<"Le nombre en binaire est: "<< resultat << endl;

    return 0;
}

Sortie:

Entrez un nombre entier: 10
Le nombre en binaire est: 1010

Explication:

Dans l'exercice ci-dessus la fonction convertirEnBinaire():

• Cette fonction convertit un nombre entier en binaire.
• Si le nombre est 0, elle retourne directement "0" (car c'est une exception).
• Elle utilise une boucle while qui continue tant que le nombre est supérieur à 0. À chaque itération :
• Elle calcule le reste de la division par 2 (ce qui correspond à un chiffre binaire, soit 0 soit 1) et le place à gauche de la chaîne binaire.
• Elle divise le nombre par 2 jusqu'à ce qu'il atteigne 0.

#include <iostream>
#include <iomanip> // Pour std::hex et std::uppercase

using namespace std;

string convertirEnHexa(int nombre) {
    // Chaîne pour stocker la valeur hexadécimale
    string hex = ""; 

    // Vérifier si le nombre est zéro
    if (nombre == 0) {
        return "0";
    }

    while (nombre > 0) {
        // Récupérer le reste pour la conversion
        int reste = nombre % 16; 

        // Convertir le reste en caractère hexadécimal
        if (reste < 10) {
            // Ajout des chiffres 0-9
            hex = static_cast<char>('0' + reste) + hex; 
        } else {
            // Ajout des lettres A-F
            hex = static_cast<char>('A' + (reste - 10)) + hex; 
        }

        // Diviser par 16 pour obtenir le prochain chiffre
        nombre /= 16; 
    }

    return hex;
}

int main() {
    int nombre;

    // Demander à l'utilisateur d'entrer un entier
    cout << "Entrez un nombre décimal: ";
    cin >> nombre;

    // Appeler la fonction pour convertir en hexadécimal et afficher
    // le résultat
    string resultat = convertirEnHexa(nombre);
    cout <<"Le nombre en hexadécimal est: "<< resultat << endl;

    return 0;
}

Sortie:

Entrez un nombre décimal: 255
Le nombre en hexadécimal est: FF

Explication:

Dans l'exercice ci-dessus, la fonction convertirEnHexa():

• Cette fonction prend un entier décimal et le convertit en hexadécimal.
• Si le nombre est 0, elle retourne "0" directement.
• Une boucle while continue tant que le nombre est supérieur à 0. À chaque itération :
  • Elle calcule le reste de la division par 16, ce qui correspond à un chiffre hexadécimal.
  • Si le reste est inférieur à 10, il est converti en caractère en ajoutant '0'.
  • Si le reste est supérieur ou égal à 10, il est converti en lettre (A-F) en ajoutant 'A' moins 10.
  • Le nombre est ensuite divisé par 16 pour passer au chiffre suivant.

#include <iostream>
#include <string>

using namespace std;

string convertirEnOctal(int nombre) {
    // Chaîne pour stocker la valeur octale
    string octal = ""; 

    // Vérifier si le nombre est zéro
    if (nombre == 0) {
        return "0";
    }

    while (nombre > 0) {
        // Récupérer le reste pour la conversion
        int reste = nombre % 8; 
        // Ajouter le reste à gauche de la chaîne
        octal = to_string(reste) + octal; 
        // Diviser par 8 pour obtenir le prochain chiffre
        nombre /= 8; 
    }

    return octal;
}

int main() {
    int nombre;

    // Demander à l'utilisateur d'entrer un entier
    cout << "Entrez un nombre décimal: ";
    cin >> nombre;

    // Appeler la fonction pour convertir en octal et afficher le 
    // résultat
    string resultat = convertirEnOctal(nombre);
    cout <<"Le nombre en octal est: "<< resultat << endl;

    return 0;
}

Sortie:

Entrez un nombre décimal: 65
Le nombre en octal est: 101

Explication:

Dans l'exercice ci-dessus, la fonction convertirEnOctal() :

• Cette fonction prend un entier décimal et le convertit en octal.
• Si le nombre est 0, elle retourne "0" directement.
• Une boucle while continue tant que le nombre est supérieur à 0. À chaque itération :
  • Elle calcule le reste de la division par 8, ce qui correspond à un chiffre octal.
  • Le reste est converti en chaîne de caractères et ajouté à gauche de la chaîne octal.
  • Le nombre est ensuite divisé par 8 pour passer au chiffre suivant.

#include <iostream>
#include <string>
#include <cmath>

using namespace std;

int convertirEnDecimal(const string& binaire) {
    // Variable pour stocker le résultat décimal
    int decimal = 0; 

    // Parcourir chaque caractère de la chaîne binaire de droite à 
    // gauche
    for (int i = 0; i < binaire.length(); ++i) {
        // Vérifier si le caractère est un '1'
        if (binaire[binaire.length() - 1 - i] == '1') {
            // Ajouter 2^i à la valeur décimale
            decimal += pow(2, i); 
        }
    }

    return decimal;
}

int main() {
    string binaire;

    // Demander à l'utilisateur d'entrer un nombre binaire
    cout << "Entrez un nombre binaire : ";
    cin >> binaire;

    // Appeler la fonction pour convertir en décimal et afficher le 
    // résultat
    int resultat = convertirEnDecimal(binaire);
    cout <<"Le nombre décimal est: "<< resultat << endl;

    return 0;
}

Sortie:

Entrez un nombre binaire: 1011
Le nombre décimal est: 11

Explication:

Dans l'exercice ci-dessus, la fonction convertirEnDecimal():

• Cette fonction prend une chaîne représentant un nombre binaire et la convertit en un entier décimal.
• Elle initialise une variable decimal à 0 pour stocker le résultat.
• Une boucle for parcourt chaque caractère de la chaîne binaire de droite à gauche (c'est-à-dire, du bit le moins significatif au bit le plus significatif).
• Si le caractère est '1', la fonction ajoute 2i2i à decimal, où ii est la position du bit.

#include <iostream>
#include <string>
#include <cmath>
#include <sstream> // Pour std::stringstream

using namespace std;

string convertirBinaireEnHexa(const string& binaire) {
    // Variable pour stocker la valeur décimale
    int decimal = 0; 

    // Convertir le nombre binaire en décimal
    for (int i = 0; i < binaire.length(); ++i) {
        if (binaire[binaire.length() - 1 - i] == '1') {
            // Ajouter 2^i à la valeur décimale
            decimal += pow(2, i); 
        }
    }

    // Convertir le nombre décimal en hexadécimal
    stringstream ss;
    ss << hex << decimal; // Convertir en hexadécimal
    return ss.str(); // Retourner la chaîne hexadécimale
}

int main() {
    string binaire;

    // Demander à l'utilisateur d'entrer un nombre binaire
    cout << "Entrez un nombre binaire: ";
    cin >> binaire;

    // Appeler la fonction pour convertir en hexadécimal et afficher
    // le résultat
    string resultat = convertirBinaireEnHexa(binaire);
    cout <<"Le nombre hexadécimal est: "<< resultat << endl;

    return 0;
}

Sortie:

Entrez un nombre binaire: 110110
Le nombre hexadécimal est: 36

Explication:

Dans l'exercice ci-dessus, la fonction convertirBinaireEnHexa():

• Cette fonction prend une chaîne représentant un nombre binaire et la convertit d'abord en décimal.
• Elle initialise une variable decimal à 0 pour stocker le résultat.
• Une boucle for parcourt chaque caractère de la chaîne binaire de droite à gauche. Si le caractère est '1', la fonction ajoute 2i2i à decimal, où ii est la position du bit.
• Après avoir obtenu la valeur décimale, la fonction utilise un std::stringstream pour convertir le nombre décimal en hexadécimal en utilisant std::hex.
• Elle retourne la chaîne hexadécimale résultante.

#include <iostream>
#include <string>
#include <cmath>

using namespace std;

// Fonction pour convertir un nombre binaire en décimal
int convertirBinaireEnDecimal(const string& binaire) {
    // Variable pour stocker la valeur décimale
    int decimal = 0; 

    // Convertir le nombre binaire en décimal
    for (int i = 0; i < binaire.length(); ++i) {
        if (binaire[binaire.length() - 1 - i] == '1') {
            // Ajouter 2^i à la valeur décimale
            decimal += pow(2, i); 
        }
    }

    return decimal; // Retourner la valeur décimale
}

// Fonction pour convertir un nombre décimal en octal
string convertirDecimalEnOctal(int decimal) {
    // Chaîne pour stocker la valeur octale
    string octal = ""; 

    // Vérifier si le nombre est zéro
    if (decimal == 0) {
        return "0";
    }

    while (decimal > 0) {
        // Récupérer le reste pour la conversion
        int reste = decimal % 8; 
        // Ajouter le reste à gauche de la chaîne
        octal = to_string(reste) + octal; 
        // Diviser par 8 pour obtenir le prochain chiffre
        decimal /= 8; 
    }

    return octal; // Retourner la chaîne octale
}

int main() {
    string binaire;

    // Demander à l'utilisateur d'entrer un nombre binaire
    cout << "Entrez un nombre binaire: ";
    cin >> binaire;

    // Convertir le nombre binaire en décimal
    int decimal = convertirBinaireEnDecimal(binaire);

    // Convertir le nombre décimal en octal
    string resultat = convertirDecimalEnOctal(decimal);

    // Afficher le résultat
    cout <<"Le nombre octal est: "<< resultat << endl;

    return 0;
}

Sortie:

Entrez un nombre binaire: 10110
Le nombre octal est: 26

Explication:

Dans l'exercice ci-dessus, la fonction convertirBinaireEnDecimal():

• Cette fonction prend une chaîne représentant un nombre binaire et la convertit en un entier décimal.
• Elle utilise une boucle for pour parcourir chaque bit du nombre binaire, en ajoutant 2i2i au total si le bit est '1'.

Fonction convertirDecimalEnOctal():

• Cette fonction prend un entier décimal et le convertit en une chaîne octale.
• Elle utilise une boucle while pour diviser le nombre décimal par 8, en collectant les restes jusqu'à ce que le nombre soit réduit à 0.