Devoir d’Algo et break; }

using namespace std; }

Programmat C++ return 0; Je m'excuse pour la
14/01/2022 void calc(int nums[], int } confusion. Permettez-moi
count) de clarifier l'utilisation de
#include<iostream> { Exercice 3 any_of et de la lambda
using namespace std; int result = 0; function dans ce contexte.
for (int i = 0; i < count; i+ Écrire un programme C++ La fonction any_of est un
int main(){ +) qui demande à l'utilisateur algorithme de la
int i=1, j; { de saisir une chaîne de bibliothèque standard C++
while (i <=5){ result += nums[i]; caractères alphabétiques qui vérifie si au moins un
j=i } et d'au moins dix lettres. élément dans une plage
%3; Le programme force (définie par les itérateurs
cout << "Result Is : " << l'utilisateur de continuer à begin et end) satisfait une
switch (j){ result << "\n"; refaire la saisie si la chaine condition donnée. Dans ce
ne respecte pas les deux cas, la condition est
case 0: cout<<+ } conditions. Votre définie par la lambda
+j*3 << endl; programme affiche function [](char c)
int main() ensuite le nombre de { return !isalpha(c); }, qui
{ caractères majuscules et renvoie true si le caractère
break; int arrayOfNumbers[] = minuscules de la chaine. c n'est pas alphabétique.
{10, 20, 30, 40, 100}; #include <iostream>
case 1: int numsSize = #include <cctype> signifie "Y a-t-il au
cout<<(i+j++)%2 << endl; sizeof(arrayOfNumbers); moins un caractère dans
calc(arrayOfNumbers, using namespace std; la chaîne qui n'est pas
numsSize); alphabétique ?". Si la
case 2: cout<<(i+j) % 4 <<
return 0; int main() { réponse est true, cela
endl;
} string chaine; signifie que la chaîne
}
const int longueurMin = contient au moins un
i++;
10; caractère non
Exercice 2 alphabétique, et la
}
Qu’affiche le programme do { boucle do-
return 0;
cout << "Veuillez while continue de
}
#include <iostream> saisir une chaine d'au demander à l'utilisateur
using namespace std; moins dix lettres : "; de saisir une nouvelle
0
getline(cin, chaine); chaîne jusqu'à ce que la
3
int main() { condition soit fausse
0
int i = 1, j; } while ([Link]() (c'est-à-dire que tous les
3
while (i <= 5) { < longueurMin || caractères sont
1
j = i % 3; any_of([Link](), alphabétiques et que la
2
switch (j) { [Link](), [](char c) longueur de la chaîne est
3
case 0 : cout << ++j { return !isalpha(c); })); d'au moins dix lettres).
* 3 << endl; break; En résumé, any_of est
Calculatrice
case 1 : cout << // Initialiser les utilisé ici pour vérifier si
(i+j++)%2 << endl; compteurs de majuscules au moins un caractère
#include<iostream>
case 2 : cout << et de minuscules dans la chaîne ne satisfait
using namespace std;
(i+j) % 4 << endl; int majuscules = 0, pas la condition définie
} minuscules = 0; par la lambda function. Si
int main(){
i++; tel est le cas, l'utilisateur
int i, j; char op;
} // Parcourir chaque est invité à saisir une
cout <<
return 0; caractère de la chaîne nouvelle chaîne. J'espère
"entr..."; cin >> i >> j;cin
} for (char caractere : que cela clarifie
>> op;
chaine) { l'utilisation de cette partie
switch (op ) {
#include <iostream> if (isupper(caractere)) du code.
case
using namespace std; { // Parcourir chaque
'+' : cout << i+j;break;
majuscules++; caractère de la chaîne
case
int main() { } else if for (int i=0; i <
'-' : if (i>j) cout << i-j; else
int i = 3, j; (islower(caractere)) { [Link](); i++ ){
cout << j-i; break;
j = i % 3; minuscules++; if (isupper(chaine[i]))
case
switch (j) { } {
'*' : cout << i*j;break;
case 0 : } majuscules++;
case
cout << ++j * 3 << } else if
'/' : if (j !=0) cout <<
endl; // Afficher les résultats (islower(chaine[i])) {
i/j;break;
break; cout << "Nombre de minuscules++;
}
case 1 : majuscules : " << }
cout << (i+j++) % 2 majuscules << endl; }
return 0;
<< endl; cout << "Nombre de C’est la méthode vu en
}
break; minuscules : " << classe mais les deux
fonction
case 2 : minuscules << endl; s’exécutent correctement.
addition des nombres
cout << (i+j) % 4 <<
endl; return 0;
#include <iostream>
 un entier n et qui affiche // Si le tableau est vide, const int size = 5;
Exercice 4 le triangle de Pascal retourner une valeur int myArray[size] = {5, 2,
Soit U de n la suite d'ordre n. spéciale (par exemple 8, 1, 9};
définie comme suit, U INT_MAX)
de 0 égale racine carrée #include <iostream> if (size == 0) { // Appeler la fonction
de 2, U de 1 égale 1, U using namespace std; return INT_MAX; pour calculer la somme
} des éléments du tableau
de n égale 2 * U de n - 1
// Fonction pour calculer int sum =
+ U de n - 2 pour toute
le coefficient binomial C(n, // Initialiser la variable calculateSum(myArray,
n> 1. Donner le k) de minimum avec la size);
prototype de la fonction int binomialCoefficient(int première valeur du
U(n) qui retourne Un n, int k) { tableau cout << "La somme des
Voici le prototype de la if (k == 0 || k == n) { int minVal = T[0]; éléments du tableau est :
fonction U en C++ qui return 1; " << sum << endl;
calcule U_n selon la } else { // Parcourir le tableau
définition donnée : return pour trouver le minimum return 0;
#include <cmath> binomialCoefficient(n - 1, for (int i = 1; i < size; i++) }
k - 1) + { Écrire en c++ une fonction
double U(int n); binomialCoefficient(n - 1, if (T[i] < minVal) { qui prend comme
Cette fonction peut k); minVal = T[i]; paramètre un tableau T
ensuite être définie et } } d’entiers de 6 éléments. La
} } fonction retourne la valeur
implémentée comme
minimale et maximales
suit :
// Fonction pour afficher return minVal; qui peuvent être calculés
#include <cmath>
le triangle de Pascal } en additionnant
d'ordre n exactement 5 des six
double U(int n) {
void int main() { entiers.
if (n == 0) {
printPascalTriangle(int n) { const int size = 5;
return sqrt(2.0); //
for (int i = 0; i < n; i++) { int myArray[size] = {5, 2,
Racine carrée de 2 #include <iostream>
// Affiche les 8, 1, 9};
} else if (n == 1) { #include <algorithm> //
coefficients binomiaux de
return 1.0; Inclure la bibliothèque
la ligne i // Appeler la fonction
} else { pour utiliser std::sort
for (int j = 0; j <= i; j+ pour trouver le minimum
return 2 * U(n - 1) +
+) { dans le tableau
U(n - 2); using namespace std;
cout << int minimum =
}
binomialCoefficient(i, j) << findMin(myArray, size);
} // Fonction pour trier le
" ";
} cout << "Le minimum tableau par ordre
pour obtenir la valeur de ` dans le tableau est : " << croissant en utilisant le tri
cout << endl; minimum << endl; à bulles
} void bubbleSort(int arr[],
U_n pour un } return 0; int size) {
certain n. Par exemple : } for (int i = 0; i < size - 1;
#include <iostream> int main() { i++) {
int n; La somme for (int j = 0; j < size - i
int main() { cout << "Entrez l'ordre - 1; j++) {
int n; du triangle de Pascal : "; #include <iostream> if (arr[j] > arr[j + 1])
std::cout << "Entrez la cin >> n; {
valeur de n : "; using namespace std; // Échanger les
std::cin >> n; printPascalTriangle(n); éléments s'ils sont dans le
// Fonction pour calculer mauvais ordre
double result = U(n); return 0; la somme des éléments int temp = arr[j];
} d'un tableau arr[j] = arr[j + 1];
std::cout << "U(" << n Contrôlé de compétences int calculateSum(const int arr[j + 1] = temp;
<< ") = " << result << Exercice 2 T[], int size) { }
std::endl; Écrire la fonction Min qui // Initialiser la variable }
prend comme paramètre de somme à zéro }
return 0; un tableau T d’entiers et int sum = 0; }
} retourne le minimum de T.
#include <iostream> // Parcourir le tableau // Fonction pour calculer
#include <climits> // et ajouter chaque élément la valeur minimale et
Cette fonction récursive maximale en additionnant
calcule la valeur de U_n Inclure la bibliothèque à la somme
pour utiliser INT_MAX for (int i = 0; i < size; i++) exactement 5 des six
selon la définition donnée
{ entiers
pour n supérieur à 1. Vous
pouvez appeler cette using namespace std; sum += T[i]; void
fonction dans votre } findMinMaxSum(const int
programme principal // Fonction pour trouver T[], int size) {
le minimum dans un return sum; // Vérifier si la taille du
Exercice 5 tableau } tableau est correcte
Écrire une fonction qui int findMin(const int T[], if (size != 6) {
prend comme paramètre int size) { int main() {
 cout << "Le tableau } int S = calculateSum(t, cout << "U(1) = " <<
doit avoir exactement 6 n); U(1) << endl;
éléments." << endl; Autre méthode qui int mini = findMin(t, n); cout << "U(2) = " <<
return; regroupe toutes les int maxi = findMax(t, n); U(2) << endl;
} fonctions cout << "U(3) = " <<
int valmini = S - maxi; U(3) << endl;
// Copier le tableau #include <iostream> int valmaxi = S - mini;
dans un tableau return 0;
temporaire using namespace std; // Vous pouvez faire }
// int tempArray[6]; quelque chose avec Exercice 2
// copy(T, T + size, // Fonction pour trouver valmini et valmaxi ici
tempArray); le minimum dans un // Pour l'instant, je vais Écrire une fonction qui
int tempArray[6]; tableau simplement les afficher prend comme paramêtre
for(int i = 0; i<size; i++) { int findMin(int T[], int size) cout << "Addition Min : un caractère et qui
tempArray[i] = T[i]; { " << valmini << endl; retourne le caractère avec
} // Initialiser la variable cout << "Addition Max : une inversion des
de minimum avec la " << valmaxi << endl; majuscules et
// Trier le tableau première valeur du [Link] c++
temporaire par ordre tableau return 0;
croissant en utilisant le tri int minVal = T[0]; } #include <iostream>
à bulles // Parcourir le tableau
bubbleSort(tempArray, pour trouver le minimum int main() { using namespace std;
size); for (int i = 1; i < size; i++) int n = 6;
{ int t[n] = {1, 3, 5, 7, 9, char
// Calculer la valeur if (T[i] < minVal) { 4}; inverserMajusculesMinusc
minimale en additionnant minVal = T[i]; ules(char caractere) {
les 5 plus petits éléments } valMiMa(t, n); // Vérifier si le caractère
int minSum = } est une majuscule
tempArray[0] + return minVal; return 0; if (isupper(caractere)) {
tempArray[1] + } } // Si c'est une
tempArray[2] + majuscule, retourner la
tempArray[3] + // Fonction pour trouver version minuscule
tempArray[4]; le maximum dans un Examen de return
tableau rattrapage tolower(caractere);
// Calculer la valeur int findMax(int T[], int } else if
maximale en additionnant size) {
d’Algorihmique et (islower(caractere)) {
les 5 plus grands éléments // Initialiser la variable programmation C+ // Si c'est une
int maxSum = de maximum avec la + minuscule, retourner la
tempArray[1] + première valeur du version majuscule
tempArray[2] + tableau
25/02/2O22 return
tempArray[3] + int maxVal = T[0]; Exercice 1 toupper(caractere);
tempArray[4] + // Parcourir le tableau Écrire une fonction int } else {
tempArray[5]; pour trouver le maximum U(int n) qui renvoie la // Si ce n'est ni une
for (int i = 1; i < size; i++) valeur Un de la suite majuscule ni une
cout << "La valeur { définie comme suit. minuscule, retourner le
minimale en additionnant if (T[i] > maxVal) { U0=1 caractère inchangé
exactement 5 des six maxVal = T[i]; Un =2Un-1+1 si n est pair return caractere;
entiers est : " << minSum } Un =2n-5 si n est impair }
<< endl; } Tous en c++ }
cout << "La valeur return maxVal;
maximale en additionnant } #include <iostream> int main() {
exactement 5 des six // Testons la fonction
entiers est : " << maxSum // Fonction pour calculer using namespace std; avec quelques caractères
<< endl; la somme des éléments char c1 = 'A';
} d'un tableau int U(int n) { char c2 = 'b';
int calculateSum(int T[], if (n == 0) { char c3 = '7';
int main() { int size) { return 1;
const int size = 6; // Initialiser la variable } else if (n % 2 == 0) { cout << "Inversion de
int myArray[size] = {1, 3, de somme à zéro // Si n est pair majuscules/minuscules
5, 7, 9, 4}; int sum = 0; return 2 * U(n - 1) + 1; pour " << c1 << " : " <<
// Parcourir le tableau } else { inverserMajusculesMinusc
// Appeler la fonction et ajouter chaque élément // Si n est impair ules(c1) << endl;
pour trouver la valeur à la somme return 2 * n - 5; cout << "Inversion de
minimale et maximale en for (int i = 0; i < size; i++) } string
additionnant 5 des six { } inverserMajusculesMinusc
entiers sum += T[i]; ules(const string& chaine)
} int main() { {
findMinMaxSum(myArray, return sum; // Testons la fonction string resultat = "";
size); } avec quelques valeurs de
n for (char caractere :
return 0; int valMiMa(int t[], int n) { cout << "U(0) = " << chaine) {
U(0) << endl;
 if (isupper(caractere)) string texte = "Hello void tri(int T[], int n) { // Demander à
{ World! 123"; for (int i = 0; i < n - 1; i+ l'utilisateur de saisir les
resultat += +) { valeurs du tableau
tolower(caractere); cout << "Avant : " << for (int j = 0; j < n - i - cout << "Saisissez les
} else if texte << endl; 1; j++) { valeurs du tableau :\n";
(islower(caractere)) { cout << "Après : " << if (T[j] > T[j + 1]) { for (int i = 0; i < n; i++) {
resultat += inverserMajusculesMinusc int temp = T[j]; cout << "T[" << i <<
toupper(caractere); ules(texte) << endl; T[j] = T[j + 1]; "] : ";
} else { T[j + 1] = temp; cin >> T[i];
resultat += return 0; } }
caractere; } }
} } // Afficher le tableau
} Une autre méthode } avant le tri
string cout << "\nTableau
return resultat; inverserMajusculesMinusc int main() { avant le tri : ";
}majuscules/minuscules ules(const string& chaine) int n = 5; // Vous devez for (int i = 0; i < n; i++) {
pour " << c2 << " : " << { spécifier une taille pour le cout << T[i] << " ";
inverserMajusculesMinusc string resultat = ""; tableau }
ules(c2) << endl; int t[] = {2, 7, 1, 0, 5}; //
cout << "Inversion de for (char caractere : Initialisation correcte du // Appeler la fonction
majuscules/minuscules chaine) { tableau de tri à bulles
pour " << c3 << " : " << if (isupper(caractere)) tri(t, n); triBulles(T, n);
inverserMajusculesMinusc {
ules(c3) << endl; resultat += // Affichage du tableau // Afficher le tableau
tolower(caractere); trié après le tri
return 0; } else if cout << "Tableau trié : "; cout << "\nTableau
} (islower(caractere)) { for (int i = 0; i < n; i++) { après le tri : ";
resultat += cout << t[i] << " "; for (int i = 0; i < n; i++) {
Version chaine de toupper(caractere); } cout << T[i] << " ";
caractères } else { }
resultat += return 0;
#include <iostream> caractere; } return 0;
#include <cctype> // } 2. }
Inclure la bibliothèque } #include <iostream>
pour isupper, islower,
toupper, tolower return resultat; using namespace std;
} Examen
using namespace std; // Fonction de tri à bulles

Exercice 3 void triBulles(int T[], int n) d’Algorithmi

string {
inverserMajusculesMinusc for (int i = 0; i < n - 1; i+ que et
Il y a quelques erreurs
ules(const string& chaine)
{ dans votre programme :
+) {
for (int j = 0; j < n - i - programmati
string resultat = "";
Vous devez spécifier une
1; j++) {
if (T[j] > T[j + 1]) {
on C++
for (int i = 0; i < taille pour le tableau t // Échanger les
dans la fonction main.
[Link](); i++) {
char caractere = Actuellement, vous
éléments si ils sont dans le
mauvais ordre Session
chaine[i];
if (isupper(caractere))
utilisez int n; sans
initialiser n. Vous devez
int temp = T[j];
T[j] = T[j + 1];
Principale
{ déclarer n et lui attribuer T[j + 1] = temp; Exercice 1
resultat += une valeur avant de créer } #include <iostream>
tolower(caractere); le tableau. }
} else if }
(islower(caractere)) { La fonction tri a un type } int
resultat += de retour void, ce qui
countDivisibleByTwo(int
toupper(caractere); signifie qu'elle ne int main() { n);
} else { retourne rien. Dans le int n;
resultat += main, cout << tri(t, n) <<
caractere; endl; ne fonctionnera pas // Demander à
} comme prévu, car la l'utilisateur de saisir la int main() {
} fonction tri ne produit taille du tableau
aucune sortie à afficher. cout << "Saisissez la int num;
return resultat; taille du tableau : ";
} Voici une version corrigée cin >> n;
de votre programme :
std::cout << "Entrez un
int main() { // Créer un tableau de
entier : ";
// Testons la fonction #include <iostream> taille n
std::cin >> num;
avec une chaîne de int T[n];
caractères using namespace std;
 int count = cout << "Entrez une {1, 4, 6}, Initialiser(tableau,
countDivisibleByTwo(num) phrase : "; {4, 5, 9}, taille);
; getline(cin, {6, 9, 2}
inputPhrase); }; // Vous pouvez utiliser
std::cout << num << " n = 3; le tableau initialisé ici.
est divisible par 2 " << string modifiedPhrase =
count << " fois." << replaceSpaces(inputPhras /* return 0;
std::endl; e); cout << "Saisissez la }
taille de la matrice carrée :
return 0; cout << "Phrase "; 2.
} modifiée : " << cin >> n;
modifiedPhrase << endl; Ecrire une fonction
int int matrice[MAX][MAX]; PremOccurrence () qui
countDivisibleByTwo(int n) return 0; prend comme paramètre
{ } cout << "Saisissez les un tableau T et sa taille n
int count = 0; éléments de la matrice et un réel x puis elle
string carrée :\n"; retourne la position de la
while (n % 2 == 0 && n ! replaceSpaces(string for (int i = 0; i < n; i++) { première occurrence de x
= 0) { phrase) { for (int j = 0; j < n; j++) dans T, sinon elle retourne
n /= 2; for (int i = 0; i < { -1
count++; [Link](); i++) { cout << "M[" << i << #include <iostream>
} if (phrase[i] == ' ') { "][" << j << "] : ";
phrase[i] = '_'; cin >> matrice[i][j]; int PremOccurrence(const
return count; } } double T[], int n, double x)
} } } {
return phrase; */ for (int i = 0; i < n; ++i) {
Exercice 2 } if (T[i] == x) {
Exercice 4 if return i; //
#include <iostream> (Est_Symetrique(matrice, Retourne la position si
#include <cstdlib> Une matrice symétrique n)) { l'occurrence est trouvée
#include <ctime> est une matrice carrée qui cout << "La matrice }
using namespace std; est égale à sa propre est symétrique.\n"; }
transposée, c'est-à- } else { return -1; // Retourne -
int fibonacci(int n); dire telle que al,j = aj, cout << "La matrice 1 si l'occurrence n'est pas
pour tous i et J compris n'est pas symétrique.\n"; trouvée
int main() { entre 0 et n-1. } }
int n; Ecrire une fonction
srand(time(0)); Est_Symétrique() qui return 0; int main() {
n = rand() % 101; prend comme paramètres } const int taille = 5;
cout << "n = " << n << une matrice carrée M double tableau[taille];
endl; d'ordre n et affiche si M
est symétrique ou non. Exercice 5
// Remplir le tableau
int result = fibonacci(n); std::cout << "Saisissez
#include <iostream> les valeurs du tableau :\
cout << "F" << n << " = "
<< result << endl;
#define MAX 3
using namespace std; 1 . n";
for (int i = 0; i < taille; +
#include <iostream>
+i) {
return 0; using namespace std;
std::cout << "T[" << i
} bool Est_Symetrique(int << "] : ";
M[MAX][MAX], int n) { const int MAX = 100;
std::cin >> tableau[i];
int fibonacci(int n) { // Vérifier la symétrie }
if (n <= 1) { par rapport à la diagonale void Initialiser(double
return n; principale T[MAX], int& n) {
// Saisir la valeur à
} else { for (int i = 0; i < n; i++) { cout << "Saisissez la
rechercher
return fibonacci(n - 2) for (int j = i + 1; j < n; taille du tableau : ";
double
+ fibonacci(n - 1); j++) { cin >> n;
valeurRecherchee;
} if (M[i][j] != M[j][i]) std::cout << "Saisissez la
} { cout << "Saisissez les
valeur à rechercher : ";
Exercice 3 return false; valeurs réelles du
std::cin >>
#include <iostream> } tableau :\n";
valeurRecherchee;
#include <string> } for (int i = 0; i < n; i++) {
} cout << "T[" << i <<
// Appeler la fonction et
using namespace std; return true; "] : ";
afficher le résultat
} cin >> T[i];
int position =
string }
PremOccurrence(tableau,
replaceSpaces(string int main() { }
taille, valeurRecherchee);
phrase); int n;
int main() {
if (position != -1) {
int main() { // Matrice donnée en double tableau[MAX];
std::cout <<
string inputPhrase; exemple int taille;
"Première occurrence de "
int matrice[3][3] = { << valeurRecherchee << "
à la position : " << position position : " << position << // Remplir le tableau Exercice 5
<< std::endl; std::endl; std::cout << "Saisissez #include <iostream>
} else { } else { les valeurs du tableau :\ using namespace std;
std::cout << "Aucune std::cout << "Aucune n";
occurrence de " << occurrence de " << for (int i = 0; i < taille; + int main() {
valeurRecherchee << " valeurRecherchee << " +i) { int nombre, inverse = 0;
trouvée dans le tableau." trouvée dans le tableau." std::cout << "T[" << i
<< std::endl; << std::endl; << "] : "; // Demander à
} } std::cin >> tableau[i]; l'utilisateur d'entrer un
} nombre
return 0; return 0; cout << "Entrez un
} } // Saisir la valeur à nombre entier : ";
rechercher cin >> nombre;
4 double
3. #include <iostream> valeurRecherchee; // Inverser le nombre
#include <iostream> std::cout << "Saisissez la while (nombre != 0) {
int PremOccurrence(const valeur à rechercher : "; int chiffre = nombre %
int DernOccurrence(const double T[], int n, double x) std::cin >> 10;
double T[], int n, double x) { valeurRecherchee; inverse = inverse * 10
{ for (int i = 0; i < n; ++i) { + chiffre;
int position = -1; // if (T[i] == x) { // Appeler la fonction et nombre /= 10;
Initialise la position à -1, return i; // afficher le résultat }
au cas où x ne serait pas Retourne la première if
trouvé position de l'occurrence (UneOccurrence(tableau, // Afficher le nombre
} taille, valeurRecherchee)) inversé
for (int i = 0; i < n; ++i) { } { cout << "Le nombre
if (T[i] == x) { return -1; // Retourne - std::cout << "Il y a inversé est : " << inverse
position = i; // Met 1 si l'occurrence n'est pas une occurrence unique de << endl;
à jour la position trouvée " << valeurRecherchee <<
lorsqu'une occurrence de } " dans le tableau." << return 0;
x est trouvée std::endl; }
} int DernOccurrence(const } else {
} double T[], int n, double x) std::cout << "Il n'y a Intel Hyper-Threading (HT)
{ pas une occurrence et Turbo Boost sont deux
return position; int position = -1; // unique de " << technologies intégrées
} Initialise la position à -1, valeurRecherchee << " dans les processeurs Intel
au cas où x ne serait pas dans le tableau." << pour améliorer les
int main() { trouvé std::endl; performances et
const int taille = 5; } l'efficacité énergétique.
double tableau[taille]; for (int i = 0; i < n; ++i) {
if (T[i] == x) { return 0; Exercice 1
// Remplir le tableau position = i; // Met }
std::cout << "Saisissez à jour la position #include <iostream>
les valeurs du tableau :\ lorsqu'une occurrence de Exercice 3 #include <cmath>
n"; x est trouvée
for (int i = 0; i < taille; + } #include <iostream> #define MAX 100
+i) { } using namespace std;
std::cout << "T[" << i using namespace std;
<< "] : "; return position; int main() {
std::cin >> tableau[i]; } char c = 'B'; int
} int a = 0; calculateDiagonalDifferenc
bool UneOccurrence(const int b = 0; e(int matrix[MAX][MAX],
// Saisir la valeur à double T[], int n, double x) int n) {
rechercher { switch(c) { int leftToRightDiagonal =
double int premiereOccurrence case 'A': b = a++ + 2; 0;
valeurRecherchee; = PremOccurrence(T, n, x); break; int rightToLeftDiagonal =
std::cout << "Saisissez la int derniereOccurrence case 'B': b = a++ + 2; 0;
valeur à rechercher : "; = DernOccurrence(T, n, x); case 'C': ++b;
std::cin >> case 'D': b++;break; for (int i = 0; i < n; i++) {
valeurRecherchee; return default: a++; leftToRightDiagonal
(premiereOccurrence != -1 } += matrix[i][i];
// Appeler la fonction et && derniereOccurrence != rightToLeftDiagonal
afficher le résultat -1 && cout << a << endl; += matrix[i][n - 1 - i];
int position = premiereOccurrence == cout << b << endl; }
DernOccurrence(tableau, derniereOccurrence);
taille, valeurRecherchee); } return 0; return
} abs(leftToRightDiagonal -
if (position != -1) { int main() { rightToLeftDiagonal);
std::cout << "Dernière const int taille = 5; 1 }
occurrence de " << double tableau[taille]; 4
valeurRecherchee << " à la
void inputMatrix(int
matrix[MAX][MAX], int n)
{
cout << "Saisissez les
éléments de la matrice :\
n";
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++)
{
cout << "matrix["
<< i << "][" << j << "] : ";
cin >> matrix[i][j];
}
}
}

int main() {
int n;

cout << "Saisissez la

taille de la matrice carrée :
";
cin >> n;

int matrix[MAX][MAX];

if (n <= 0 || n > MAX) {

cout << "Taille de la
matrice invalide." << endl;
return 1;
}

inputMatrix(matrix, n);

int difference =
calculateDiagonalDifferenc
e(matrix, n);

cout << "La différence

absolue entre les sommes
des diagonales est : " <<
difference << endl;

return 0;
}