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

#include <iostream>
// Bibliothèque nécessaire pour manipuler les chaînes de caractères
#include <string> 

using namespace std;

int main() {
    string str;

    // Demander à l'utilisateur d'entrer une chaîne de caractères
    cout << "Entrez une chaîne de caractères: ";
    getline(cin, str); //Permet de lire toute la ligne de texte

    // Afficher la chaîne originale
    cout << "Chaîne originale: " << str << endl;

    // Inverser la chaîne
    string strInverse;
    for (int i = str.length() - 1; i >= 0; --i) {
        // Ajouter les caractères dans l'ordre inverse
        strInverse += str[i]; 
    }

    // Afficher la chaîne inversée
    cout << "Chaîne inversée: " << strInverse << endl;

    return 0;
}

Sortie:

Entrez une chaîne de caractères: Hello World!
Chaîne originale: Hello World!
Chaîne inversée: !dlroW olleH

Explication:

L'approche pour inverser une chaîne à l'aide d'une boucle for consiste à parcourir les caractères de la chaîne originale dans l'ordre inverse et à construire une nouvelle chaîne. La boucle for commencera à partir du dernier caractère de la chaîne entrée (str) et ajoutera chaque caractère à la nouvelle chaîne (strInverse).

Dans le programme ci-dessus, nous déclarons une variable (str) et l'initialisons avec la chaîne que nous devons inverser, c'est-à-dire « Hello World! ». Nous déclarons également une variable (strInverse) et lui assignons une chaîne vide. Ensuite, nous utilisons une boucle for pour parcourir les caractères de la chaîne d'entrée (str) dans l'ordre inverse. La boucle commence à partir de str.Length() - 1 (l'index du dernier caractère) et se poursuit jusqu'à ce que l'index atteigne zéro. À l'intérieur de la boucle, nous concaténons chaque caractère à la chaîne inversée à l'aide de l'opérateur +=. Enfin, nous affichons les chaînes originales et inversées sur la console.

#include <iostream>

using namespace std;

int main() {
    const int taille = 5; // Taille du tableau
    int tab[taille]; // Déclaration du tableau
    int max; // Variable pour stocker le plus grand entier

    // Demander à l'utilisateur d'entrer les éléments du tableau
    cout << "Entrez " << taille << " entiers : " << endl;
    for (int i = 0; i < taille; ++i) {
        cout << "Élément " << (i + 1) << ": ";
        cin >> tab[i]; // Saisie des éléments dans le tableau
    }

    // Initialiser max avec la première valeur du tableau
    max = tab[0];

    // Parcourir le tableau pour trouver le plus grand entier
    for (int i = 1; i < taille; ++i) {
        if (tab[i] > max) {
            // Met à jour max si un plus grand entier est trouvé
            max = tab[i]; 
        }
    }

    // Afficher le plus grand entier
    cout <<"Le plus grand entier dans le tableau est:"<< max << endl;

    return 0;
}

Sortie:

Entrez 5 entiers : 
Élément 1: 4
Élément 2: 3
Élément 3: 9
Élément 4: 1
Élément 5: 0
Le plus grand entier dans le tableau est: 9

Explication:
Entrée utilisateur:

• Une boucle for permet de demander à l'utilisateur d'entrer les éléments du tableau.
• Les valeurs saisies sont stockées dans le tableau.

Recherche du plus grand entier:

• max est initialisé avec la première valeur du tableau.
• Une autre boucle for parcourt les éléments restants du tableau. Si un élément est supérieur à max, max est mis à jour avec cette nouvelle valeur.

#include <iostream>

using namespace std;

int main() {
    char c;

    // Demander à l'utilisateur d'entrer un caractère
    cout << "Entrez un caractère : ";
    cin >> c;

    // La conversion implicite du caractère en int
    int ascii = c; 
	
    // Afficher la valeur ASCII du caractère
    cout <<"La valeur ASCII de '"<< c <<"' est: "<< ascii << endl;

    return 0;
}

Sortie:

Entrez un caractère : A
La valeur ASCII de 'A' est: 65

Explication:

Note: la variable 'c' se verra attribuer la valeur ASCII du caractère 'A' qui est 65 (conversion implicite du caractère en int). Si nous affectons directement une variable char à int, elle renverra la valeur ASCII d'un caractère donné.

#include <iostream>
// Bibliothèque nécessaire pour manipuler les fichiers
#include <fstream> 

using namespace std;

int main() {
    string nomFichier;

    // Demander à l'utilisateur d'entrer le nom du fichier
    cout << "Entrez le nom du fichier : ";
    cin >> nomFichier;

    // Ouvrir le fichier en mode binaire
    ifstream fichier(nomFichier, ios::binary);

    // Vérifier si le fichier est ouvert
    if (!fichier) {
        cerr << "Erreur: Impossible d'ouvrir le fichier "<< endl;
        // Retourne une erreur si le fichier ne peut pas être ouvert
        return 1; 
    }

    // Se déplacer à la fin du fichier pour obtenir la taille
    fichier.seekg(0, ios::end);
    // Obtenir la position actuelle (taille du fichier)
    streampos taille = fichier.tellg(); 

    // Afficher la taille du fichier
    cout << "La taille du fichier '"<< nomFichier <<"' est: "<< taille << " octets." << endl;

    // Fermer le fichier
    fichier.close();

    return 0;
}

Sortie:

Entrez le nom du fichier: test.txt
La taille du fichier test.txt est 78 octets.

Explication:

• #include <iostream>: Cette bibliothèque permet d'utiliser les entrées et sorties standard, comme std::cout et std::cin.
• #include <fstream>: Cette bibliothèque est nécessaire pour manipuler les fichiers, permettant d'ouvrir, lire et écrire des fichiers.
• std::string nomFichier;: Déclare une variable de type chaîne pour stocker le nom du fichier entré par l'utilisateur.
• std::cin >> nomFichier;: Demande à l'utilisateur d'entrer le nom du fichier, qui est ensuite stocké dans nomFichier.
• std::ifstream fichier(nomFichier, std::ios::binary);: Ouvre le fichier en mode binaire pour éviter les modifications accidentelles de son contenu.
• if (!fichier): Vérifie si le fichier a été ouvert avec succès. Si l'ouverture échoue, un message d'erreur est affiché et le programme se termine.
• fichier.seekg(0, std::ios::end);: Se déplace à la fin du fichier pour préparer la lecture de sa taille.
• std::streampos taille = fichier.tellg();: Renvoie la position actuelle dans le fichier, qui correspond à la taille du fichier en octets.
• std::cout << "La taille du fichier ...": Affiche la taille du fichier à l'utilisateur.
• fichier.close();: Ferme le fichier après l'opération.

#include <iostream>
// Bibliothèque nécessaire pour manipuler le temps
#include <ctime> 

using namespace std;

int main() {
    // Récupère l'heure actuelle
    time_t now = time(0); 
    // Affiche l'heure
    cout <<"L'heure actuelle est: "<< ctime(&now); 

    return 0;
}

Sortie:

L'heure actuelle est: Tue Oct 8 22:04:39 2025

Explication:

std::time(0): Récupère l'heure actuelle en secondes depuis l'époque (1er janvier 1970).

std::ctime(&now): Convertit le temps en une chaîne lisible et l'affiche.

#include <iostream>
// Bibliothèque nécessaire pour manipuler le temps
#include <ctime> 
// Bibliothèque pour formater la sortie
#include <iomanip> 

using namespace std;

int main() {
    // Récupère l'heure actuelle
    time_t now = time(0);
    // Convertit en heure locale	
    tm* heureLocale = localtime(&now); 

    // Afficher la date et l'heure au format "yyyy/MM/dd HH:mm:ss"
    cout << put_time(heureLocale, "%Y/%m/%d %H:%M:%S") << endl;

    return 0;
}

Sortie:

2025/04/12 09:40:44

Explication:

• Bibliothèque #include <ctime> : Utilisée pour récupérer et manipuler l'heure.
• Bibliothèque #include <iomanip> : Nécessaire pour utiliser la fonction std::put_time, qui permet de formater la date et l'heure.
• std::time(0) : Récupère l'heure actuelle du système en secondes depuis l'époque (1er janvier 1970).
• std::localtime(&maintenant) : Convertit les secondes en heure locale.
• std::put_time(heureLocale, "%Y/%m/%d %H:%M:%S") : Formate la date et l'heure selon le format yyyy/MM/dd HH:mm:ss.

#include <iostream>

int calculerPGCD(int x, int y) {
    // Algorithme d'Euclide pour calculer le PGCD
    while (y != 0) {
        int reste = x % y; // Calcul du reste
        x = y;             // Remplacement de x par y
        y = reste;         // Remplacement de y par le reste
    }
    return x; // x contient maintenant le PGCD
}

int main() {
    int x, y;

    // Demander à l'utilisateur d'entrer deux nombres
    std::cout << "Entrez deux nombres entiers: ";
    std::cin >> x >> y;

    // Calculer et afficher le PGCD
    std::cout <<"Le PGCD de "<< x <<" et "<< y <<" est : "<< calculerPGCD(x, y) << std::endl;

    return 0;
}

Sortie:

Entrez deux nombres entiers : 36 24
Le PGCD de 36 et 24 est : 12

Explication:

Fonction calculerPGCD: Utilise l'algorithme d'Euclide pour calculer le PGCD.

Algorithme d'Euclide: Si y est différent de zéro, on calcule le reste de la division de x par y et on remplace x par y et y par le reste. On répète cette opération jusqu'à ce que y soit égal à zéro. Le PGCD est alors la dernière valeur de x.

#include <iostream>

using namespace std;

bool estPremier(int n) {
    // Les nombres inférieurs à 2 ne sont pas premiers
    if (n < 2) {
        return false;
    }
    
    // Vérifie si n est divisible par un nombre entre 2 et la racine 
    // carrée de n
    for (int i = 2; i * i <= n; i++) {
        if (n % i == 0) {
            // n est divisible par i, donc n n'est pas premier
            return false; 
        }
    }
    
    // Si aucune division n'est trouvée, n est premier
    return true; 
}

int main() {
    int n;

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

    // Vérifier si le nombre est premier et afficher le résultat
    if (estPremier(n)) {
        cout << n <<" est un nombre premier."<< endl;
    } else {
        cout << n <<" n'est pas un nombre premier."<< endl;
    }

    return 0;
}

Sortie:

Entrez un nombre entier: 29
29 est un nombre premier.

Explication:

Dans le programme ci-dessus, la fonction estPremier(): Cette fonction vérifie si un nombre entier n est premier.

• Si n est inférieur à 2, il n'est pas premier (par définition).
• La boucle for vérifie si n est divisible par un nombre entre 2 et la racine carrée de n. Si une telle division existe (remainder n % i == 0), alors n n'est pas premier.
• Si aucune division n'est trouvée, le nombre est considéré comme premier.

#include <iostream>
#include <string>

bool estPalindrome(const std::string& chaine) {
    int debut = 0;
    int fin = chaine.length() - 1;

    // Comparer les caractères du début et de la fin, en ignorant la 
    // casse
    while (debut < fin) {
        if (tolower(chaine[debut]) != tolower(chaine[fin])) {
            // Si les caractères ne correspondent pas, ce n'est pas 
            // un palindrome
            return false; 
        }
        debut++;
        fin--;
    }
    // Si tous les caractères correspondent, c'est un palindrome
    return true; 
}

using namespace std;

int main() {
    string str;

    // Demander à l'utilisateur d'entrer une chaîne
    cout << "Entrez une chaîne de caractères: ";
    // getline permet de lire une chaîne avec des espaces
    getline(cin, str); 

    // Vérifier si la chaîne est un palindrome et afficher le 
    // résultat
    if (estPalindrome(str)) {
        cout <<"\""<< str <<"\" est un palindrome."<< endl;
    } else {
        cout <<"\""<< str <<"\" n'est pas un palindrome."<< endl;
    }

    return 0;
}

Sortie:

Entrez une chaîne de caractères: madam
"madam" est un palindrome.

Explication:

Dans le programme ci-dessus, la fonction estPalindrome():

• Utilise deux indices, debut et fin, pour parcourir la chaîne de caractères du début à la fin.
• Compare les caractères correspondants (de gauche à droite et de droite à gauche) tout en ignorant la casse (en utilisant tolower() pour convertir les lettres en minuscules).
• Si une différence est trouvée, la fonction retourne false, indiquant que la chaîne n'est pas un palindrome.
• Si aucun écart n'est trouvé, elle retourne true, indiquant que la chaîne est un palindrome.