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

#include <iostream>
using namespace std;

int main() {
    // Déclarer un tableau d'entiers de taille fixe
    int tab[] = {10, 20, 10, 30, 10, 20, 40, 10};
    // Calculer la taille du tableau
    int taille = sizeof(tab) / sizeof(tab[0]);  

    int count10 = 0, count20 = 0;

    // Parcourir le tableau et compter les occurrences de 10 et 20
    for (int i = 0; i < taille; i++) {
        if (tab[i] == 10) {
            count10++;
        } else if (tab[i] == 20) {
            count20++;
        }
    }

    // Comparer le nombre de 10 avec le nombre de 20
    if (count10 > count20) {
      cout <<"Le nombre de 10 est supérieur au nombre de 20."<< endl;
    } else if (count10 < count20) {
      cout <<"Le nombre de 20 est supérieur au nombre de 10."<< endl;
    } else {
      cout <<"Le nombre de 10 et le nombre de 20 sont égaux."<< endl;
    }

    return 0;
}

Sortie:

Le nombre de 10 est supérieur au nombre de 20.

Explication:

Un tableau d'entiers est défini dans le programme.

Le programme compte les occurrences de 10 et de 20 à l'aide d'une boucle for pour parcourir le tableau.

Ensuite, il compare les deux compteurs et affiche le résultat.

#include <iostream>
using namespace std;

int main() {
    // Déclarer un tableau d'entiers de taille fixe
    int tab[] = {5, 8, 15, 25, 30, 45, 50};
    // Calculer la taille du tableau
    int taille = sizeof(tab) / sizeof(tab[0]);  

    bool contient10 = false;
    bool contient30 = false;

    // Parcourir le tableau pour vérifier la présence de 10 ou 30
    for (int i = 0; i < taille; i++) {
        if (tab[i] == 10) {
            contient10 = true;
        }
        if (tab[i] == 30) {
            contient30 = true;
        }
    }

    // Afficher les résultats
    if (contient10) {
        cout << "Le tableau contient 10." << endl;
    } else {
        cout << "Le tableau ne contient pas 10."<< endl;
    }

    if (contient30) {
        cout <<"Le tableau contient 30."<< endl;
    } else {
        cout <<"Le tableau ne contient pas 30."<< endl;
    }

    return 0;
}

Sortie:

Le tableau ne contient pas 10.
Le tableau contient 30.

Explication:

Le tableau tab[] est initialisé avec des valeurs entières.

Deux variables booléennes (contient10 et contient30) sont utilisées pour indiquer si les valeurs 10 ou 30 sont présentes.

Une boucle for parcourt le tableau, et si l'une des valeurs est trouvée, le booléen correspondant est mis à true.

Enfin, le programme affiche si le tableau contient 10 ou 30 en fonction des résultats.

#include <iostream>
using namespace std;

int main() {
    // Déclarer un tableau d'entiers de taille fixe
    int tab[] = {5, 10, 15, 10, 20, 25, 10, 30};
    // Calculer la taille du tableau
    int taille = sizeof(tab) / sizeof(tab[0]);  

    int count10 = 0;
    bool adjacent10 = false;

    // Parcourir le tableau pour compter les occurrences de 10 et 
    // vérifier les 10 adjacents
    for (int i = 0; i < taille; i++) {
        if (tab[i] == 10) {
            count10++;
            if (i > 0 && tab[i - 1] == 10) {
                // Un 10 est adjacent à un autre 10
                adjacent10 = true;  
            }
        }
    }

    // Vérifier si la valeur 10 apparaît trois fois et n'est pas 
    // adjacente à un autre 10
    if (count10 == 3 && !adjacent10) {
        cout << "La valeur 10 apparaît exactement trois fois et aucun 10 n'est adjacent." << endl;
    } else {
        if (count10 != 3) {
            cout << "La valeur 10 n'apparaît pas exactement trois fois." << endl;
        }
        if (adjacent10) {
            cout << "Il y a au moins deux 10 adjacents." << endl;
        }
    }

    return 0;
}

Sortie:

La valeur 10 apparaît exactement trois fois et aucun 10 n'est adjacent.

Explication:

Le tableau d'entiers tab[] est initialisé.

La variable count10 est utilisée pour compter le nombre de 10 dans le tableau.

La variable adjacent10 est utilisée pour vérifier si deux 10 se trouvent côte à côte.

Une boucle parcourt le tableau:

• Chaque fois qu'un 10 est rencontré, on incrémente count10.
• Si un 10 est précédé d'un autre 10 (vérification avec tab[i - 1]), on met adjacent10 à true.

Après la boucle, le programme vérifie :

• Si le nombre de 10 est exactement égal à 3.
• Si aucun 10 n'est adjacent à un autre.

Le programme affiche les résultats en fonction des conditions.

#include <iostream>
using namespace std;

int main() {
    // Déclarer un tableau d'entiers
    int tab[] = {5, 7, 8, 15, 20, 30, 25, 28};
    // Calculer la taille du tableau
    int taille = sizeof(tab) / sizeof(tab[0]);  
    bool troisAdjacentsCroissants = false;

    // Parcourir le tableau pour vérifier s'il y a trois nombres 
    // adjacents croissants
    for (int i = 0; i < taille - 2; i++) {
        if (tab[i] < tab[i + 1] && tab[i + 1] < tab[i + 2]) {
            troisAdjacentsCroissants = true;
            break;
        }
    }

    // Afficher le résultat
    if (troisAdjacentsCroissants) {
        cout << "Le tableau contient trois nombres adjacents croissants." << endl;
    } else {
        cout << "Le tableau ne contient pas trois nombres adjacents croissants." << endl;
    }

    return 0;
}

Sortie:

Le tableau contient trois nombres adjacents croissants.

Explication:

Le tableau d'entiers tab[] est initialisé.

La variable troisAdjacentsCroissants est utilisée pour indiquer si trois nombres adjacents croissants sont trouvés.

Une boucle parcourt le tableau jusqu'à la troisième dernière position (taille - 2), pour éviter les dépassements de tableau.

À chaque itération, elle compare trois nombres consécutifs:

• Si le nombre à l'indice i est strictement inférieur à celui à i + 1, et celui à i + 1 est inférieur à celui à i + 2, alors il y a trois nombres croissants.
• Si cette condition est remplie, la boucle s'arrête (break).

Le programme affiche le résultat selon la valeur de troisAdjacentsCroissants.

#include <iostream>
using namespace std;

// Fonction pour vérifier si un nombre est une puissance de 4
bool estPuissanceDe4(int n) {
    if (n <= 0) {
        // Les puissances de 4 sont des entiers positifs
        return false;  
    }

    // Vérifier si n est une puissance de 4
    while (n % 4 == 0) {
        n /= 4;
    }

    return (n == 1);
}

int main() {
    int n;

    // Entrer un nombre à vérifier
    cout << "Entrez un entier: ";
    cin >> n;

    // Vérifier si le nombre est une puissance de 4
    if (estPuissanceDe4(n)) {
        cout << n <<" est une puissance de 4."<< endl;
    } else {
        cout << n <<" n'est pas une puissance de 4."<< endl;
    }

    return 0;
}

Sortie:

Entrez un entier: 64
64 est une puissance de 4.

Explication:

La fonction estPuissanceDe4 prend un entier n comme paramètre:

• Si n est inférieur ou égal à 0, elle retourne false car les puissances de 4 sont toujours des entiers positifs.
• Tant que n est divisible par 4, le programme divise n par 4.
• Si, à la fin des divisions, le nombre devient 1, cela signifie que le nombre initial était une puissance de 4.

Le programme principal permet à l'utilisateur d'entrer un entier et utilise la fonction estPuissanceDe4 pour vérifier si l'entier est une puissance de 4, puis affiche le résultat.

#include <iostream>
using namespace std;

// Fonction pour additionner deux nombres sans utiliser d'opérateurs arithmétiques
int additionner(int a, int b) {
    while (b != 0) {
        // Calculer la retenue (carry)
        int carry = a & b;

        // Additionner sans tenir compte de la retenue
        a = a ^ b;

        // Décaler la retenue d'un bit vers la gauche
        b = carry << 1;
    }
    return a;
}

int main() {
    int n1, n2;

    // Entrer les deux nombres à additionner
    cout << "Entrez le premier nombre: ";
    cin >> n1;
    cout << "Entrez le deuxième nombre: ";
    cin >> n2;

    // Additionner les deux nombres sans opérateurs arithmétiques
    int res = additionner(n1, n2);

    // Afficher le résultat
    cout <<"Somme de "<< n1 <<" et "<< n2 <<" est: "<< res << endl;

    return 0;
}

Sortie:

Entrez le premier nombre: 2
Entrez le deuxième nombre: 4
La somme de 2 et 4 est: 6

Explication:

Dans la fonction additionner():

• Tant que la retenue n'est pas nulle (b != 0), on continue de calculer la somme.
• La somme partielle est stockée dans a en utilisant l'opération XOR.
• La retenue est décalée à gauche et stockée dans b pour l'ajouter au tour suivant.
• Le processus se répète jusqu'à ce que la retenue soit nulle, auquel cas a contient le résultat final.

#include <iostream>
using namespace std;

// Fonction pour fusionner deux tableaux triés
void fusionnerTableaux(int tab1[], int taille1, int tab2[], int taille2, int tableauFusion[]) {
    int i = 0, j = 0, k = 0;

    // Parcourir les deux tableaux et fusionner en ordre croissant
    while (i < taille1 && j < taille2) {
        if (tab1[i] < tab2[j]) {
            tableauFusion[k++] = tab1[i++];
        } else {
            tableauFusion[k++] = tab2[j++];
        }
    }

    // Ajouter les éléments restants du premier tableau, s'il y en a
    while (i < taille1) {
        tableauFusion[k++] = tab1[i++];
    }

    // Ajouter les éléments restants du deuxième tableau, s'il y en a
    while (j < taille2) {
        tableauFusion[k++] = tab2[j++];
    }
}

int main() {
    // Déclarer deux tableaux triés
    int tab1[] = {1, 3, 5, 7};
    int tab2[] = {2, 4, 6, 8, 10};

    int taille1 = sizeof(tab1) / sizeof(tab1[0]);
    int taille2 = sizeof(tab2) / sizeof(tab2[0]);

    // Créer un tableau pour stocker la fusion des deux tableaux
    int tableauFusion[taille1 + taille2];

    // Fusionner les deux tableaux triés
    fusionnerTableaux(tab1, taille1, tab2, taille2, tableauFusion);

    // Afficher le tableau fusionné
    cout << "Tableau fusionné trié: ";
    for (int i = 0; i < taille1 + taille2; i++) {
        cout << tableauFusion[i] << " ";
    }
    cout << endl;

    return 0;
}

Sortie:

Tableau fusionné trié: 1 2 3 4 5 6 7 8 10 

Explication:

La fonction fusionnerTableaux fusionne les deux tableaux en comparant les éléments respectifs:

• Si l'élément dans tableau1 est plus petit, il est ajouté dans tableauFusion, sinon c'est l'élément de tableau2 qui est ajouté.
• Ce processus se poursuit jusqu'à ce que tous les éléments des deux tableaux soient placés dans le tableau fusionné.

#include <iostream>
using namespace std;

// Fonction pour vérifier si un nombre est un palindrome
bool estPalindrome(int n) {
    int original = n;  // Sauvegarder le nombre original
    int renverse = 0;

    // Calculer le renversé du nombre
    while (n > 0) {
        // Extraire le dernier chiffre
        int chiffre = n % 10;
        // Ajouter le chiffre au renversé		
        renverse = renverse * 10 + chiffre;
        // Supprimer le dernier chiffre
        n /= 10;
    }

    // Vérifier si le nombre original est égal à son renversé
    return (original == renverse);
}

int main() {
    int n;

    // Entrer un nombre à vérifier
    cout << "Entrez un nombre positif: ";
    cin >> n;

    // Vérifier si le nombre est un palindrome
    if (n < 0) {
        cout << "Le nombre doit être positif." << endl;
    } else if (estPalindrome(n)) {
        cout << n << " est un palindrome." << endl;
    } else {
        cout << n << " n'est pas un palindrome." << endl;
    }

    return 0;
}

Sortie:

Entrez un nombre positif: 121
121 est un palindrome.

Explication:

La fonction commence par sauvegarder le nombre original dans une variable original.

Ensuite, elle calcule le renversé du nombre en extrayant les chiffres un par un (en utilisant % 10 pour obtenir le dernier chiffre et / 10 pour supprimer le dernier chiffre), puis en les ajoutant au nombre renversé.

Une fois que le nombre est renversé, elle compare le nombre original avec son renversé. Si les deux sont identiques, le nombre est un palindrome.

#include <iostream>
#include <cmath>  // Pour utiliser la fonction sqrt()
using namespace std;

int main() {
    double n, racineCarree;

    // Entrer un nombre
    cout << "Entrez un nombre: ";
    cin >> n;

    // Vérifier si le nombre est négatif
    if (n < 0) {
        cout << "La racine carrée d'un nombre négatif n'est pas définie dans l'ensemble des réels." << endl;
    } else {
        // Calculer la racine carrée
        racineCarree = sqrt(n);

        // Afficher le résultat
        cout <<"La racine carrée de "<< n <<" est: "<< racineCarree << endl;
    }

    return 0;
}

Sortie:

Entrez un nombre: 25
La racine carrée de 25 est: 5

Explication:

Si le nombre est positif ou zéro, la fonction sqrt() (de la bibliothèque <cmath>) est utilisée pour calculer la racine carrée du nombre.