UNIVERSITÉ IBN ZOHR – AGADIR TP N2 – Corrigé
UNIVERSITÉ IBN ZOHR – AGADIR
École Nationale des Sciences Appliquées
TP N°2 – Corrigé détaillé
Année Universitaire : 2025–2026 Filière : AP1
Prof. : Abenaou A. Auteur : SUPER
Énoncé (rappel)
Exercice 1. Écrire un programme qui permet de créer deux tableaux d’entiers T1 et T2. La
taille N doit être saisie à partir du clavier par l’utilisateur. À l’aide d’une boucle on saisit les
valeurs de T1. Le tableau T2 reçoit ses valeurs selon la règle suivante : si un élément de T1
est positif on le recopie directement dans T2 sinon on copie son carré. Afficher les deux tableaux.
Exercice 2. Écrire un programme qui permet de tester si une chaîne de caractères donnée
est un palindrome ou non (se lit de la même façon dans les deux sens). On lira une chaîne
depuis le clavier (taille maximale 100) et on comparera le premier caractère avec le dernier, le
deuxième avec l’avant-dernier, etc.
1 Corrigé complet
1.1 Remarques générales
Avant d’implémenter un programme, vérifier :
— Les bornes (valeurs maximales/minimales) : N positif, taille maximale raisonnable.
— Le comportement pour les cas limites : N = 0, tous nombres négatifs, chaîne vide, chaîne
d’un seul caractère.
— La présentation de la sortie pour faciliter la correction automatique (format clair).
1.2 Exercice 1 – Solution (C) et explication
Idée : lire N, allouer deux tableaux (ici statiques avec limite supérieure), remplir T1 par
saisie, puis pour chaque i écrire dans T2 : si T1[i] >= 0 alors T2[i] = T1[i] sinon T2[i] = T1[i]
* T1[i]. Enfin afficher les deux tableaux.
Complexité : O(N) en temps et O(N) en espace.
Code C complet :
1 // Exercice 1 : c r a t i o n des tableaux T1 et T2
2 #include <stdio.h>
3 #include <stdlib.h>
4
5 int main(void) {
6 const int MAX = 100; // taille max autoris e
7 int T1[MAX], T2[MAX];
8 int N;
9
10 printf("Entrez la taille N (1..%d) : ", MAX);
1
UNIVERSITÉ IBN ZOHR – AGADIR TP N2 – Corrigé
11 if (scanf("%d", &N) != 1) {
12 fprintf(stderr, "Erreur de lecture.\n");
13 return 1;
14 }
15 if (N <= 0 || N > MAX) {
16 fprintf(stderr, "N doit etre entre 1 et %d.\n", MAX);
17 return 1;
18 }
19
20 // Saisie des elements de T1
21 for (int i = 0; i < N; ++i) {
22 printf("T1[%d] = ", i);
23 if (scanf("%d", &T1[i]) != 1) {
24 fprintf(stderr, "Erreur de lecture a l’indice %d.\n", i);
25 return 1;
26 }
27 }
28
29 // Construction de T2 selon la regle donnee
30 for (int i = 0; i < N; ++i) {
31 if (T1[i] >= 0) {
32 T2[i] = T1[i];
33 } else {
34 // attention au debordement si T1[i] tres grand en valeur absolue
35 T2[i] = T1[i] * T1[i];
36 }
37 }
38
39 // Affichage
40 printf("\nT1 = [ ");
41 for (int i = 0; i < N; ++i) printf("%d ", T1[i]);
42 printf("]\n");
43
44 printf("T2 = [ ");
45 for (int i = 0; i < N; ++i) printf("%d ", T2[i]);
46 printf("]\n");
47
48 return 0;
49 }
Commentaires pédagogiques
— On a choisi ‘T1[i] >= 0‘ (positif ou nul) : si vous voulez strictement positif, remplacez par ‘>
0‘.
— Le calcul du carré peut provoquer un débordement si la valeur absolue est grande. Pour des
applications robustes, utilisez ‘long long‘ ou vérifiez la valeur absolue avant de multiplier.
— Tests recommandés :
— N=5, T1 = [2, -3, 0, -1, 5] ⇒ T2 = [2, 9, 0, 1, 5]
— N=1, T1 = [-10000] (vérifier débordement si int est petit)
1.3 Exercice 2 – Solution (C) et explication
Idée : lire la chaîne en tant que tableau de caractères (limite 100). Utiliser deux indices ‘i‘
(début) et ‘j‘ (fin) et comparer ‘s[i]‘ et ‘s[j]‘ en avançant / reculant jusqu’à i >= j. Attention
aux espaces et à la casse : définir si la vérification doit être sensible à la casse et inclure ou non
les espaces/punctuation. Ici nous proposons une version simple (sensible à la casse, espaces
pris en compte) et une version avancée (ignorer espaces, ponctuation et casse).
2
UNIVERSITÉ IBN ZOHR – AGADIR TP N2 – Corrigé
Code C (version simple) :
1 // Exercice 2 : test palindrome (simple)
2 #include <stdio.h>
3 #include <string.h>
4
5 int main(void) {
6 char s[101];
7 printf("Entrez une chaine (max 100 caracteres) :\n");
8 // lire une ligne avec fgets
9 if (fgets(s, sizeof(s), stdin) == NULL) {
10 return 1;
11 }
12 // supprimer eventuel ’\n’
13 size_t len = strlen(s);
14 if (len > 0 && s[len-1] == ’\n’) {
15 s[len-1] = ’\0’;
16 --len;
17 }
18
19 // indices
20 int i = 0, j = (int)len - 1;
21 int estPalindrome = 1; // vrai jusqu’a preuve du contraire
22
23 while (i < j) {
24 if (s[i] != s[j]) {
25 estPalindrome = 0;
26 break;
27 }
28 ++i; --j;
29 }
30
31 if (estPalindrome) {
32 printf("\"%s\" est un palindrome (sensible a la casse et aux espaces).\n", s);
33 } else {
34 printf("\"%s\" n’est pas un palindrome.\n", s);
35 }
36
37 return 0;
38 }
Version avancée : ignorer espaces, signes de ponctuation et casse
1 // Version avancee : on normalise la chaine (on ne garde que les lettres/digits et on
met en minuscules)
2 #include <stdio.h>
3 #include <string.h>
4 #include <ctype.h>
5
6 int main(void) {
7 char input[256];
8 char s[256];
9 printf("Entrez une phrase (max 255 caracteres) :\n");
10 if (fgets(input, sizeof(input), stdin) == NULL) return 1;
11 size_t L = strlen(input);
12 if (L > 0 && input[L-1] == ’\n’) input[L-1] = ’\0’;
13
14 // Normalisation : garder seulement alphanumeriques et mettre en minuscules
15 int k = 0;
16 for (size_t i = 0; i < strlen(input); ++i) {
17 if (isalnum((unsigned char)input[i])) {
18 s[k++] = (char)tolower((unsigned char)input[i]);
19 }
20 }
21 s[k] = ’\0’;
22
23 int i = 0, j = k - 1;
3
UNIVERSITÉ IBN ZOHR – AGADIR TP N2 – Corrigé
24 int estPalindrome = 1;
25 while (i < j) {
26 if (s[i] != s[j]) { estPalindrome = 0; break; }
27 ++i; --j;
28 }
29
30 if (estPalindrome) printf("\"%s\" est un palindrome (ignorant espaces/punctuation/
casse).\n", input);
31 else printf("\"%s\" n’est pas un palindrome (ignorant espaces/punctuation/casse).\n
", input);
32
33 return 0;
34 }
Commentaires pédagogiques
— La version simple est adaptée pour des chaînes sans espaces (ex : "radar", "elle").
— La version avancée est celle qu’on attend souvent dans des exercices réels : "A man, a plan,
a canal: Panama" devient palindrome après normalisation.
— Complexité : O(n) en temps et O(n) pour la version qui crée une chaîne normalisée.
2 Tests et exemples d’exécution
Exemple pour Exercice 1 :
Saisie : N=5, T1 = [2, -3, 0, -1, 5]
Sortie attendue : T1 = [ 2 -3 0 -1 5 ]
T2 = [ 2 9 0 1 5 ]
Exemples pour Exercice 2 :
— Entrée : radar ⇒ palindrome (simple).
— Entrée : A man, a plan, a canal: Panama ⇒ palindrome (version avancée).
— Entrée : hello ⇒ non palindrome.
3 Améliorations possibles et exercices supplémentaires
— Pour l’exercice 1 : gérer nombres flottants, ou utiliser allocation dynamique (‘malloc‘) pour N
arbitraire.
— Pour l’exercice 2 : écrire une fonction ‘isPalindrome(const char *s)‘ et des tests unitaires
(fichiers de test).
— Ajouter un menu pour choisir l’exercice à exécuter dans un même programme.
— Gérer les cas de débordement lors du calcul du carré (utiliser ‘long long‘).
Fin du corrigé .