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

#include <iostream>

int main() {
    // Déclaration de la variable pour stocker le nombre
    int nombre;

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

    // Vérification si le nombre est pair ou impair
    if (nombre % 2 == 0) {
        // Le nombre est pair
        std::cout << "1" << std::endl; 
    } else {
        // Le nombre est impair
        std::cout << "0" << std::endl; 
    }

    return 0;
}

Sortie:

Entrez un nombre: 7
0

Explication:

Dans la condition if-else:

• La condition nombre % 2 == 0 vérifie si le nombre est divisible par 2, ce qui signifie qu'il est pair.
• Si le nombre est pair, le programme affiche 1.
• Si le nombre est impair, le programme affiche 0.

#include <iostream>

int main() {
    // Affichage des nombres divisibles par 2
    std::cout << "Nombres divisibles par 2: ";
    for (int i = 2; i <= 25; i += 2) { // Incrémentation de 2
        std::cout << i << " ";
    }

    // Affichage des nombres divisibles par 4
    std::cout << "\nNombres divisibles par 4: ";
    for (int i = 4; i <= 25; i += 4) { // Incrémentation de 4
        std::cout << i << " ";
    }

    // Affichage des nombres divisibles à la fois par 2 et par 4
    std::cout << "\nNombres divisibles par 2 et par 4: ";
    // Les nombres divisibles par 4 sont automatiquement divisibles 
    // par 2
    for (int i = 4; i <= 25; i += 4) { 
        std::cout << i << " ";
    }

    // Retour à la ligne à la fin
    std::cout << std::endl; 
    return 0;
}

Sortie:

Nombres divisibles par 2: 2 4 6 8 10 12 14 16 18 20 22 24 
Nombres divisibles par 4: 4 8 12 16 20 24 
Nombres divisibles par 2 et par 4: 4 8 12 16 20 24 

Explication:

Incrémentation intelligente:

• Pour les nombres divisibles par 2, la boucle commence à 2 et incrémente de 2 en 2. Cela évite de tester tous les nombres (impairs exclus directement).
• Pour les nombres divisibles par 4, la boucle commence à 4 et incrémente de 4 en 4.
• Pour les nombres divisibles par 2 et 4, il suffit de réutiliser la boucle divisibles par 4, car ces nombres sont automatiquement divisibles par 2.

#include <iostream>

int main() {
    // Déclaration de la variable pour stocker la limite supérieure
    int n, somme = 0;

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

    // Boucle pour additionner tous les nombres de 1 à n
    for (int i = 1; i <= n; i++) {
        somme += i; // Ajoute le nombre actuel à la somme
    }

    // Affichage de la somme totale
    std::cout <<"La somme de tous les nombres de 1 à "<< n <<" est: "<< somme << std::endl;

    return 0;
}

Sortie:

Entrez un nombre: 5
La somme de tous les nombres de 1 à 5 est: 15

Explication:

Dans la boucle for:

• La boucle commence à 1 et se poursuit jusqu'à n.
• À chaque itération, la variable somme est incrémentée par la valeur actuelle de i pour additionner tous les nombres de 1 à n.

#include <iostream>

bool verifierSomme(int a, int b, int c) {
    // Calcul de la somme de a et b, puis comparaison avec c
    return (a + b == c);
}

int main() {
    // Déclaration des variables pour stocker les trois entiers
    int n1, n2, n3;

    // Demande à l'utilisateur d'entrer les trois nombres
    std::cout << "Entrez le premier entier: ";
    std::cin >> n1;

    std::cout << "Entrez le deuxième entier: ";
    std::cin >> n2;

    std::cout << "Entrez le troisième entier: ";
    std::cin >> n3;

    // Vérification si la somme des deux premiers nombres est égale
    // au troisième
    if (verifierSomme(n1, n2, n3)) {
        std::cout <<"TRUE: La somme de "<< n1 <<" et "<< n2 <<" est égale à "<< n3 << std::endl;
    } else {
        std::cout <<"FALSE: La somme de "<< n1 <<" et "<< n2 <<" n'est pas égale à "<< n3 << std::endl;
    }

    return 0;
}

Sortie:

Entrez le premier entier: 1
Entrez le deuxième entier: 2
Entrez le troisième entier: 3
TRUE: La somme de 1 et 2 est égale à 3

Explication:

Dans la fonction verifierSomme(int a, int b, int c):

• Cette fonction prend trois entiers en paramètres.
• Elle calcule la somme de a et b, puis compare cette somme avec c. Si la somme est égale à c, la fonction renvoie true, sinon elle renvoie false.

#include <iostream>

bool verifierOrdre(int a, int b, int c) {
    // Vérifie si b est plus grand que a et si c est plus grand que b
    return (b > a && c > b);
}

int main() {
    // Déclaration des variables pour stocker les trois entiers
    int nombre1, nombre2, nombre3;

    // Demande à l'utilisateur d'entrer les trois nombres
    std::cout << "Entrez le premier entier: ";
    std::cin >> nombre1;

    std::cout << "Entrez le deuxième entier: ";
    std::cin >> nombre2;

    std::cout << "Entrez le troisième entier: ";
    std::cin >> nombre3;

    // Vérification de l'ordre des nombres
    if (verifierOrdre(nombre1, nombre2, nombre3)) {
        std::cout << "TRUE: Le deuxième nombre est plus grand que le premier et le troisième est plus grand que le deuxième." << std::endl;
    } else {
        std::cout << "FALSE: Les conditions ne sont pas remplies." << std::endl;
    }

    return 0;
}

Sortie:

Entrez le premier entier: 2
Entrez le deuxième entier: 5
Entrez le troisième entier: 8
TRUE: Le deuxième nombre est plus grand que le premier et le troisième est plus grand que le deuxième.

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        
        System.out.print("Saisir le premier nombre: ");
        int a = sc.nextInt();

        System.out.print("Saisir le deuxième nombre: ");
        int b = sc.nextInt();

        System.out.print("Saisir le troisième nombre: ");
        int c = sc.nextInt();

        System.out.print("Le résultat est: " + check(a, b, c));
    }

    // Fonction permettant de tester si deux nombres ont le même 
    // chiffre à l'extrême droite.
    public static boolean check(int x, int y, int z) {
        return (x % 10 == y % 10) || (x % 10 == z % 10) || (y % 10 == z % 10);
    }
}

Sortie:

Saisir le premier nombre: 2
Saisir le deuxième nombre: 12
Saisir le troisième nombre: 32
Le résultat est: true

Explication:

Dans la fonction verifierOrdre(int a, int b, int c):

• Cette fonction prend trois entiers comme paramètres.
• Elle vérifie si le deuxième nombre (b) est plus grand que le premier (a) et si le troisième nombre (c) est plus grand que le deuxième (b). Si les deux conditions sont vraies, la fonction renvoie true, sinon elle renvoie false.

#include <iostream>

int main() {
    // Déclaration de la variable pour stocker le nombre de secondes
    int totalSecondes;

    // Demande à l'utilisateur d'entrer le nombre de secondes
    std::cout << "Entrez le nombre de secondes: ";
    std::cin >> totalSecondes;

    // Calcul des heures, minutes et secondes
    // 1 heure = 3600 secondes
    int heures = totalSecondes / 3600; 
    // Reste de secondes après avoir extrait les heures, puis 
    // conversion en minutes
    int minutes = (totalSecondes % 3600) / 60; 
    // Reste de secondes après avoir extrait les minutes
    int secondes = totalSecondes % 60; 

    // Affichage du résultat
    std::cout << totalSecondes << " secondes équivalent à: "
              << heures << " heures, "
              << minutes << " minutes et "
              << secondes << " secondes." << std::endl;

    return 0;
}

Sortie:

Entrez le nombre de secondes: 3661
3661 secondes équivalent à: 1 heures, 1 minutes et 1 secondes.

Explication:

Calcul des heures, minutes et secondes:

• Les heures sont calculées en divisant le nombre total de secondes par 3600 (le nombre de secondes dans une heure).
• Les minutes sont obtenues en prenant le reste des secondes après avoir extrait les heures, puis en divisant par 60 (le nombre de secondes dans une minute).
• Les secondes restantes sont simplement le reste de la division du nombre total de secondes par 60.

#include <iostream>

int main() {
    // Déclaration d'un tableau pour stocker les sept nombres
    int nombres[7];

    // Demande à l'utilisateur d'entrer sept nombres
    std::cout << "Entrez sept nombres: " << std::endl;
    for (int i = 0; i < 7; ++i) {
        std::cout << "Nombre " << (i + 1) << ": ";
        std::cin >> nombres[i];
    }

    // Tri du tableau par ordre décroissant (méthode du tri par 
    // sélection)
    for (int i = 0; i < 7 - 1; ++i) {
        for (int j = i + 1; j < 7; ++j) {
            // Échange si le nombre actuel est plus petit que le 
            // nombre suivant
            if (nombres[i] < nombres[j]) {
                // Échange des éléments
                int temp = nombres[i];
                nombres[i] = nombres[j];
                nombres[j] = temp;
            }
        }
    }

    // Affichage des nombres triés
    std::cout << "Les nombres triés par ordre décroissant sont: ";
    for (int i = 0; i < 7; ++i) {
        std::cout << nombres[i] << " ";
    }
    std::cout << std::endl; // Retour à la ligne

    return 0;
}

Sortie:

Entrez sept nombres: 
Nombre 1: 5
Nombre 2: 1
Nombre 3: 2
Nombre 4: 9
Nombre 5: 4
Nombre 6: 0
Nombre 7: 3
Les nombres triés par ordre décroissant sont: 9 5 4 3 2 1 0 

Explication:

Tri du tableau :

• Un algorithme de tri par sélection est utilisé pour trier les nombres par ordre décroissant.
• Deux boucles for sont utilisées :
  • La boucle extérieure parcourt chaque élément du tableau.
  • La boucle intérieure compare l'élément actuel avec les éléments suivants.
  • Si l'élément actuel est plus petit que l'élément suivant, ils sont échangés.

#include <iostream>

using namespace std;

int main() {
    int anneeDebut, anneeFin;

    // Demande à l'utilisateur d'entrer les années de début et de fin
    cout << "Entrez l'année de début: ";
    cin >> anneeDebut;
    cout << "Entrez l'année de fin: ";
    cin >> anneeFin;

    cout <<"Années bissextiles entre "<< anneeDebut <<" et "<< anneeFin <<": ";

    // Drapeau pour vérifier si une année bissextile a été trouvée
    bool trouveBissextile = false; 

    for (int annee = anneeDebut; annee <= anneeFin; ++annee) {
        // Vérification si l'année est bissextile
        if ((annee % 4 == 0 && annee % 100 != 0) || (annee % 400 == 0)) {
            cout << annee << " "; // Affiche l'année bissextile
            trouveBissextile = true; // Met à jour le drapeau
        }
    }

    // Si aucune année bissextile n'a été trouvée, affiche un message 
    // approprié
    if (!trouveBissextile) {
        cout <<"Aucune année bissextile trouvée dans cette période."<< endl;
    } else {
        // Retour à la ligne après l'affichage des années
        cout << endl; 
    }

    return 0;
}

Sortie:

Entrez l'année de début: 2020
Entrez l'année de fin: 2025
Années bissextiles entre 2020 et 2025: 2020 2024

Explication:

Une année est considérée bissextile si elle est divisible par 4, mais pas par 100, sauf si elle est aussi divisible par 400.

La boucle 'for' parcourt chaque année entre anneeDebut et anneeFin. Puis une condition 'if' vérifie si l'année est bissextile en utilisant les règles de calcul.