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

#include <iostream>
using namespace std;

void multiplierTableaux(int tab1[], int tab2[], int res[], int taille) {
    // Multiplier les éléments correspondants des deux tableaux
    for (int i = 0; i < taille; i++) {
        res[i] = tab1[i] * tab2[i];
    }
}

int main() {
    const int TAILLE = 3;  // Taille des tableaux
    int tab1[TAILLE], tab2[TAILLE], res[TAILLE];

    // Saisie des éléments du premier tableau
    cout << "Entrez " << TAILLE << " entiers pour remplir le premier tableau: " << endl;
    for (int i = 0; i < TAILLE; i++) {
        cin >> tab1[i];
    }

    // Saisie des éléments du deuxième tableau
    cout << "Entrez " << TAILLE << " entiers pour remplir le deuxième tableau: " << endl;
    for (int i = 0; i < TAILLE; i++) {
        cin >> tab2[i];
    }

    // Multiplier les éléments correspondants des deux tableaux
    multiplierTableaux(tab1, tab2, res, TAILLE);

    // Afficher les résultats
    cout << "Résultat de la multiplication des éléments correspondants: ";
    for (int i = 0; i < TAILLE; i++) {
        cout << res[i] << " ";
    }
    cout << endl;

    return 0;
}

Sortie:

Entrez 3 entiers pour remplir le premier tableau: 
1
2
3
Entrez 3 entiers pour remplir le deuxième tableau: 
3
2
1
Résultat de la multiplication des éléments correspondants: 3 4 3 

Explication:

La fonction multiplierTableaux() prend deux tableaux en entrée, multiplie les éléments correspondants, et stocke les résultats dans un troisième tableau.

Le programme principal demande à l'utilisateur de remplir deux tableaux d'entiers (de longueur 3), multiplie les éléments correspondants des deux tableaux, puis affiche le tableau contenant les résultats.

#include <iostream>
#include <string>
using namespace std;

bool commencePar(const string& str, const string& mot) {
    // Vérifier si la chaîne commence par le mot spécifié
    return str.rfind(mot, 0) == 0;
}

int main() {
    string str, mot;

    // Saisie de la chaîne de caractères
    cout << "Entrez une chaîne de caractères: ";
    getline(cin, str);

    // Saisie du mot à vérifier
    cout << "Entrez le mot à vérifier: ";
    getline(cin, mot);

    // Vérifier si la chaîne commence par le mot
    if (commencePar(str, mot)) {
        cout <<"La chaîne commence par le mot \""<< mot <<"\"."<< endl;
    } else {
        cout <<"La chaîne ne commence pas par le mot \""<< mot <<"\"."<< endl;
    }

    return 0;
}

Sortie:

Entrez une chaîne de caractères: Hi Alex!
Entrez le mot à vérifier: Hi
La chaîne commence par le mot "Hi".

Explication:

La fonction commencePar() utilise la méthode rfind() de la classe string, qui permet de rechercher un mot dans une chaîne. Lorsqu'il est utilisé avec 0 comme second argument, cela vérifie si le mot est trouvé au tout début de la chaîne. Si le mot est trouvé à l'indice 0, cela signifie que la chaîne commence par ce mot.

Le programme principal demande à l'utilisateur de saisir une chaîne de caractères et un mot à vérifier, puis il affiche si la chaîne commence par ce mot ou non.

Ce processus (parfois appelé la conjecture de Syracuse ou la conjecture de Collatz) en prenant un entier n et en appliquant les règles de division par 2 si n est pair, ou de multiplication par 3 et ajout de 1 si n est impair, jusqu'à ce que n soit égal à 1.

Solution:

#include <iostream>
using namespace std;

void collatz(int n) {
    // Répéter le processus jusqu'à ce que n = 1
    while (n != 1) {
        cout << n << " "; // Afficher la valeur actuelle de n
        
        if (n % 2 == 0) {
            // Si n est pair, le diviser par 2
            n /= 2;
        } else {
            // Si n est impair, le multiplier par 3 et ajouter 1
            n = 3 * n + 1;
        }
    }
    // Afficher 1 à la fin
    cout << n << endl;
}

int main() {
    int n;

    // Saisie de l'entier n
    cout << "Entrez un entier positif: ";
    cin >> n;

    // Vérifier que n est positif
    if (n <= 0) {
        cout <<"Veuillez entrer un entier positif supérieur à 0."<< endl;
    } else {
        // Exécuter la fonction Collatz
        cout <<"Les étapes de la conjecture de Collatz pour n = "<< n <<" sont: "<< endl;
        collatz(n);
    }

    return 0;
}

Sortie:

Les étapes de la conjecture de Collatz pour n = 6 sont:
6 3 10 5 16 8 4 2 1

Explication:

La fonction collatz prend un entier n en entrée et répète le processus de division par 2 pour les nombres pairs et de multiplication par 3 suivi de l'ajout de 1 pour les nombres impairs, jusqu'à ce que n devienne 1.

Le programme principal demande à l'utilisateur de saisir un entier positif, vérifie que n est supérieur à 0, puis appelle la fonction collatz pour afficher les étapes du processus.

#include <iostream>
using namespace std;

void compterPairsImpairs(int tab[], int taille, int &nbrPairs, int &nbrImpairs) {
    // Initialiser les compteurs
    nbrPairs = 0;
    nbrImpairs = 0;

    // Parcourir le tableau et compter les éléments pairs et impairs
    for (int i = 0; i < taille; i++) {
        if (tab[i] % 2 == 0) {
            nbrPairs++;
        } else {
            nbrImpairs++;
        }
    }
}

int main() {
    int taille;

    // Saisie de la taille du tableau
    cout << "Entrez la taille du tableau: ";
    cin >> taille;

    int tab[taille];

    // Saisie des éléments du tableau
    cout << "Entrez " << taille << " entiers: " << endl;
    for (int i = 0; i < taille; i++) {
        cin >> tab[i];
    }

    int nbrPairs, nbrImpairs;

    // Compter les éléments pairs et impairs
    compterPairsImpairs(tab, taille, nbrPairs, nbrImpairs);

    // Afficher les résultats
    cout <<"Nombre d'éléments pairs: "<< nbrPairs << endl;
    cout <<"Nombre d'éléments impairs: "<< nbrImpairs << endl;

    return 0;
}

Sortie:

Entrez la taille du tableau: 5
Entrez 5 entiers: 
1
2
3
4
5
Nombre d'éléments pairs: 2
Nombre d'éléments impairs: 3

Explication:

La fonction compterPairsImpairs() prend un tableau et sa taille en entrée, ainsi que deux références pour stocker les résultats : nombrePairs et nombreImpairs. Elle parcourt chaque élément du tableau et utilise l'opérateur modulo (%) pour déterminer si un nombre est pair ou impair.

Le programme principal permet à l'utilisateur de définir la taille du tableau, de saisir les éléments, puis d'afficher le nombre d'éléments pairs et impairs.

#include <iostream>
using namespace std;

bool contientAdjacent(int tab[], int taille, int valeur) {
    // Vérifier si la valeur spécifiée apparaît deux fois 
    // consécutives dans le tableau
    for (int i = 0; i < taille - 1; i++) {
        if (tab[i] == valeur && tab[i + 1] == valeur) {
            return true;
        }
    }
    return false;
}

bool verifierCondition(int tab[], int taille) {
    bool a20Adjacent = contientAdjacent(tab, taille, 20);
    bool a80Adjacent = contientAdjacent(tab, taille, 80);

    // Retourner vrai si un seul des deux (20 adjacent ou 80 
    // adjacent) est vrai
    return (a20Adjacent || a80Adjacent) && !(a20Adjacent && a80Adjacent);
}

int main() {
    int taille;

    // Saisie de la taille du tableau
    cout << "Entrez la taille du tableau: ";
    cin >> taille;

    int tab[taille];

    // Saisie des éléments du tableau
    cout <<"Entrez "<< taille <<" entiers: "<< endl;
    for (int i = 0; i < taille; i++) {
        cin >> tab[i];
    }

    // Vérification de la condition
    if (verifierCondition(tab, taille)) {
        cout << "Le tableau contient soit deux 20 adjacents, soit deux 80 adjacents, mais pas les deux." << endl;
    } else {
        cout << "Le tableau ne satisfait pas la condition." << endl;
    }

    return 0;
}

Sortie:

Entrez la taille du tableau: 4
Entrez 4 entiers: 
20
20
10
30
Le tableau contient soit deux 20 adjacents, soit deux 80 adjacents, mais pas les deux.

Explication:

La fonction contientAdjacent vérifie si une valeur spécifiée (soit 20, soit 80) apparaît deux fois consécutives dans le tableau.

La fonction verifierCondition utilise cette fonction pour vérifier s'il y a des 20 adjacents ou des 80 adjacents, mais pas les deux simultanément. Elle retourne true si la condition est satisfaite, et false sinon.

Le programme principal demande à l'utilisateur de saisir un tableau d'entiers, puis vérifie et affiche le résultat selon la condition décrite.

#include <iostream>
using namespace std;

void reordonnerImpairsPuisPairs(int tab[], int taille) {
    int impairs[taille], pairs[taille];
    int indexImpairs = 0, indexPairs = 0;

    // Séparer les éléments impairs et pairs
    for (int i = 0; i < taille; i++) {
        if (tab[i] % 2 != 0) {
            impairs[indexImpairs++] = tab[i];
        } else {
            pairs[indexPairs++] = tab[i];
        }
    }

    // Combiner les impairs suivis des pairs dans le tableau original
    for (int i = 0; i < indexImpairs; i++) {
        tab[i] = impairs[i];
    }
    for (int i = 0; i < indexPairs; i++) {
        tab[indexImpairs + i] = pairs[i];
    }
}

int main() {
    int taille;

    // Saisie de la taille du tableau
    cout << "Entrez la taille du tableau: ";
    cin >> taille;

    int tab[taille];

    // Saisie des éléments du tableau
    cout <<"Entrez "<< taille <<" entiers: "<< endl;
    for (int i = 0; i < taille; i++) {
        cin >> tab[i];
    }

    // Réorganiser le tableau de sorte que les impairs précèdent les 
    // pairs
    reordonnerImpairsPuisPairs(tab, taille);

    // Afficher le tableau réorganisé
    cout << "Tableau après réorganisation: ";
    for (int i = 0; i < taille; i++) {
        cout << tab[i] << " ";
    }
    cout << endl;

    return 0;
}

Sortie:

Entrez la taille du tableau: 5
Entrez 5 entiers: 
1
2
3
4
5
Tableau après réorganisation: 1 3 5 2 4

Explication:

La fonction reordonnerImpairsPuisPairs sépare les éléments impairs et pairs dans deux tableaux temporaires (impairs et pairs).

Ensuite, elle combine les éléments impairs suivis des éléments pairs dans le tableau original.

Le programme principal permet à l'utilisateur de saisir un tableau d'entiers, puis il réorganise les éléments pour que les impairs précèdent les pairs et affiche le tableau réorganisé.

#include <iostream>
#include <string>
using namespace std;

int main() {
    // Définir la longueur du tableau (initialement 0)
    // On veut des éléments de '0' à '5', donc longueur = 6
    int longueur = 6;  

    // Créer un tableau dynamique de chaînes de caractères
    string* tab = new string[longueur];

    // Remplir le tableau avec les valeurs de '0' à '5'
    for (int i = 0; i < longueur; i++) {
        // Convertir l'entier en chaîne de caractères
        tab[i] = to_string(i);  
    }

    // Afficher les éléments du tableau
    cout << "Éléments du tableau : ";
    for (int i = 0; i < longueur; i++) {
        cout << tab[i] << " ";
    }
    cout << endl;

    // Libérer la mémoire allouée dynamiquement
    delete[] tab;

    return 0;
}

Sortie:

Éléments du tableau : 0 1 2 3 4 5 

#include <iostream>
using namespace std;

bool verifier10SuiviDe20(int tab[], int taille) {
    // Parcourir le tableau pour trouver un 10
    for (int i = 0; i < taille; i++) {
        if (tab[i] == 10) {
            // Après avoir trouvé un 10, vérifier s'il y a un 20 plus 
            // tard
            for (int j = i + 1; j < taille; j++) {
                if (tab[j] == 20) {
                    // Si 20 trouvé après 10, retourner vrai
                    return true;  
                }
            }
        }
    }
    // Si aucune paire 10 suivi de 20 n'est trouvée
    return false;  
}

int main() {
    int taille;

    // Saisie de la taille du tableau
    cout << "Entrez la taille du tableau: ";
    cin >> taille;

    int tab[taille];

    // Saisie des éléments du tableau
    cout <<"Entrez "<< taille <<" entiers: "<< endl;
    for (int i = 0; i < taille; i++) {
        cin >> tab[i];
    }

    // Vérifier si le tableau contient un 10 suivi d'un 20
    if (verifier10SuiviDe20(tab, taille)) {
        cout <<"Il y a un 10 suivi d'un 20 quelque part dans le tableau."<< endl;
    } else {
        cout <<"Il n'y a pas de 10 suivi d'un 20 dans le tableau."<< endl;
    }

    return 0;
}

Sortie:

Entrez la taille du tableau: 5
Entrez 5 entiers: 
15
10
20
40
30
Il y a un 10 suivi d'un 20 quelque part dans le tableau.

Explication:

La fonction verifier10SuiviDe20 parcourt le tableau pour chercher un 10. Dès qu'un 10 est trouvé, une autre boucle interne vérifie s'il y a un 20 après ce 10.

Si un 10 suivi d'un 20 est trouvé, la fonction retourne true. Sinon, elle retourne false.

Le programme principal demande à l'utilisateur de saisir un tableau d'entiers et affiche s'il y a un 10 suivi d'un 20.

#include <iostream>
using namespace std;

bool verifier10AdjacentsOuSepares(int tab[], int taille) {
    for (int i = 0; i < taille - 1; i++) {
        // Vérifier si deux 10 sont adjacents
        if (tab[i] == 10 && tab[i + 1] == 10) {
            return true;
        }
        // Vérifier si deux 10 sont séparés par un seul élément
        if (i < taille - 2 && tab[i] == 10 && tab[i + 2] == 10) {
            return true;
        }
    }
    return false;
}

int main() {
    int taille;

    // Saisie de la taille du tableau
    cout << "Entrez la taille du tableau: ";
    cin >> taille;

    int tab[taille];

    // Saisie des éléments du tableau
    cout <<"Entrez "<< taille <<" entiers: "<< endl;
    for (int i = 0; i < taille; i++) {
        cin >> tab[i];
    }

    // Vérifier si le tableau contient deux 10 adjacents ou séparés 
    // par un seul élément
    if (verifier10AdjacentsOuSepares(tab, taille)) {
        cout << "Le tableau contient deux 10 adjacents ou séparés par un seul élément." << endl;
    } else {
        cout << "Le tableau ne contient pas de 10 adjacents ni séparés par un seul élément." << endl;
    }

    return 0;
}

Sortie:

Entrez la taille du tableau: 5
Entrez 5 entiers: 
10
20
10
30
10
Le tableau contient deux 10 adjacents ou séparés par un seul élément.

Explication:

La fonction verifier10AdjacentsOuSepares parcourt le tableau pour vérifier deux conditions :

• Si deux 10 sont adjacents (c'est-à-dire, l'élément actuel et l'élément suivant sont tous deux égaux à 10).
• Si deux 10 sont séparés par exactement un élément (c'est-à-dire, l'élément actuel est 10 et l'élément deux positions après est également 10).

Le programme principal demande à l'utilisateur de saisir un tableau d'entiers et utilise la fonction pour vérifier si le tableau satisfait l'une de ces deux conditions.