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

#include <iostream>
using namespace std;

int main() {
    double a, b;

    // Entrer les deux variables
    cout << "Entrez la première variable: ";
    cin >> a;
    cout << "Entrez la deuxième variable: ";
    cin >> b;

    // Vérifier si les deux variables sont strictement comprises 
    // entre 0 et 1
    if (a > 0 && a < 1 && b > 0 && b < 1) {
        cout << "Les deux variables sont strictement comprises entre 0 et 1." << endl;
    } else {
        cout << "Les deux variables ne sont pas strictement comprises entre 0 et 1." << endl;
    }

    return 0;
}

Sortie:

Entrez la première variable: 0.5
Entrez la deuxième variable: 0.8
Les deux variables sont strictement comprises entre 0 et 1.

Explication:

Le programme demande à l'utilisateur d'entrer deux variables de type double (a et b).

La condition a > 0 && a < 1 && b > 0 && b < 1 vérifie que les deux variables sont strictement comprises entre 0 et 1 (excluant 0 et 1 eux-mêmes).

Si les deux variables satisfont la condition, un message est affiché indiquant que les deux variables sont strictement comprises entre 0 et 1.

Sinon, un message indique que ce n'est pas le cas.

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

// Fonction pour trouver les k plus petits éléments d'un tableau
void trouverKPlusPetits(int tab[], int taille, int k) {
    // Trier le tableau
    sort(tab, tab + taille);

    // Afficher les k plus petits éléments
    cout <<"Les "<< k <<" plus petits éléments sont: ";
    for (int i = 0; i < k; i++) {
        cout << tab[i] << " ";
    }
    cout << endl;
}

int main() {
    int tab[] = {7, 10, 4, 3, 20, 15};
    int taille = sizeof(tab) / sizeof(tab[0]);
    int k;

    // Entrer la valeur de k
    cout << "Entrez la valeur de k: ";
    cin >> k;

    // Vérifier si k est valide
    if (k > 0 && k <= taille) {
        trouverKPlusPetits(tab, taille, k);
    } else {
        cout <<"k doit être entre 1 et "<< taille << endl;
    }

    return 0;
}

Sortie:

Entrez la valeur de k: 3
Les 3 plus petits éléments sont: 3 4 7

Explication:

Nous utilisons la fonction sort() de la bibliothèque <algorithm> pour trier les éléments du tableau dans l'ordre croissant.

Après le tri, les k premiers éléments du tableau sont les plus petits, donc nous les affichons directement.

Le programme vérifie si k est valide (entre 1 et la taille du tableau).

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

// Fonction pour trouver le kème élément le plus petit et le kème élément le plus grand
void trouverKemeElement(int tab[], int taille, int k) {
    // Trier le tableau
    sort(tab, tab + taille);

    // Afficher le kème plus petit élément
    cout <<"Le "<< k <<"ème élément le plus petit est: "<< tab[k - 1] << endl;

    // Afficher le kème plus grand élément
    cout <<"Le "<< k <<"ème élément le plus grand est: "<< tab[taille - k] << endl;
}

int main() {
    int tab[] = {7, 10, 4, 3, 20, 15};
    int taille = sizeof(tab) / sizeof(tab[0]);
    int k;

    // Entrer la valeur de k
    cout << "Entrez la valeur de k: ";
    cin >> k;

    // Vérifier si k est valide
    if (k > 0 && k <= taille) {
        trouverKemeElement(tab, taille, k);
    } else {
        cout <<"k doit être entre 1 et "<< taille << endl;
    }

    return 0;
}

Sortie:

Entrez la valeur de k: 3
Le 3ème élément le plus petit est: 7
Le 3ème élément le plus grand est: 10

Explication:

La fonction sort() de la bibliothèque <algorithm> est utilisée pour trier les éléments du tableau dans l'ordre croissant.

Après le tri, le k-ème élément le plus petit se trouve à l'indice k-1 dans le tableau (car les indices commencent à 0 en C++).

Le k-ème élément le plus grand correspond à l'élément à l'indice taille - k après le tri.

Le programme vérifie si k est dans les limites valides, c'est-à-dire entre 1 et la taille du tableau.

#include <iostream>
using namespace std;

// Fonction pour calculer la moyenne d'un tableau
double calculerMoyenne(int tab[], int taille) {
    int somme = 0;

    // Calculer la somme des éléments du tableau
    for (int i = 0; i < taille; i++) {
        somme += tab[i];
    }

    // Calculer et retourner la moyenne
	// Conversion implicite (double)
    return (double)somme / taille;  
}

// Fonction pour afficher les nombres supérieurs à la moyenne
void afficherNombresSuperieursMoyenne(int tab[], int taille) {
    double moyenne = calculerMoyenne(tab, taille);

    cout <<"La moyenne est: "<< moyenne << endl;
    cout <<"Les nombres supérieurs à la moyenne sont:";

    // Parcourir le tableau pour afficher les éléments supérieurs à 
    // la moyenne
    for (int i = 0; i < taille; i++) {
        if (tab[i] > moyenne) {
            cout << tab[i] << " ";
        }
    }
    cout << endl;
}

int main() {
    int tableau[] = {1, 3, 5, 7, 9, 11, 13};
    int taille = sizeof(tableau) / sizeof(tableau[0]);

    // Afficher les nombres supérieurs à la moyenne
    afficherNombresSuperieursMoyenne(tableau, taille);

    return 0;
}

Sortie:

La moyenne est: 7
Les nombres supérieurs à la moyenne sont: 9 11 13

Explication:

La fonction calculerMoyenne parcourt le tableau et calcule la somme de ses éléments, puis divise cette somme par la taille du tableau pour obtenir la moyenne.

La fonction afficherNombresSuperieursMoyenne parcourt le tableau une seconde fois et affiche chaque nombre qui est strictement supérieur à la moyenne.

Pour éviter des erreurs de division entière, la somme est convertie en double lors du calcul de la moyenne.

#include <iostream>
using namespace std;

// Fonction pour diviser deux nombres en utilisant l'opérateur de soustraction
int division(int numerateur, int denominateur) {
    // Vérifier si le dénominateur est zéro
    if (denominateur == 0) {
        cout << "Erreur: Division par zéro." << endl;
        return 0; // Renvoie 0 en cas d'erreur
    }

    int quotient = 0;

    // Soustraire le dénominateur du numérateur jusqu'à ce qu'il soit 
    // inférieur au numérateur
    while (numerateur >= denominateur) {
        numerateur -= denominateur; // Soustraction
        quotient++; // Incrémenter le quotient
    }

    return quotient; // Retourner le quotient
}

int main() {
    int numerateur, denominateur;

    // Demander à l'utilisateur d'entrer les nombres
    cout << "Entrez le numérateur: ";
    cin >> numerateur;
    cout << "Entrez le dénominateur: ";
    cin >> denominateur;

    // Calculer et afficher le quotient
    int quotient = division(numerateur, denominateur);
    cout << "Le quotient est: " << quotient << endl;

    return 0;
}

Sortie:

Entrez le numérateur: 10
Entrez le dénominateur: 5
Le quotient est: 2

Explication:

Avant de procéder à la division, le programme vérifie si le dénominateur est égal à zéro. Si c'est le cas, un message d'erreur est affiché pour éviter la division par zéro.

Soustraction répétée: Une boucle while est utilisée pour soustraire le dénominateur du numérateur jusqu'à ce que le numérateur soit inférieur au dénominateur. Chaque fois que nous soustrayons, nous incrémentons le quotient.

Après avoir calculé le quotient, le programme l'affiche à l'utilisateur.

#include <iostream>
using namespace std;

// Fonction pour déplacer les nombres positifs à droite et les négatifs à gauche
void deplacerNombres(int tableau[], int taille) {
    int j = 0; // Index pour les négatifs

    // Parcourir le tableau et déplacer les éléments
    for (int i = 0; i < taille; i++) {
        if (tableau[i] < 0) {
            // Si l'élément est négatif, le déplacer vers le début
            swap(tableau[i], tableau[j]);
            j++;
        }
    }
}

int main() {
    int tableau[] = {3, -1, 2, -5, 4, -2, 6, -3};
    int taille = sizeof(tableau) / sizeof(tableau[0]);

    cout << "Tableau original: ";
    for (int i = 0; i < taille; i++) {
        cout << tableau[i] << " ";
    }
    cout << endl;

    // Appeler la fonction pour déplacer les nombres
    deplacerNombres(tableau, taille);

    cout << "Tableau après déplacement: ";
    for (int i = 0; i < taille; i++) {
        cout << tableau[i] << " ";
    }
    cout << endl;

    return 0;
}

Sortie:

Tableau original: 3 -1 2 -5 4 -2 6 -3 
Tableau après déplacement: -1 -5 -2 -3 4 2 6 3 

Explication:

La fonction parcourt le tableau d'origine.

Elle utilise une variable j pour suivre l'index où le prochain nombre négatif doit être placé.

Lorsque l'élément actuel est négatif, il est échangé avec l'élément à l'index j, puis j est incrémenté.

Le programme affiche d'abord le tableau original.

Ensuite, après avoir déplacé les éléments, il affiche le tableau modifié.

#include <iostream>
using namespace std;

// Fonction pour déplacer tous les zéros vers la droite
void deplacerZeros(int tableau[], int taille) {
    // Index pour suivre la position des non-zéros
    int j = 0; 

    // Parcourir le tableau
    for (int i = 0; i < taille; i++) {
        if (tableau[i] != 0) {
            // Si l'élément n'est pas zéro, le déplacer à la position 
            // j
            tableau[j] = tableau[i];
            j++;
        }
    }

    // Remplir le reste du tableau avec des zéros
    while (j < taille) {
        tableau[j] = 0;
        j++;
    }
}

int main() {
    int tableau[] = {0, 1, 0, 3, 12, 0, 5};
    int taille = sizeof(tableau) / sizeof(tableau[0]);

    cout << "Tableau original: ";
    for (int i = 0; i < taille; i++) {
        cout << tableau[i] << " ";
    }
    cout << endl;

    // Appeler la fonction pour déplacer les zéros
    deplacerZeros(tableau, taille);

    cout << "Tableau après déplacement des zéros: ";
    for (int i = 0; i < taille; i++) {
        cout << tableau[i] << " ";
    }
    cout << endl;

    return 0;
}

Sortie:

Tableau original: 0 1 0 3 12 0 5 
Tableau après déplacement des zéros: 1 3 12 5 0 0 0 

Explication:

La fonction deplacerZeros() parcourt le tableau et utilise une variable j pour suivre la position des éléments non nuls.

Chaque fois qu'un élément non nul est trouvé, il est placé à l'index j, et j est incrémenté.

Une fois que tous les éléments non nuls ont été déplacés, la fonction remplit le reste du tableau avec des zéros.

Le programme affiche d'abord le tableau original.

Ensuite, après le déplacement des zéros, il affiche le tableau modifié.

#include <iostream>
using namespace std;

// Fonction pour multiplier deux entiers sans utiliser l'opérateur de multiplication
int multiplier(int a, int b) {
    // Gérer les cas où b est négatif
    bool estNegatif = (b < 0);
    if (estNegatif) {
        b = -b; // Rendre b positif
    }

    int resultat = 0;

    // Ajouter a à lui-même b fois
    for (int i = 0; i < b; i++) {
        resultat += a;
    }

    // Si b était négatif, inverser le signe du résultat
    return estNegatif ? -resultat : resultat;
}

int main() {
    int a, b;

    // Demander à l'utilisateur d'entrer les nombres
    cout << "Entrez le premier entier (a): ";
    cin >> a;
    cout << "Entrez le deuxième entier (b): ";
    cin >> b;

    // Calculer et afficher le produit
    int res = multiplier(a, b);
    cout <<"Produit de "<< a <<" et "<< b <<" est: "<< res << endl;

    return 0;
}

Sortie:

Entrez le premier entier (a): 2
Entrez le deuxième entier (b): 3
Le produit de 2 et 3 est: 6

Explication:

Le programme demande à l'utilisateur d'entrer deux entiers, puis appelle la fonction multiplier pour calculer le produit.

La fonction prend deux entiers a et b.

Elle gère le cas où b est négatif en le rendant positif et en gardant une trace de son signe.

Ensuite, elle utilise une boucle pour ajouter a à lui-même b fois. Cela équivaut à la multiplication.

Si b était initialement négatif, le résultat est inversé pour obtenir la valeur correcte.

#include <iostream>
// Inclure la bibliothèque pour les chaînes
#include <string> 
using namespace std;

// Fonction pour tester si la première chaîne est contenue dans la seconde
bool contient(const string& str1, const string& str2) {
    // Utiliser la fonction find pour vérifier si str1 est dans str2
    return str2.find(str1) != string::npos;
}

int main() {
    string str1, str2;

    // Demander à l'utilisateur d'entrer les chaînes
    cout << "Entrez la première chaîne: ";
    // Utiliser getline pour permettre les espaces
    getline(cin, str1); 
    cout << "Entrez la deuxième chaîne: ";
    getline(cin, str2);

    // Vérifier si la deuxième chaîne contient la première
    if (contient(str1, str2)) {
        cout << "La deuxième chaîne contient la première." << endl;
    } else {
        cout << "La deuxième chaîne ne contient pas la première." << endl;
    }

    return 0;
}

Sortie:

Entrez la première chaîne: Hello
Entrez la deuxième chaîne: Hello World!
La deuxième chaîne contient la première.

Explication:

Le programme utilise getline(cin, str1) et getline(cin, str2) pour lire les chaînes entrées par l'utilisateur, ce qui permet de capturer les espaces.

La fonction contient() prend deux chaînes en paramètres (str1 et str2).

Elle utilise la méthode find() de la classe string, qui recherche str1 dans str2.

Si find() renvoie une position différente de string::npos, cela signifie que str1 est trouvée dans str2.

Le programme affiche un message indiquant si la deuxième chaîne contient ou non la première.