Voici un exemple de programme C qui lit un tableau d'entiers T de taille maximale 50, détermine la

position de la valeur maximale et l'affiche :

#include <stdio.h>
int main() {
int T[50];
int i, n, max, pos;

printf("Entrez la taille du tableau (max 50) : ");

scanf("%d", &n);

// Lecture du tableau
for (i = 0; i < n; i++) {
printf("Entrez la valeur de T[%d] : ", i);
scanf("%d", &T[i]);
}

// Recherche de la valeur maximale et de sa position

max = T[0];
pos = 0;
for (i = 1; i < n; i++) {
if (T[i] > max) {
max = T[i];
pos = i;
}
}

// Affichage de la position de la valeur maximale

printf("La valeur maximale est %d et se trouve à la position %d\n", max, pos);

return 0;
}
Le programme commence par déclarer un tableau d'entiers T de taille maximale 50,
ainsi que les variables i, n, max et pos.

Ensuite, le programme demande à l'utilisateur d'entrer la taille du tableau (la valeur

de n) à l'aide de scanf. Le programme utilise ensuite une boucle for pour lire les
valeurs du tableau à partir de l'entrée utilisateur.

Ensuite, le programme recherche la valeur maximale dans le tableau en utilisant une

autre boucle for. Pour cela, le programme compare chaque valeur du tableau à la
valeur maximale actuelle (initialisée à la première valeur du tableau) et met à jour la
valeur maximale et sa position si nécessaire.

Enfin, le programme affiche la valeur maximale et sa position à l'aide de printf .

Voici un exemple d'algorithme qui lit un tableau d'entiers T de taille maximale 50, détermine la
position de la valeur maximale et l'affiche :
Algorithme positionMax(T)
variables :
T : tableau d'entiers
n, i, max, pos : entiers

écrire "Entrez la taille du tableau (max 50) :"

lire n

// Lecture du tableau
pour i allant de 0 à n-1 faire
écrire "Entrez la valeur de T[", i, "] :"
lire T[i]
fin pour

// Recherche de la valeur maximale et de sa position

max <- T[0]
pos <- 0
pour i allant de 1 à n-1 faire
 si T[i] > max alors
max <- T[i]
pos <- i
fin si
fin pour

// Affichage de la position de la valeur maximale

écrire "La valeur maximale est ", max, " et se trouve à la position ", pos

Fin algorithme

L'algorithme commence par déclarer les variables T, n, i, max et pos.

Ensuite, l'algorithme demande à l'utilisateur d'entrer la taille du tableau n.

Le tableau est ensuite lu à l'aide d'une boucle pour, où chaque élément du tableau
est saisi par l'utilisateur.

Ensuite, l'algorithme recherche la valeur maximale et sa position en utilisant une

autre boucle pour. Pour cela, l'algorithme compare chaque valeur du tableau à la
valeur maximale actuelle (initialisée à la première valeur du tableau) et met à jour la
valeur maximale et sa position si nécessaire.

Enfin, l'algorithme affiche la valeur maximale et sa position à l'aide de l'instruction

écrire.

Voici un exemple d'algorithme qui utilise des pointeurs pour lire un tableau d'entiers T de taille
maximale 50, déterminer la position de la valeur maximale et l'afficher :
Algorithme positionMax(T)
variables :
T : tableau d'entiers
n, i, max, *pMax, pos, *pPos : entiers

pMax <- &T[0] // Pointeur initialisé sur le premier élément du tableau

pPos <- &pos // Pointeur initialisé sur la variable pos

écrire "Entrez la taille du tableau (max 50) :"

 lire n
// Lecture du tableau
pour i allant de 0 à n-1 faire
écrire "Entrez la valeur de T[", i, "] :"
lire *(T+i)
fin pour
// Recherche de la valeur maximale et de sa position
pour i allant de 1 à n-1 faire
si *(T+i) > *pMax alors
pMax <- (T+i)
pPos <- &i
fin si
fin pour

// Affichage de la position de la valeur maximale

écrire "La valeur maximale est ", *pMax, " et se trouve à la position ", *pPos
Fin algorithme

Dans cet algorithme, nous utilisons des pointeurs pour stocker l'adresse de la valeur maximale
(pMax) et de sa position ( pPos).

Le pointeur pMax est initialisé sur le premier élément du tableau T, tandis que le pointeur pPos est
initialisé sur la variable pos.

Le tableau est ensuite lu à l'aide d'une boucle pour, où chaque élément du tableau est saisi par
l'utilisateur. Nous utilisons la notation *(T+i) pour accéder à l'élément i du tableau.

Ensuite, l'algorithme recherche la valeur maximale et sa position en utilisant une autre boucle pour.
Pour cela, l'algorithme compare chaque valeur du tableau à la valeur maximale actuelle (pointée
par pMax) et met à jour le pointeur pMax et le pointeur pPos si nécessaire.

Enfin, l'algorithme affiche la valeur maximale et sa position à l'aide de l'instruction écrire . Nous
utilisons la notation *pMax et *pPos pour accéder aux valeurs pointées par les pointeurs.

Voici un exemple de programme en langage C qui utilise des pointeurs pour lire un tableau
d'entiers T de taille maximale 50, déterminer et afficher les positions des valeurs maximales :
#include <stdio.h>
void positionMax(int *T, int n)
{
int i, max, *pMax, pos, *pPos;

pMax = &T[0]; // Pointeur initialisé sur le premier élément du tableau

pPos = &pos; // Pointeur initialisé sur la variable pos

// Recherche de la première valeur maximale et de sa position

max = *pMax;
pos = 0;
for (i = 1; i < n; i++) {
if (*(T+i) > max) {
max = *(T+i);
pMax = (T+i);
pPos = &i;
}
}
// Affichage de la première position de la valeur maximale
printf("La valeur maximale est %d et se trouve à la position %d\n", *pMax, *pPos);

// Recherche des autres valeurs maximales et de leurs positions

for (i = 0; i < n; i++) {
if (*(T+i) == max && pPos != &i) {
printf("La valeur maximale est également à la position %d\n", i);
}
}
}
int main()
{
int T[50], n, i;

printf("Entrez la taille du tableau (max 50) : ");

scanf("%d", &n);
 // Lecture du tableau
for (i = 0; i < n; i++) {
printf("Entrez la valeur de T[%d] : ", i);
scanf("%d", &T[i]);
}
positionMax(T, n);

return 0;
}

Dans ce programme, nous utilisons la fonction positionMax pour déterminer et afficher les positions
des valeurs maximales dans le tableau T.

La fonction positionMax prend en entrée un pointeur T vers le tableau d'entiers et un entier n qui
représente la taille du tableau.

Nous utilisons des pointeurs pour stocker l'adresse de la valeur maximale ( pMax) et de sa position
(pPos).

Le pointeur pMax est initialisé sur le premier élément du tableau T, tandis que le pointeur pPos est
initialisé sur la variable pos.

Nous commençons par rechercher la première valeur maximale et sa position en utilisant une
boucle for. Pour cela, nous comparons chaque valeur du tableau à la valeur maximale actuelle
(initialisée à la première valeur du tableau) et mettons à jour le pointeur pMax et le pointeur pPos si
nécessaire.

Ensuite, nous affichons la première position de la valeur maximale à l'aide de la fonction printf.

Enfin, nous recherchons les autres valeurs maximales et leurs positions en utilisant une autre
boucle for. Pour cela, nous comparons chaque valeur du tableau à la valeur maximale et affichons
leur position à l'aide de la fonction printf si elles sont différentes de la première position.

Dans la fonction main, nous demandons à l'utilisateur d'entrer la taille du tableau n et les valeurs du
tableau T à l'aide de deux boucles for et de