Code N1:: Devoir Maison C++

Devoir maison c++
 Code N1:
#include<iostream>
// Cette ligne inclut la bibliothèque iostream pour utiliser les
entrées/sorties .
using namespace std;
// Cette ligne évite d'avoir à utiliser le préfixe "std::" devant les
objets cout et cin
int main()
// Commance dexecution de programme.
int a, b, temp;
// La Déclaration des trois entières, a, b et temp.
cout << "Donner la valeur de a : ";
// Affiche le message "Donner la valeur de a : " à la console, puis
attend la saisie de l'utilisateur pour la stocker dans la variable
'a'.
cin >> a;
// entree de la valeur a
cout << "Donner la valeur de b : ";
// Affiche le message "Donner la valeur de b : " à la console, puis
attend la saisie de l'utilisateur pour la stocker dans la variable
'b'.
cin >> b;
//entree la valeur b
temp = a;
//Stocker la valeur de 'a' dans la variable 'temp'.
a = b;
//Affecte la valeur de 'b' à 'a'.
b = temp;
//Affecte la valeur temporaire 'temp' à 'b'
cout << "La valeur de a est " << a << endl;
//Affiche la valeur actuelle de 'a' avec le message "La valeur de a
est "
cout << "La valeur de b est " << b << endl;
//Affiche la valeur actuelle de 'b' avec le message "La valeur de b
est "
return 0;
// Termine la fonction main en renvoyant la valeur 0
----------------------------------------------------------------------
 Code N2 :
#include <iostream>
//C'est une directive de préprocesseur qui inclut la bibliothèque
iostream, nécessaire pour l'entrée/sortie en C++.
//Cela permet d'utiliser les éléments du namespace standard (std) sans
avoir à les qualifier explicitement.

int main()
//'est la fonction principale du programme. Elle retourne un entier
double lar, lon, sur, per;
//Déclaration de quatre variables de type double pour stocker la
largeur (lar), la longueur (lon), la surface (sur), et le périmètre
(per).
cout << "tappez la valeur de l : " ; cin >> lar;
//demander a tappez la valuer de lar
cout << "tappez la valeur de L : " ; cin >> lon;
//demander a tappez la valuer de lon
sur = lar * lon;
//Calcule la surface en multipliant la largeur par la longueur et
stocke le résultat dans sur.
per = 2 * (lar + lon);
//Calcule le périmètre en additionnant la largeur et la longueur,
multiplie le résultat par 2, et stocke le résultat dans per.
cout << "S= " << sur << endl;
//Affiche la surface.
cout << "P = " << per << endl;
//Affiche le périmètre.
return 0;
// a terminé son exécution et retourne 0
----------------------------------------------------------------------
 Code N3:
#include <iostream>
entrées/sorties .
objets cout et cin
const int N = 10;
// Définit une constante `N` à 10.
int main()
// Déclare la fonction `main` qui retourne un entier.
int t[N], i, ind;
//Déclare un tableau `t` d'entiers de taille `N`, deux variables ì`
et ìnd` d'entiers.
for (i = 0; i < N; i++)
// Déclare un boucle `for` pour parcourir le tableau `t` et demander à
l'utilisateur d'entrer chaque élément.
cout << "Tapez l'entier " << i << " : ";
//Affiche un message demandant à l'utilisateur d'entrer l'élément ì`
du tableau `t`.
cin >> t[i];

// l'entrée standard `cin` pour obtenir l'élément ì` du tableau
`t`.
ind = 0;
// nitialise l'indice du maximum à 0
for (i = 1; i < N; i++)
// Déclare une boucle `for` pour parcourir le tableau `t` à partir de
l'index 1 jusqu'à la fin.
if (t[i] > t[ind])
// Déclare une condition pour vérifier si l'élément ì` du tableau `t`
est plus grand que l'élément actuellement considéré comme maximum.
ind = i;
// Met à jour l'indice du maximum avec l'index ì`
cout << "La position du max est " << ind << endl;
//Affiche l'indice du maximum trouvé.
return 0;
// a terminé son exécution et retourne 0
----------------------------------------------------------------------
 Code N4 :
#include <iostream>
//Directive de préprocesseur pour inclure la bibliothèque iostream
nécessaire pour les entrées/sorties en C++.
//Permet d'utiliser les éléments du namespace standard (std) sans
avoir à les qualifier explicitement.
int main()
//Déclaration de la fonction principale du programme qui retourne un
entier.
int n;
//Déclaration d'une variable entière n pour stocker la valeur saisie
par l'utilisateur.
double fact = 1;
//Initialisation de la variable fact à 1. Cette variable sera utilisée
pour stocker le résultat du calcul du factoriel.
cout << "Tapez un entier : "; cin >> n;
//Affiche un message demandant à l'utilisateur de saisir un entier,
puis lit cette valeur depuis la console et la stocke dans la variable
n.
for (int i = 2; i <= n; i++) { fact = fact * i; }
//Utilisation d'une boucle for pour calculer le factoriel. La boucle
commence à i = 2 et se poursuit jusqu'à ce que i soit inférieur ou
égal à n. À chaque itération, la variable fact est multipliée par i.
cout << "Le factoriel " << n << "! = " << fact << endl;
//Affiche le résultat du calcul du factoriel.

return 0;
// Indique que le programme s'est terminé avec succès
----------------------------------------------------------------------
 Code N5:
#include <iostream>
entrées/sorties .
objets cout et cin
const int N = 10;
// Définit une constante `N` à 10.
int main()
int t[N], i, nb = 0;
//Déclare un tableau `t` d'entiers de taille `N`, deux variables ì`
et `nb` d'entiers. `nb` est initialisée à 0.
for (i = 0; i < N; i++)
//Déclare un boucle `for` pour parcourir le tableau `t` et demander à
l'utilisateur d'entrer chaque élément.
cout << "Tapez un entier : ";

//Affiche un message demandant à l'utilisateur d'entrer un élément du
tableau `t`.
cin >> t[i]; // entree dun entier .
for (i = 0; i < N; i++)
//Déclare une boucle `for` pour parcourir le tableau `t` et compter le
nombre d'entiers supérieurs ou égal à 10.
if (t[i] >= 10)
//Déclare une condition pour vérifier si l'élément ì` du tableau `t`
est supérieur ou égal à 10.
nb++;
//Incrémente la variable `nb` de 1 si l'élément courant est supérieur
ou égal à 10.
cout << "Le nombre d'entiers >= à 10 est : " << nb << endl;
//Affiche le nombre d'entiers supérieurs ou égal à 10.
return 0;
}
----------------------------------------------------------------------
 Code N6 :
#include <iostream>
//Cette ligne inclut le fichier d'en-tête ìostream`, qui définit les
opérations d'entrée/sortie standard de C++.
//Cette ligne permet d'utiliser les espaces de noms de la bibliothèque
standard `std` sans préfixe.
int minimax(int *p, int n, int *pmin, int *pmax) {
int *i(0);
// Déclare un pointeur i et l'initialise à 0
*pmin = *p;
// Initialise la valeur minimale au premier élément du tableau
pointé par p
*pmax = *p;
// Initialise la valeur maximale au premier élément du tableau
pointé par p
for (i = p; i < p + n; i++) {
// Parcourt le tableau pointé par p
if (*i < *pmin) *pmin = *i;

// Si l'élément actuel est inférieur à la valeur minimale
actuelle, mettez à jour la valeur minimale
if (*i > *pmax) *pmax = *i;
// Si l'élément actuel est supérieur à la valeur maximale
actuelle, mettez à jour la valeur maximale
return 0;
// Renvoie 0 car la fonction minimax ne renvoie aucune valeur utile
dans ce cas
int main()
int tn[] = {12, 23, 36, 5, 16, 46, 9, 25};
// Déclare un tableau d'entiers tn avec quelques
int min, max, r;
// Déclarez les variables min, max et r pour stocker respectivement
les valeurs minimales et maximales et la valeur de retour de la
fonction minimax
r = minimax(tn, sizeof(tn) / sizeof(int), &min, &max);
// Appelez la fonction minimax avec le tableau tn, sa taille et
ses pointeurs pour stocker respectivement les valeurs minimales et
maximales. Stockez la valeur de retour dans r.
cout << "Min, Max : " << min << " " << max << endl;
// Imprime les valeurs minimales et maximales stockées
respectivement dans les variables min et max.
return 0;
----------------------------------------------------------------------
 Code N7 :
#include <iostream>
const int N = 10;
//Cette ligne déclare une constante `N` de type ìnt` et initialise sa
valeur à 10.
int main()
//Cette ligne déclare la fonction `main()` qui est le point d'entrée
du programme. Elle retourne un entier ìnt` et n'accepte aucun
argument.
int t[N], nb = 0, choix, e, i;
//Cette ligne déclare quatre variables `t`, `nb`, `choix`, è`, et ì`
de type ìnt`. La variable `t` est un tableau de taille `N` déclaré
avec la constante `N` précédente. La variable `nb` est initialisée à
0.
bool fini = false;
//Cette ligne déclare une variable `fini` de type `bool` et initialise
sa valeur à `false`.
while (!fini)
//Cette ligne déclare une boucle `while` qui se termine lorsque la
condition `!fini` est vraie.
cout << "1. Ajouter un entier" << endl;
// Cette ligne affiche un message d'invitation à l'utilisateur pour
ajouter un entier.
cout << "2. Afficher la liste des entiers" << endl;
//Cette ligne affiche un message d'invitation à l'utilisateur pour
afficher la liste des entiers.
cout << "3. Supprimer le dernier entier de la liste" << endl;
supprimer le dernier entier de la liste.

cout << "4. Afficher le dernier entier de la liste" << endl;
afficher le dernier entier de la liste.
cout << "5. Quitter" << endl;
quitter le programme.
cout << "Votre choix : ";
choisir une opération.
cin >> choix;
//Cette ligne lit l'entrée standard (clavier) et stocke la valeur
saisie dans la variable `choix`.
switch (choix)
//Cette ligne déclare une structure `switch` pour sélectionner
l'action à effectuer en fonction de la valeur de la variable `choix`.
case 1:
//Cette ligne déclare la première option du menu, qui correspond à
l'opération "Ajouter un entier".
cout << "Tapez un entier : ";
saisir un entier.
cin >> e;
saisie dans la variable è`.

if (nb < N)
//Cette ligne déclare une condition pour vérifier si il est possible
d'ajouter un nouvel entier dans le tableau `t`.
t[nb] = e;
//Cette ligne stocke l'entier è` dans la position `nb` du tableau
`t`.
nb++;
//Cette ligne incrémente la variable `nb` pour indiquer qu'un nouvel
entier a été ajouté.
cout << "ENTIER AJOUTE" << endl;
//Cette ligne affiche un message pour indiquer à l'utilisateur que
l'entier a été ajouté avec succès.
else
// Cette ligne déclare une condition pour vérifier si la liste
contient des entiers.
cout << "IMPOSSIBLE, LE TABLEAU EST PLEIN" << endl;
// afichier impossible
break;
//Cette ligne termine la structure `switch`.
case 2:
//Cette ligne déclare la deuxième option du menu, qui correspond à
l'opération "Afficher la liste des entiers".
if (nb == 0)
//Cette ligne déclare une condition pour vérifier si la liste est
vide.
cout << "LA LISTE EST VIDE" << endl;
// affichier "la list est vide"
else
//Cette ligne déclare une condition pour vérifier si la liste contient
des entiers.
cout << "VOICI LA LISTE" << endl;
//Cette ligne affiche un message pour indiquer à l'utilisateur que la
liste est affichée.
for (i = 0; i < nb; i++)
// cette boucle for s'exécutera tant que la valeur de "i" est
inférieure à "nb", en commençant par initialiser "i" à 0 et en
l'incrémentant de 1 à chaque itération.
cout << t[i] << " ";
//Cette ligne déclare une boucle `for` pour parcourir les entiers de
la liste `t`.
cout << endl;

//Cette ligne affiche l'entier `t[i]` suivi d'un espace.
break;
// Cette ligne termine la structure `switch`.
case 3:
//Cette ligne déclare la troisième option du menu, qui correspond à
l'opération "Supprimer le dernier entier de la liste".
if (nb > 0)
des entiers.
nb--;
//Cette ligne décrémente la variable `nb` pour indiquer qu'un entier a
été supprimé.
cout << "ENTIER SUPPRIME" << endl;
//cette ligne affiche un message pour indiquer à l'utilisateur que
l'entier a été supprimé avec succès.
else
//Cette ligne déclare une condition pour vérifier si entirer est
suprime
//cette ligne affiche un message pour indiquer à l'utilisateur que la
list est vide .

}
break;
case 4:
//Cette ligne déclare la quatrième option du menu, qui correspond à
l'opération "Afficher le dernier entier de la liste".
if (nb > 0)
des entiers.
cout << "LE DERNIER ENTIER EST " << t[nb - 1] << endl;
//cCette ligne affiche l'entier `t[nb - 1]` suivi d'un message pour
indiquer à l'utilisateur qu'il s'agit de l'entier le plus récent de la
liste.
else
//Cette ligne déclare une condition pour vérifier si la liste est
vide.
liste est vide.
break;
//Cette ligne termine la structure `switch`.

case 5:
// Cette ligne déclare la cinquième option du menu, qui correspond à
l'opération "Quitter".
fini = true;
//Cette ligne initialise la variable `fini` à `true` pour indiquer à
la boucle `while` que le programme doit se terminer.
break;
return 0;
//Cette ligne retourne la valeur 0 pour indiquer à l'OS que le
programme s'est terminé sans erreur.
----------------------------------------------------------------------
 Code N8 :
#include <iostream>
#include <string>
//qui indique au compilateur d'inclure la bibliothèque standard
<string>. Cette bibliothèque fait partie de la bibliothèque standard
du C++
struct Livre {
// Cela indique le début de la déclaration d'une structure nommée
"Livre".
string titre;
// Cette ligne déclare un membre de la structure "Livre" de type
string et nommé "titre".
string auteur;
//De manière similaire, cette ligne déclare un autre membre de la
structure "Livre", de type string et nommé "auteur".
int anneePublication;
//Cette ligne déclare un membre de type int nommé "anneePublication".
string ISBN;
// Encore une fois, cette ligne déclare un membre de type string nommé
"ISBN"
};
//Définition d'une structure Livre qui représente un livre avec des
propriétés telles que le titre, l'auteur, l'année de publication et
l'ISBN.
const int MAX_LIVRES = 100;
//Définition d'une constante qui spécifie la taille maximale de la
bibliothèque.
Livre bibliotheque[MAX_LIVRES];
//Déclaration d'un tableau de livres pour stocker les livres dans la
bibliothèque.
int nombreLivres = 0;
// Variable pour suivre le nombre actuel de livres dans la
bibliothèque.
void ajouterLivre() {
//Début de la définition de la fonction ajouterLivre.
if (nombreLivres < MAX_LIVRES) {
//Vérifie si la bibliothèque n'est pas pleine en comparant le nombre
actuel de livres avec la taille maximale de la bibliothèque.
cout << "Ajout d'un nouveau livre : " << endl;
//Affiche un message pour indiquer que l'utilisateur est en train
d'ajouter un nouveau livre.
cout << "Titre : ";
//Invite l'utilisateur à saisir le titre du livre.
cin >> bibliotheque[nombreLivres].titre;

//Lit la saisie de l'utilisateur et stocke le titre dans la structure
du livre dans la bibliothèque.
cout << "Auteur : ";
//Cette ligne affiche la chaîne de caractères "Auteur : " sur la
console grâce à cout Puis, elle lit une chaîne de caractères saisie
par l'utilisateur grâce à cin et stocke cette chaîne dans le membre
auteur de l'array bibliotheque à l'index spécifié par nombreLivres.
cin >> bibliotheque[nombreLivres].auteur;
//Lit la saisie de l'utilisateur et stocke auteur dans la structure du
livre dans la bibliothèque.
cout << "Annee de publication : ";
// Affiche un message Annee de publication
cin >> bibliotheque[nombreLivres].anneePublication;
//Lit la saisie de l'utilisateur et stocke anneePublication dans la
structure du livre dans la bibliothèque.
cout << "ISBN : ";
//Cette ligne affiche la chaîne de caractères "ISBN : " sur la console
grâce à cout..
cin >> bibliotheque[nombreLivres].ISBN;
// Affiche un message si la bibliothèque est vide.
nombreLivres++;
//Incrémente le nombre de livres dans la bibliothèque après avoir
ajouté un livre.
cout << "Livre ajouté avec succès !" << endl;
//Affiche un message indiquant que le livre a été ajouté avec succès.
} else {
cout << "La bibliothèque est pleine." << endl;
//Affiche un message indiquant que la bibliothèque est pleine.
//Fin de la structure conditionnelle.
void afficherLivres() {
//Début de la définition de la fonction afficherLivres.
if (nombreLivres == 0) {
//Vérifie si la bibliothèque est vide en comparant le nombre de livres
avec zéro.
cout << "La bibliothèque est vide." << endl;
// Affiche un message si la bibliothèque est vide.
} else {
//Partie exécutée si la bibliothèque n'est pas vide.
cout << "Livres dans la bibliothèque : " << endl;
//Affiche un message indiquant que les livres sont présents dans la
bibliothèque.
for (int i = 0; i < nombreLivres; i++) {

// Début d'une boucle for qui parcourt chaque livre dans la
bibliothèque.
cout << "Livre " << i + 1 << " :" << endl;
//Affiche le numéro du livre.
cout << "Titre : " << bibliotheque[i].titre << endl;
// Affiche un message "Titre :".
cout << "Auteur : " << bibliotheque[i].auteur << endl;
// Affiche un message "Auteur :".
cout << "Annee de publication : " << bibliotheque[i].anneePublication
<< endl;
// Affiche un message "Annee de publication :".
cout << "ISBN: " << bibliotheque[i].ISBN<< endl;
// Affiche un message "ISBN :".
cout << endl;
//Affiche une ligne vide pour séparer les informations des différents
livres.
int main() {
//Cette ligne déclare la fonction `main()` qui est le point
d'entrée du programme. Elle retourne un entier ìnt` et n'accepte
aucun argument.
int choix;
//Déclaration d'une variable entière choix pour stocker l'option
choisie par l'utilisateur dans le menu.
do {
//Début de la boucle do-while, qui garantit que le bloc d'instructions
à l'intérieur est exécuté au moins une fois, et ensuite tant que la
condition spécifiée (choix != 3) est vraie.
cout << "Menu :" << endl;
//Affichage du menu principal.
cout << "1. Ajouter un livre" << endl;
//Affichage de l'option pour ajouter un livre.
cout << "2. Afficher les livres" << endl;
//Affichage de l'option pour afficher les livres.
cout << "3. Quitter" << endl;
//Affichage de l'option pour quitter le programme.
cout << "Faites un choix : ";
//Invite l'utilisateur à faire un choix.
cin >> choix;
//Lit le choix de l'utilisateur depuis l'entrée standard et le stocke
dans la variable choix.
switch (choix) {
//Début de la structure de contrôle switch, qui évalue la valeur de
choix et exécute le bloc de code correspondant à la valeur.
case 1:
//Si choix est égal à 1, exécute les instructions suivantes.

ajouterLivre();
// Appelle la fonction ajouterLivre(), qui permet à l'utilisateur
d'ajouter un livre à la bibliothèque.
break;
//Termine le bloc case et sort du switch.
case 2:
afficherLivres();
//Appelle la fonction afficherLivres(), qui affiche la liste des
livres dans la bibliothèque.
break;
case 3:
cout << "Au revoir !" << endl;
//Affiche un message de départ.
break;
default:
//Cette partie est exécutée si choix n'est égal à aucune des valeurs
spécifiées dans les case.
cout << "Choix invalide." << endl;
//Affiche un message d'erreur pour un choix invalide.
} while (choix != 3);

//Fin de la boucle do-while. Répète le bloc d'instructions tant que
choix est différent de 3.
return 0;
//Indique que le programme s'est terminé avec succès en retournant 0
----------------------------------------------------------------------
 Code N9 :
#include <iostream>
int main() {
// Cette ligne déclare la fonction `main()` qui est le point d'entrée
du programme. Elle retourne un entier ìnt` et n'accepte aucun
argument.
int taille;
// Cette ligne déclare une variable `taille` de type ìnt` pour
stocker la taille de la liste d'entiers.
cout << "Saisir la taille de la liste d'entiers : ";

saisir la taille de la liste d'entiers.
cin >> taille;
// Cette ligne lit l'entrée standard (clavier) et stocke la valeur
saisie dans la variable `taille`.
int* listeEntiers = new int[taille];
//Cette ligne déclare une variable `listeEntiers` de type ìnt*`
(pointeur vers un entier) et alloue dynamiquement un tableau de taille
`taille` via l'opérateur `new`.
cout << "Saisir les entiers : " << endl;
saisir les éléments de la liste.
for (int i = 0; i < taille; i++) {
//Cette ligne déclare une boucle `for` qui parcourt les indices de la
liste `listeEntiers` de 0 à `taille-1`.
cin >> listeEntiers[i];
saisie dans la position ì` de la liste `listeEntiers`.
cout << "Liste d'entiers : ";

liste est affichée.
for (int i = 0; i < taille; i++) {
//Cette ligne déclare une deuxième boucle `for` qui parcourt les
indices de la liste `listeEntiers` de 0 à `taille-1`.
cout << listeEntiers[i] << " ";
//Cette ligne affiche l'élément de la liste `listeEntiers` à l'index
ì` suivi d'un espace.
cout << endl;
//Cette ligne affiche un retour à la ligne pour séparer la liste des
autres messages.
delete[] listeEntiers;
//Cette ligne libère la mémoire dynamique allouée pour la liste
`listeEntiers` via l'opérateur `delete[]`.
return 0;
//Cette ligne termine la fonction `main()`

Code N1:: Devoir Maison C++

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Code N1:: Devoir Maison C++

Transféré par

Droits d'auteur :

Formats disponibles

Devoir maison c++

// Cette ligne inclut la bibliothèque iostream pour utiliser les

using namespace std;

// Cette ligne évite d'avoir à utiliser le préfixe "std::" devant les

objets cout et cin

// Commance dexecution de programme.

// La Déclaration des trois entières, a, b et temp.

cout << "Donner la valeur de a : ";

// Affiche le message "Donner la valeur de a : " à la console, puis

attend la saisie de l'utilisateur pour la stocker dans la variable

cout << "Donner la valeur de b : ";

// Affiche le message "Donner la valeur de b : " à la console, puis

attend la saisie de l'utilisateur pour la stocker dans la variable

//Stocker la valeur de 'a' dans la variable 'temp'.

//Affecte la valeur de 'b' à 'a'.

//Affecte la valeur temporaire 'temp' à 'b'

cout << "La valeur de a est " << a << endl;

//Affiche la valeur actuelle de 'a' avec le message "La valeur de a

cout << "La valeur de b est " << b << endl;

//Affiche la valeur actuelle de 'b' avec le message "La valeur de b

// Termine la fonction main en renvoyant la valeur 0

//C'est une directive de préprocesseur qui inclut la bibliothèque

iostream, nécessaire pour l'entrée/sortie en C++.

using namespace std;

//Cela permet d'utiliser les éléments du namespace standard (std) sans

avoir à les qualifier explicitement.

//'est la fonction principale du programme. Elle retourne un entier

double lar, lon, sur, per;

//Déclaration de quatre variables de type double pour stocker la

largeur (lar), la longueur (lon), la surface (sur), et le périmètre

cout << "tappez la valeur de l : " ; cin >> lar;

//demander a tappez la valuer de lar

cout << "tappez la valeur de L : " ; cin >> lon;

//demander a tappez la valuer de lon

sur = lar * lon;

//Calcule la surface en multipliant la largeur par la longueur et

stocke le résultat dans sur.

per = 2 * (lar + lon);

//Calcule le périmètre en additionnant la largeur et la longueur,

multiplie le résultat par 2, et stocke le résultat dans per.

cout << "S= " << sur << endl;

cout << "P = " << per << endl;

// a terminé son exécution et retourne 0

// Cette ligne inclut la bibliothèque iostream pour utiliser les

using namespace std;

// Cette ligne évite d'avoir à utiliser le préfixe "std::" devant les

objets cout et cin

const int N = 10;

// Définit une constante `N` à 10.

// Déclare la fonction `main` qui retourne un entier.

int t[N], i, ind;

//Déclare un tableau `t` d'entiers de taille `N`, deux variables `i`

for (i = 0; i < N; i++)

// Déclare un boucle `for` pour parcourir le tableau `t` et demander à

l'utilisateur d'entrer chaque élément.

cout << "Tapez l'entier " << i << " : ";

//Affiche un message demandant à l'utilisateur d'entrer l'élément `i`

cin >> t[i];

// nitialise l'indice du maximum à 0

for (i = 1; i < N; i++)

// Déclare une boucle `for` pour parcourir le tableau `t` à partir de

l'index 1 jusqu'à la fin.

if (t[i] > t[ind])

int minimax(int p, int n, int pmin, int *pmax) {

if (i < pmin) pmin = i;

if (i > pmax) pmax = i;