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

#include <iostream>

int main() {
    // Boucle pour afficher les nombres pairs de 1 à 10
    for (int i = 1; i <= 10; i++) {
        // Vérifie si le nombre est pair
        if (i % 2 == 0) { 
            std::cout << i << " ";
        }
    }

    return 0;
}

Sortie:

2 4 6 8 10

Explication:

Boucle for: La boucle commence à 1 et s'incrémente jusqu'à 10.

• La condition i % 2 == 0 vérifie si le nombre est divisible par 2 (donc pair).
• Si la condition est vraie, le nombre est affiché.

#include <iostream>
using namespace std;

bool testElementCinq(int tab[], int size) {
    // Vérifier si la taille du tableau est supérieure à 0 pour 
    // éviter les erreurs
    if (size > 0) {
        // Vérifier si le premier ou le dernier élément est égal à 5
        if (tab[0] == 5 || tab[size - 1] == 5) {
            // 5 est soit le premier soit le dernier élément
            return true; 
        }
    }
    // 5 n'est pas le premier ni le dernier élément
    return false; 
}

int main() {
    // Initialiser le tableau avec des valeurs prédéfinies
    int tab[] = {5, 10, 15, 20, 25};
    // Calculer la taille du tableau
    int size = sizeof(tab) / sizeof(tab[0]);  

    // Afficher le tableau
    cout << "Le tableau est: ";
    for (int i = 0; i < size; i++) {
        cout << tab[i] << " ";
    }
    cout << endl;

    // Tester si 5 apparaît comme premier ou dernier élément
    if (testElementCinq(tab, size)) {
        cout <<"5 apparaît comme premier ou dernier élément du tableau."<< endl;
    } else {
        cout <<"5 n'apparaît pas comme premier ou dernier élément du tableau."<< endl;
    }

    return 0;
}

Sortie:

Le tableau est: 5 10 15 20 25 
5 apparaît comme premier ou dernier élément du tableau.

Explication:

Le tableau tab est initialisé avec des valeurs prédéfinies {5, 10, 15, 20, 25}. La taille du tableau est calculée en divisant la taille totale du tableau par la taille d'un élément (sizeof(tab) / sizeof(tab[0])).

Le programme utilise la fonction testElementCinq pour vérifier si le premier ou le dernier élément est égal à 5. Le programme affiche un message indiquant si 5 apparaît en premier ou dernier élément.

#include <iostream>
using namespace std;

bool testElem(int tab[], int size) {
    // Vérifier si la taille du tableau est suffisante (au moins 1 
    // élément)
    if (size > 0) {
        // Comparer le premier et le dernier élément
        return tab[0] == tab[size - 1];
    }
    return false; // Retourner false si le tableau est vide
}

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

    // Afficher le tableau
    cout << "Le tableau est: ";
    for (int i = 0; i < size; i++) {
        cout << tab[i] << " ";
    }
    cout << endl;

    // Tester si le premier et le dernier élément sont identiques
    if (testElem(tab, size)) {
        cout <<"Le premier et le dernier élément du tableau sont identiques."<< endl;
    } else {
        cout <<"Le premier et le dernier élément du tableau sont différents."<< endl;
    }

    return 0;
}

Sortie:

Le tableau est: 10 20 30 40 10 
Le premier et le dernier élément du tableau sont identiques.

Explication:

Le tableau tab[] est initialisé avec des valeurs prédéfinies {10, 20, 30, 40, 10}. La taille du tableau est calculée en divisant la taille totale du tableau par la taille d'un élément (sizeof(tab) / sizeof(tab[0])). La fonction testElem() compare le premier élément (tab[0]) avec le dernier élément (tab[size - 1]). Enfin le programme affiche un message indiquant si le premier et le dernier élément sont identiques ou différents.

#include <iostream>
using namespace std;

bool testDeuxTableaux(int tab1[], int size1, int tab2[], int size2) {
    // Vérifier si les deux tableaux ont au moins un élément
    if (size1 > 0 && size2 > 0) {
        // Comparer le premier élément des deux tableaux et le 
        // dernier élément des deux tableaux
        if (tab1[0] == tab2[0] && tab1[size1 - 1] == tab2[size2 - 1]) {
            return true;
        }
    }
    return false;
}

int main() {
    // Initialiser les deux tableaux d'entiers
    int tab1[] = {5, 20, 30, 40, 10};  // Premier tableau
    int tab2[] = {5, 50, 60, 70, 10};  // Deuxième tableau

    // Calculer la taille des deux tableaux
    int size1 = sizeof(tab1) / sizeof(tab1[0]);
    int size2 = sizeof(tab2) / sizeof(tab2[0]);

    // Afficher les deux tableaux
    cout << "Le premier tableau est: ";
    for (int i = 0; i < size1; i++) {
        cout << tab1[i] << " ";
    }
    cout << endl;

    cout << "Le deuxième tableau est: ";
    for (int i = 0; i < size2; i++) {
        cout << tab2[i] << " ";
    }
    cout << endl;

    // Tester si le premier et le dernier élément des deux tableaux 
    // sont identiques
    if (testDeuxTableaux(tab1, size1, tab2, size2)) {
        cout <<"Le premier et le dernier élément des deux tableaux sont identiques."<< endl;
    } else {
        cout <<"Le premier et le dernier élément des deux tableaux sont différents."<< endl;
    }

    return 0;
}

Sortie:

Le premier tableau est: 5 20 30 40 10 
Le deuxième tableau est: 5 50 60 70 10 
Le premier et le dernier élément des deux tableaux sont identiques.

Explication:

Deux tableaux d'entiers sont initialisés dans le programme: tab1[] et tab2[]. La taille de chaque tableau est calculée en divisant la taille totale du tableau par la taille d'un élément (sizeof(tab1) / sizeof(tab1[0]) et sizeof(tab2) / sizeof(tab2[0])).

La fonction testDeuxTableaux compare le premier élément des deux tableaux (tab1[0] et tab2[0]) et le dernier élément des deux tableaux (tab1[size1 - 1] et tab2[size2 - 1]). Si le premier et le dernier élément des deux tableaux sont identiques, le programme affiche un message positif, sinon un message négatif.

#include <iostream>
using namespace std;

int* createArray(int tab1[], int tab2[]) {
    // Créer un nouveau tableau de longueur 2
    static int result[2];
    
    // Mettre le premier élément du premier tableau dans la première 
    // position
    result[0] = tab1[0];
    
    // Mettre le dernier élément du second tableau dans la deuxième 
    // position
    result[1] = tab2[2];
    
    return result; // Retourner le tableau créé
}

int main() {
    // Initialiser les deux tableaux avec 3 éléments chacun
    int tab1[] = {1, 2, 3};  // Premier tableau
    int tab2[] = {4, 5, 6};  // Deuxième tableau
    
    // Créer le tableau résultant
    int* newArray = createArray(tab1, tab2);

    // Afficher le tableau résultant
    cout << "Le tableau créé est : [";
    for (int i = 0; i < 2; i++) {
        cout << newArray[i];
        if (i != 1) {
            cout << ", ";
        }
    }
    cout << "]" << endl;

    return 0;
}

Sortie:

Le tableau créé est: [1, 6]

Explication:

Dans la fonction createArray():

• La fonction prend deux tableaux d'entiers de trois éléments chacun en paramètres.
• Elle crée un nouveau tableau result[2] qui contient:
• Le premier élément du premier tableau (tab1[0]).
• Le dernier élément du second tableau (tab2[2]).
• Le tableau result est retourné par la fonction.

#include <iostream>
using namespace std;

bool contient4ou5(int tab[]) {
    // Vérification si le tableau contient 4 ou 5
    return (tab[0] == 4 || tab[1] == 4 || tab[0] == 5 || tab[1] == 5);
}

int main() {
    int tab[2];

    // Saisie des éléments du tableau
    cout << "Entrez deux entiers pour remplir le tableau: " << endl;
    cin >> tab[0] >> tab[1];

    // Test si le tableau contient 4 ou 5
    if (contient4ou5(tab)) {
        cout <<"Le tableau contient un 4 ou un 5."<< endl;
    } else {
        cout <<"Le tableau ne contient ni 4 ni 5."<< endl;
    }

    return 0;
}

Sortie:

Entrez deux entiers pour remplir le tableau: 
4
5
Le tableau contient un 4 ou un 5.

Explication:

La fonction contient4ou5 prend un tableau d'entiers et retourne true si l'un des éléments est égal à 4 ou 5.

Le programme principal demande à l'utilisateur de remplir un tableau de deux entiers et affiche si ce tableau contient un 4 ou un 5.

#include <iostream>
using namespace std;

void rotationGauche(int tab[]) {
    // Stocker le premier élément
    int temp = tab[0];
    
    // Déplacer les éléments restants
    tab[0] = tab[1];
    tab[1] = tab[2];
    
    // Remettre le premier élément à la fin
    tab[2] = temp;
}

int main() {
    int tab[3];

    // Saisie des éléments du tableau
    cout <<"Entrez trois entiers pour remplir le tableau: " << endl;
    cin >> tab[0] >> tab[1] >> tab[2];

    // Afficher le tableau avant la rotation
    cout << "Tableau avant rotation: ";
    for (int i = 0; i < 3; i++) {
        cout << tab[i] << " ";
    }
    cout << endl;

    // Rotation vers la gauche
    rotationGauche(tab);

    // Afficher le tableau après la rotation
    cout <<"Tableau après rotation vers la gauche: ";
    for (int i = 0; i < 3; i++) {
        cout << tab[i] << " ";
    }
    cout << endl;

    return 0;
}

Sortie:

Entrez trois entiers pour remplir le tableau: 
1
2
3
Tableau avant rotation: 1 2 3 
Tableau après rotation vers la gauche: 2 3 1

Explication:

La fonction rotationGauche fait pivoter les éléments d'un tableau de 3 positions vers la gauche.

Elle stocke temporairement le premier élément, puis décale les deux autres éléments d'une position vers la gauche, et enfin met le premier élément à la dernière position du tableau.

Le programme principal permet à l'utilisateur de saisir trois entiers, affiche le tableau avant et après la rotation.

#include <iostream>
using namespace std;

int plusGrandeValeur(int arr[]) {
    // Comparer le premier et le dernier élément du tableau
    return (arr[0] > arr[2]) ? arr[0] : arr[2];
}

int main() {
    int tableau[3];

    // Saisie des éléments du tableau
    cout << "Entrez trois entiers pour remplir le tableau: " << endl;
    cin >> tableau[0] >> tableau[1] >> tableau[2];

    // Afficher le tableau
    cout << "Tableau: ";
    for (int i = 0; i < 3; i++) {
        cout << tableau[i] << " ";
    }
    cout << endl;

    // Trouver et afficher la plus grande valeur entre le premier et 
    // le dernier élément
    int maxValeur = plusGrandeValeur(tableau);
    cout << "La plus grande valeur entre le premier et le dernier élément est: " << maxValeur << endl;

    return 0;
}

Sortie:

Entrez trois entiers pour remplir le tableau: 
1
9
4
Tableau: 1 9 4 
La plus grande valeur entre le premier et le dernier élément est: 4

Explication:

La fonction plusGrandeValeur() compare le premier élément (tab[0]) et le dernier élément (tab[2]) du tableau, et retourne la plus grande des deux.

Le programme principal permet à l'utilisateur de saisir trois entiers, affiche le tableau, puis affiche la plus grande valeur entre le premier et le dernier élément.

#include <iostream>
using namespace std;

void echangerPremierDernier(int original[], int modifie[]) {
    // Copier le tableau original dans le tableau modifié
    for (int i = 0; i < 3; i++) {
        modifie[i] = original[i];
    }

    // Échanger le premier et le dernier élément
    int temp = modifie[0];
    modifie[0] = modifie[2];
    modifie[2] = temp;
}

int main() {
    int tab[3], tabModifie[3];

    // Saisie des éléments du tableau original
    cout <<"Entrez trois entiers pour remplir le tableau: " << endl;
    cin >> tab[0] >> tab[1] >> tab[2];

    // Afficher le tableau original
    cout << "Tableau original: ";
    for (int i = 0; i < 3; i++) {
        cout << tab[i] << " ";
    }
    cout << endl;

    // Échanger le premier et le dernier élément
    echangerPremierDernier(tab, tabModifie);

    // Afficher le tableau modifié
    cout <<"Tableau après échange du premier et dernier élément: ";
    for (int i = 0; i < 3; i++) {
        cout << tabModifie[i] << " ";
    }
    cout << endl;

    return 0;
}

Sortie:

Entrez trois entiers pour remplir le tableau: 
1
2
3
Tableau original: 1 2 3 
Tableau après échange du premier et dernier élément: 3 2 1 

Explication:

La fonction echangerPremierDernier() copie le tableau original dans un nouveau tableau modifie et échange le premier et le dernier élément du tableau.

Le programme principal demande à l'utilisateur de saisir trois entiers, affiche le tableau original, puis crée et affiche un tableau modifié où le premier et le dernier élément sont échangés.