[
{
"category": "exercise",
"question": "Écrire un programme Pascal qui échange les valeurs de deux entiers $x$ et $y$ à l'aide d'une variable temporaire. Afficher les valeurs avant et après échange.",
"choices": [
"A Corrige Type"
],
"correct": [
"A"
],
"explanation": "Solution complète :
Algorithme en Pascal :
program EchangeValeurs;\nvar\n x, y, temp : integer;\nbegin\n write('Entrez la valeur de x : ');\n readln(x);\n write('Entrez la valeur de y : ');\n readln(y);\n writeln('Avant l''échange: x = ', x, ', y = ', y);\n temp := x; // Sauvegarde la valeur de x\n x := y; // Remplace x par y\n y := temp; // Remplace y par la valeur initiale de x\n writeln('Après l''échange: x = ', x, ', y = ', y);\n readln;\nend.
Explication :
La variable temporaire $temp$ permet de stocker la valeur initiale de $x$. Ainsi, après échange :$x$ prend la valeur de $y$ et $y$ prend la valeur initiale de $x$.",
"id_category": "1",
"id_number": "1"
},
{
"category": "exercise",
"question": "Écrire un programme Pascal qui calcule la moyenne arithmétique de $n$ notes introduites par l'utilisateur et affiche le résultat.",
"choices": [
"A Corrige Type"
],
"correct": [
"A"
],
"explanation": "Solution complète :
Algorithme en Pascal :
program MoyenneNotes;\nvar\n n, i : integer;\n note, somme, moyenne : real;\nbegin\n write('Entrez le nombre de notes (n) : ');\n readln(n);\n somme := 0;\n for i := 1 to n do\n begin\n write('Entrez la note ', i, ' : ');\n readln(note);\n somme := somme + note;\n end;\n moyenne := somme / n;\n writeln('La moyenne des ', n, ' notes est : ', moyenne:0:2);\n readln;\nend.
Formule générale :
$moyenne = (\\sum_{i=1}^{n} note_{i}) / n$.",
"id_category": "1",
"id_number": "2"
},
{
"category": "exercise",
"question": "Créer un programme Pascal qui détermine si un entier $n$ saisi par l'utilisateur est pair ou impair. Afficher un message explicite.",
"choices": [
"A Corrige Type"
],
"correct": [
"A"
],
"explanation": "Solution complète :
Algorithme en Pascal :
program PairImpair;\nvar\n n : integer;\nbegin\n write('Entrez un entier n : ');\n readln(n);\n if n mod 2 = 0 then\n writeln(n, ' est pair')\n else\n writeln(n, ' est impair');\n readln;\nend.
Explication :
La division entière par $2$ permet de savoir si le reste ($n \\mod 2$) est zéro (pair) ou non (impair).",
"id_category": "1",
"id_number": "3"
},
{
"category": "exercise",
"question": "Écrire un algorithme Pascal pour lire les éléments d'un tableau d'entiers de taille $n$, puis afficher le minimum et le maximum.",
"choices": [
"A Corrige Type"
],
"correct": [
"A"
],
"explanation": "Solution complète :
Algorithme en Pascal :
program MinMaxTableau;\nconst\n MAX = 100;\nvar\n T : array[1..MAX] of integer;\n n, i, min, max : integer;\nbegin\n write('Donner la taille du tableau (n) : ');\n readln(n);\n for i := 1 to n do\n begin\n write('Entrer T[', i, '] : ');\n readln(T[i]);\n end;\n min := T[1];\n max := T[1];\n for i := 2 to n do\n begin\n if T[i] < min then min := T[i];\n if T[i] > max then max := T[i];\n end;\n writeln('Le minimum est : ', min, ', le maximum est : ', max);\n readln;\nend.
Étapes :
Initialiser $min$ et $max$ avec le premier élément.
Parcourir le tableau et mettre à jour selon la formule :$ min = \\min(min, T[i])$, $ max = \\max(max, T[i])$.",
"id_category": "1",
"id_number": "4"
},
{
"category": "exercise",
"question": "Donner un programme Pascal qui lit un entier naturel $n$ et calcule la factorielle $n!$. Afficher toutes les étapes du calcul.",
"choices": [
"A Corrige Type"
],
"correct": [
"A"
],
"explanation": "Solution complète :
Programme en Pascal :
program Factorielle;\nvar\n n, i : integer;\n fact : longint;\nbegin\n write('Entrer n : ');\n readln(n);\n fact := 1;\n for i := 1 to n do\n fact := fact * i;\n writeln(n, '! = ', fact);\n readln;\nend.
Formule générale :
$n! = 1 \\times 2 \\times \\ldots \\times n$.",
"id_category": "1",
"id_number": "5"
},
{
"category": "exercise",
"question": "Écrire un programme Pascal qui recherche le nombre d'occurrences d'une valeur donnée $x$ dans un tableau d'entiers de taille $n$.",
"choices": [
"A Corrige Type"
],
"correct": [
"A"
],
"explanation": "Solution complète :
Algorithme en Pascal :
program OccurrenceValeur;\nconst\n MAX = 100;\nvar\n T : array[1..MAX] of integer;\n n, i, x, cpt : integer;\nbegin\n write('Entrer la taille du tableau n : ');\n readln(n);\n for i := 1 to n do begin\n write('T[', i, '] : ');\n readln(T[i]);\n end;\n write('Entrer la valeur à chercher x : ');\n readln(x);\n cpt := 0;\n for i := 1 to n do begin\n if T[i] = x then\n cpt := cpt + 1;\n end;\n writeln('Le nombre d''occurrences de ', x, ' est : ', cpt);\n readln;\nend.
Formule générale :
$cpt = \\sum_{i=1}^{n} (T_{i} = x)$.",
"id_category": "1",
"id_number": "6"
},
{
"category": "exercise",
"question": "Rédiger un programme Pascal qui calcule le PGCD de deux entiers $a$ et $b$ à l'aide de l'algorithme d'Euclide.",
"choices": [
"A Corrige Type"
],
"correct": [
"A"
],
"explanation": "Solution complète :
Programme :
program CalculPGCD;\nvar\n a, b, r : integer;\nbegin\n write('Entrer a : '); readln(a);\n write('Entrer b : '); readln(b);\n while b <> 0 do\n begin\n r := a mod b; // Calcul du reste\n a := b;\n b := r;\n end;\n writeln('Le PGCD est : ', a);\n readln;\nend.
Formule générale :
Itérer tant que $b \\neq 0$ : remplacer $a$ par $b$, $b$ par $a \\mod b$. Le PGCD est la dernière valeur non nulle de $a$.",
"id_category": "1",
"id_number": "7"
},
{
"category": "exercise",
"question": "Créer un algorithme Pascal qui lit un tableau $T$ de $n$ entiers, puis trie ce tableau de façon croissante avec le tri à bulles.",
"choices": [
"A Corrige Type"
],
"correct": [
"A"
],
"explanation": "Solution complète :
Algorithme en Pascal :
program TriBulles;\nconst\n MAX = 100;\nvar\n T : array[1..MAX] of integer;\n n, i, j, tmp : integer;\n permut : boolean;\nbegin\n write('Donnez la taille du tableau n : ');\n readln(n);\n for i := 1 to n do begin\n write('T[', i, '] : ');\n readln(T[i]);\n end;\n repeat\n permut := false;\n for i := 1 to n-1 do\n if T[i] > T[i+1] then\n begin\n tmp := T[i]; T[i] := T[i+1]; T[i+1] := tmp;\n permut := true;\n end;\n until not permut;\n writeln('Tableau trié :');\n for i := 1 to n do write(T[i], ' ');\n writeln;\n readln;\nend.
Formule :
Comparer deux à deux $T_{i}$ et $T_{i+1}$, échanger si ordre non respecté, répéter jusqu'à plus d'échanges.",
"id_category": "1",
"id_number": "8"
},
{
"category": "exercise",
"question": "Donner un programme Pascal qui lit deux entiers $a$ et $b$ et calcule le quotient et le reste de la division entière de $a$ par $b$. Préciser le cas de la division par zéro.",
"choices": [
"A Corrige Type"
],
"correct": [
"A"
],
"explanation": "Solution complète :
Programme Pascal :
program DivisionEntiere;\nvar\n a, b, q, r : integer;\nbegin\n write('Entrer a : '); readln(a);\n write('Entrer b : '); readln(b);\n if b <> 0 then\n begin\n q := a div b;\n r := a mod b;\n writeln('Quotient : ', q);\n writeln('Reste : ', r);\n end\n else\n writeln('Erreur : division par zéro impossible.');\n readln;\nend.
Formule générale :
$a = b \\times q + r$, avec $0 \\leq r < |b|$.",
"id_category": "1",
"id_number": "9"
},
{
"category": "exercise",
"question": "Rédiger un programme Pascal qui lit une matrice d'entiers de dimension $n \\times m$ et calcule la somme de tous ses éléments.",
"choices": [
"A Corrige Type"
],
"correct": [
"A"
],
"explanation": "Solution complète :
Programme Pascal :
program SommeMatrice;\nconst\n MAXN = 50; MAXM = 50;\nvar\n M : array[1..MAXN, 1..MAXM] of integer;\n n, m, i, j, somme : integer;\nbegin\n write('Donner nombre de lignes n : '); readln(n);\n write('Donner nombre de colonnes m : '); readln(m);\n for i := 1 to n do\n for j := 1 to m do\n begin\n write('M[', i, ', ', j, '] : ');\n readln(M[i, j]);\n end;\n somme := 0;\n for i := 1 to n do\n for j := 1 to m do\n somme := somme + M[i, j];\n writeln('Somme de la matrice : ', somme);\n readln;\nend.
Formule :
$somme = \\sum_{i=1}^{n} \\sum_{j=1}^{m} M_{i,j}$.",
"id_category": "1",
"id_number": "10"
},
{
"category": "exercise",
"question": "Créer un programme Pascal pour remplir un tableau d'entiers de taille $n$ et afficher uniquement les valeurs positives, négatives et nulles séparément.",
"choices": [
"A Corrige Type"
],
"correct": [
"A"
],
"explanation": "Solution complète :
Algorithme :
program AfficheSignes;\nconst\n MAX = 100;\nvar\n T : array[1..MAX] of integer;\n n, i : integer;\nbegin\n write('Entrer taille tableau n : ');\n readln(n);\n for i := 1 to n do\n begin\n write('T[', i, '] : ');\n readln(T[i]);\n end;\n writeln('Positifs :');\n for i := 1 to n do if T[i] > 0 then write(T[i], ' ');\n writeln;\n writeln('Négatifs :');\n for i := 1 to n do if T[i] < 0 then write(T[i], ' ');\n writeln;\n writeln('Nuls :');\n for i := 1 to n do if T[i] = 0 then write(T[i], ' ');\n writeln;\n readln;\nend.
Détection :
Parcourir chaque $T_{i}$, afficher selon $T_{i} > 0$, $T_{i} < 0$, ou $T_{i} = 0$.",
"id_category": "1",
"id_number": "11"
},
{
"category": "exercise",
"question": "Écrire un programme Pascal qui lit une séquence d’entiers jusqu’à ce que la valeur $0$ soit saisie, puis affiche la moyenne des valeurs saisies (hors zéro).",
"choices": [
"A Corrige Type"
],
"correct": [
"A"
],
"explanation": "Solution complète :
Programme :
program MoyenneSequence;\nvar\n n, somme, cpt : integer;\nbegin\n somme := 0;\n cpt := 0;\n repeat\n write('Entrer un entier (0 pour arrêter) : ');\n readln(n);\n if n <> 0 then\n begin\n somme := somme + n;\n cpt := cpt + 1;\n end;\n until n = 0;\n if cpt > 0 then\n writeln('Moyenne : ', somme / cpt:0:2)\n else\n writeln('Aucune valeur saisie.');\n readln;\nend.
Formule :
$moyenne = \\frac{\\text{somme}}{\\text{cpt}}$, où $cpt$ est le nombre d’entiers saisis (excluant le zéro).",
"id_category": "1",
"id_number": "12"
},
{
"category": "exercise",
"question": "Créer un algorithme Pascal qui remplit un tableau de $n$ notes, affiche les notes supérieures à la moyenne, et indique combien d'étudiants ont eu la moyenne.",
"choices": [
"A Corrige Type"
],
"correct": [
"A"
],
"explanation": "Solution complète :
Programme :
program NotesSupMoyenne;\nconst\n MAX = 100;\nvar\n T : array[1..MAX] of real;\n n, i, nb_moyenne : integer;\n somme, moyenne : real;\nbegin\n write('Entrer n : ');\n readln(n);\n somme := 0;\n for i := 1 to n do\n begin\n write('Note ', i, ' : ');\n readln(T[i]);\n somme := somme + T[i];\n end;\n moyenne := somme / n;\n writeln('Notes supérieures à la moyenne (', moyenne:0:2, ') :');\n nb_moyenne := 0;\n for i := 1 to n do\n if T[i] > moyenne then\n writeln(T[i]:0:2)\n else if T[i] = moyenne then\n nb_moyenne := nb_moyenne + 1;\n writeln('Nombre d''étudiants ayant la moyenne : ', nb_moyenne);\n readln;\nend.
Étapes :
Calcul de $moyenne$ puis dénombrement des éléments $T_{i} > moyenne$ et $= moyenne$.",
"id_category": "1",
"id_number": "13"
},
{
"category": "exercise",
"question": "Écrire un programme Pascal qui lit un entier strictement positif $n$ et affiche tous ses diviseurs.",
"choices": [
"A Corrige Type"
],
"correct": [
"A"
],
"explanation": "Solution complète :
Algorithme :
program Diviseurs;\nvar\n n, i : integer;\nbegin\n write('Entrer un entier positif n : ');\n readln(n);\n write('Les diviseurs de ', n, ' sont : ');\n for i := 1 to n do\n if n mod i = 0 then\n write(i, ' ');\n writeln;\n readln;\nend.
Recherche :
Pour chaque $i \\in [1, n]$, tester si $n \\mod i = 0$.",
"id_category": "1",
"id_number": "14"
},
{
"category": "exercise",
"question": "Créer un algorithme Pascal qui lit deux tableaux $T_{1}$ et $T_{2}$ de taille $n$, construit un tableau somme $S$ tel que $S[i] = T_{1}[i] + T_{2}[i]$.",
"choices": [
"A Corrige Type"
],
"correct": [
"A"
],
"explanation": "Solution complète :
Programme :
program SommeDeuxTableaux;\nconst\n MAX = 100;\nvar\n T1, T2, S : array[1..MAX] of integer;\n n, i : integer;\nbegin\n write('Entrer la taille n : ');\n readln(n);\n writeln('Remplir T1 :');\n for i := 1 to n do\n begin\n write('T1[', i, '] : ');\n readln(T1[i]);\n end;\n writeln('Remplir T2 :');\n for i := 1 to n do\n begin\n write('T2[', i, '] : ');\n readln(T2[i]);\n end;\n for i := 1 to n do\n S[i] := T1[i] + T2[i];\n writeln('Somme S :');\n for i := 1 to n do\n write(S[i], ' ');\n writeln;\n readln;\nend.
Formule :
$S[i] = T_{1}[i] + T_{2}[i]$ pour tout $i \\in [1, n]$.",
"id_category": "1",
"id_number": "15"
},
{
"category": "exercise",
"question": "Créer un programme Pascal qui vérifie si un nombre $n$ est un nombre parfait (égale à la somme de ses diviseurs propres stricts).",
"choices": [
"A Corrige Type"
],
"correct": [
"A"
],
"explanation": "Solution complète :
Algorithme :
program NombreParfait;\nvar\n n, i, somme : integer;\nbegin\n write('Entrez n : ');\n readln(n);\n somme := 0;\n for i := 1 to n - 1 do\n if n mod i = 0 then\n somme := somme + i;\n if somme = n then\n writeln(n, ' est un nombre parfait')\n else\n writeln(n, ' n''est pas un nombre parfait');\n readln;\nend.
Définition :
Tester $\\sum_{i=1}^{n-1} (n \\mod i = 0) \\cdot i = n$.",
"id_category": "1",
"id_number": "16"
},
{
"category": "exercise",
"question": "Rédigez un programme Pascal pour lire une matrice carrée d'ordre $n$ et vérifier si elle est symétrique ($M[i, j] = M[j, i]$ pour tous $i, j$).",
"choices": [
"A Corrige Type"
],
"correct": [
"A"
],
"explanation": "Solution complète :
Programme :
program SymetrieMatrice;\nconst\n MAX = 50;\nvar\n M : array[1..MAX, 1..MAX] of integer;\n n, i, j : integer;\n sym : boolean;\nbegin\n write('Entrer n : ');\n readln(n);\n for i := 1 to n do\n for j := 1 to n do\n begin\n write('M[', i, ',', j, '] : ');\n readln(M[i, j]);\n end;\n sym := true;\n for i := 1 to n do\n for j := 1 to n do\n if M[i, j] <> M[j, i] then\n sym := false;\n if sym then\n writeln('Matrice symétrique')\n else\n writeln('Matrice non symétrique');\n readln;\nend.
Test :
Vérifier pour tout $i, j$ que $M[i, j] = M[j, i]$.",
"id_category": "1",
"id_number": "17"
},
{
"category": "exercise",
"question": "Écrire un programme Pascal qui lit un entier positif $n$ et affiche sa représentation binaire.",
"choices": [
"A Corrige Type"
],
"correct": [
"A"
],
"explanation": "Solution complète :
Algorithme :
program Binaire;\nvar\n n, reste : integer;\n binaire : string;\nbegin\n write('Entrer n : ');\n readln(n);\n binaire := '';\n if n = 0 then\n binaire := '0'\n else\n while n > 0 do\n begin\n reste := n mod 2;\n binaire := chr(48 + reste) + binaire;\n n := n div 2;\n end;\n writeln('Représentation binaire : ', binaire);\n readln;\nend.
Conversion :
Diviser récursivement $n$ par $2$ et concaténer chaque reste.",
"id_category": "1",
"id_number": "18"
},
{
"category": "exercise",
"question": "Écrire un programme Pascal qui calcule la suite de Fibonacci jusqu’à l’indice $n$, avec affichage de tous les termes.",
"choices": [
"A Corrige Type"
],
"correct": [
"A"
],
"explanation": "Solution complète :
Algorithme :
program Fibonacci;\nvar\n n, i, a, b, temp : integer;\nbegin\n write('Entrer n : ');\n readln(n);\n a := 0;\n b := 1;\n write(a, ' ', b, ' ');\n for i := 3 to n do\n begin\n temp := a + b;\n write(temp, ' ');\n a := b;\n b := temp;\n end;\n writeln;\n readln;\nend.
Formule :
$F_{0} = 0, F_{1} = 1, F_{k} = F_{k-1} + F_{k-2}$ pour $k \\geq 2$.",
"id_category": "1",
"id_number": "19"
},
{
"category": "exercise",
"question": "Créer un programme Pascal qui compte et affiche le nombre de voyelles et de consonnes dans une chaîne de caractères.",
"choices": [
"A Corrige Type"
],
"correct": [
"A"
],
"explanation": "Solution complète :
program CompteVoyCon;\nvar\n ch : string;\n i, cpt_voy, cpt_cons : integer;\n l : char;\nbegin\n write('Entrer une chaîne : ');\n readln(ch);\n cpt_voy := 0; cpt_cons := 0;\n for i := 1 to length(ch) do\n begin\n l := upcase(ch[i]);\n if (l in ['A','E','I','O','U','Y']) then\n cpt_voy := cpt_voy + 1\n else if (l in ['B'..'Z']) then\n cpt_cons := cpt_cons + 1;\n end;\n writeln('Voyelles : ', cpt_voy);\n writeln('Consonnes : ', cpt_cons);\n readln;\nend.
Dénombrer :
Parcourir chaque lettre, incrémenter un compteur selon la formule :$cpt_{voyelles} = \\sum (lettre \\in \\{'A','E','I','O','U','Y'\\})$.",
"id_category": "1",
"id_number": "20"
},
{
"category": "exercise",
"question": "Écrire un programme Pascal qui lit deux entiers $a$ et $b$, puis affiche leur somme, leur différence et leur produit. Utiliser des variables de type entier et l'instruction write pour afficher les résultats.",
"choices": [
"A Corrige Type"
],
"correct": [
"A"
],
"explanation": "Solution complète :
Programme Pascal :
program SommeEtOperations;\nvar\n a, b, somme, difference, produit : integer;\nbegin\n write('Entrez le premier entier a : ');\n readln(a);\n write('Entrez le second entier b : ');\n readln(b);\n \n somme := a + b;\n difference := a - b;\n produit := a * b;\n \n writeln('Somme : ', somme);\n writeln('Différence : ', difference);\n writeln('Produit : ', produit);\n \n readln;\nend.
Explication :
Déclaration des variables :
- $a, b$ : les deux entiers saisis
- $somme, difference, produit$ : résultats des opérations
Calculs arithmétiques :
- Somme : $a + b$
- Différence : $a - b$
- Produit : $a * b$
Exemple pour $a = 15$ et $b = 7$ :
Somme : $22$
Différence : $8$
Produit : $105$",
"id_category": "1",
"id_number": "21"
},
{
"category": "exercise",
"question": "Écrire un programme Pascal qui lit un entier $n$ et affiche la table de multiplication de $n$ de $1$ à $10$ (c'est-à-dire $n \\times 1, n \\times 2, ..., n \\times 10$). Utiliser une boucle for.",
"choices": [
"A Corrige Type"
],
"correct": [
"A"
],
"explanation": "Solution complète :
Programme Pascal :
program TableMultiplication;\nvar\n n, i, resultat : integer;\nbegin\n write('Entrez un entier n : ');\n readln(n);\n \n writeln('Table de multiplication de ', n, ' :');\n for i := 1 to 10 do\n begin\n resultat := n * i;\n writeln(n, ' x ', i, ' = ', resultat);\n end;\n \n readln;\nend.
Explication :
Variables :
- $n$ : l'entier saisi par l'utilisateur
- $i$ : compteur de la boucle (de 1 à 10)
- $resultat$ : le produit $n \\times i$
Boucle for :
La structure $for i := 1 to 10 do$ répète le bloc pour chaque valeur de $i$ de 1 à 10
Calcul et affichage :
À chaque itération, le produit $resultat := n \\times i$ est calculé puis affiché
Exemple pour $n = 3$ :
Table de multiplication de 3 :
$3 \\times 1 = 3$
$3 \\times 2 = 6$
$3 \\times 3 = 9$
... jusqu'à $3 \\times 10 = 30$",
"id_category": "1",
"id_number": "22"
},
{
"category": "exercise",
"question": "Écrire un programme Pascal qui lit un entier $n$ et affiche tous les diviseurs de $n$. Utiliser une boucle for et l'opérateur mod pour vérifier la divisibilité.",
"choices": [
"A Corrige Type"
],
"correct": [
"A"
],
"explanation": "Solution complète :
Programme Pascal :
program DiviseursEntier;\nvar\n n, i : integer;\nbegin\n write('Entrez un entier n : ');\n readln(n);\n \n if n <= 0 then\n writeln('Erreur : n doit être positif')\n else\n begin\n writeln('Diviseurs de ', n, ' :');\n for i := 1 to n do\n begin\n if n mod i = 0 then\n write(i, ' ');\n end;\n writeln;\n end;\n \n readln;\nend.
Explication :
Variables :
- $n$ : l'entier dont on cherche les diviseurs
- $i$ : compteur parcourant de 1 à $n$
Opérateur mod :
L'expression $n \\mod i = 0$ teste si $i$ divise $n$ (reste de division égal à 0)
Condition :
Si $n \\mod i = 0$, alors $i$ est un diviseur
Exemple pour $n = 12$ :
Diviseurs de 12 : $1 2 3 4 6 12$",
"id_category": "1",
"id_number": "23"
},
{
"category": "exercise",
"question": "Écrire un programme Pascal qui lit un entier $n$ et calcule puis affiche la factorielle de $n$ (c'est-à-dire $n! = n \\times (n-1) \\times (n-2) \\times ... \\times 1$). Utiliser une boucle for et gérer le cas où $n = 0$ ($0! = 1$).",
"choices": [
"A Corrige Type"
],
"correct": [
"A"
],
"explanation": "Solution complète :
Programme Pascal :
program FactorielleEntier;\nvar\n n, i : integer;\n factorielle : longint;\nbegin\n write('Entrez un entier n : ');\n readln(n);\n \n if n < 0 then\n writeln('Erreur : n doit être >= 0')\n else if n = 0 then\n writeln('0! = 1')\n else\n begin\n factorielle := 1;\n for i := 1 to n do\n factorielle := factorielle * i;\n \n writeln(n, '! = ', factorielle);\n end;\n \n readln;\nend.
Explication :
Variables :
- $n$ : l'entier dont on calcule la factorielle
- $i$ : compteur de la boucle
- $factorielle$ : type longint pour stocker les grands nombres
Gestion des cas :
- Si $n < 0$ : message d'erreur
- Si $n = 0$ : affichage $0! = 1$
- Sinon : boucle de multiplication successive
Formule générale :
$n! = n \\times (n-1) \\times (n-2) \\times ... \\times 1$
Exemple pour $n = 5$ :
Calcul : $1 \\times 1 \\times 2 \\times 3 \\times 4 \\times 5 = 120$
Affichage : $5! = 120$",
"id_category": "1",
"id_number": "24"
},
{
"category": "exercise",
"question": "Écrire un programme Pascal qui lit un entier $n$ et affiche si $n$ est un nombre pair ou impair. Utiliser l'opérateur mod et la structure conditionnelle if...else.",
"choices": [
"A Corrige Type"
],
"correct": [
"A"
],
"explanation": "Solution complète :
Programme Pascal :
program VerificationPairImpair;\nvar\n n : integer;\nbegin\n write('Entrez un entier n : ');\n readln(n);\n \n if n mod 2 = 0 then\n writeln(n, ' est un nombre PAIR')\n else\n writeln(n, ' est un nombre IMPAIR');\n \n readln;\nend.
Explication :
Variable :
- $n$ : l'entier à tester
Opérateur mod :
L'expression $n \\mod 2$ calcule le reste de la division de $n$ par 2
Critère de parité :
- Si $n \\mod 2 = 0$, alors $n$ est pair
- Sinon, $n$ est impair
Structure conditionnelle :
$if...then...else$ pour afficher le résultat approprié
Exemple pour $n = 7$ :
Reste de $7 \\div 2 = 1$
Affichage : $7$ est un nombre IMPAIR
Exemple pour $n = 12$ :
Reste de $12 \\div 2 = 0$
Affichage : $12$ est un nombre PAIR",
"id_category": "1",
"id_number": "25"
},
{
"category": "exercise",
"question": "Écrire un programme Pascal qui lit des entiers jusqu'à ce que l'utilisateur saisisse 0, puis affiche la somme de tous les entiers saisis. Utiliser une boucle while ou repeat...until.",
"choices": [
"A Corrige Type"
],
"correct": [
"A"
],
"explanation": "Solution complète :
Programme Pascal :
program SommeLecture;\nvar\n nombre, somme : integer;\nbegin\n somme := 0;\n writeln('Entrez des entiers (0 pour terminer) :');\n \n repeat\n write('Entrez un entier : ');\n readln(nombre);\n \n if nombre <> 0 then\n somme := somme + nombre;\n until nombre = 0;\n \n writeln('Somme totale : ', somme);\n \n readln;\nend.
Explication :
Variables :
- $nombre$ : l'entier saisi à chaque itération
- $somme$ : accumulation des entiers saisis
Boucle repeat...until :
Répète les instructions jusqu'à ce que $nombre = 0$
Accumulation :
À chaque itération, $somme := somme + nombre$ ajoute l'entier à la somme
Condition d'arrêt :
Quand $nombre = 0$, la boucle s'arrête et la somme est affichée
Exemple :
Saisie : 5, 3, 2, 0
Calcul : $5 + 3 + 2 = 10$
Affichage : Somme totale : $10$",
"id_category": "1",
"id_number": "26"
},
{
"category": "exercise",
"question": "Écrire un programme Pascal qui remplit un tableau de $n$ entiers, puis affiche le plus grand élément du tableau. Utiliser une boucle for pour remplir le tableau et une autre pour trouver le maximum.",
"choices": [
"A Corrige Type"
],
"correct": [
"A"
],
"explanation": "Solution complète :
Programme Pascal :
program MaximumTableau;\nconst\n MAX = 10;\nvar\n tableau : array[1..MAX] of integer;\n n, i, maximum : integer;\nbegin\n write('Entrez la taille du tableau (max 10) : ');\n readln(n);\n \n if n <= 0 or n > MAX then\n begin\n writeln('Erreur : taille invalide');\n end\n else\n begin\n writeln('Remplissez le tableau :');\n for i := 1 to n do\n begin\n write('Élément ', i, ' : ');\n readln(tableau[i]);\n end;\n \n maximum := tableau[1];\n for i := 2 to n do\n begin\n if tableau[i] > maximum then\n maximum := tableau[i];\n end;\n \n writeln('Le maximum du tableau est : ', maximum);\n end;\n \n readln;\nend.
Explication :
Déclaration du tableau :
$tableau : array[1..MAX] of integer$ déclare un tableau d'entiers de taille maximale 10
Remplissage du tableau :
Première boucle for remplit les $n$ éléments du tableau
Recherche du maximum :
- Initialiser $maximum = tableau[1]$
- Parcourir le tableau de l'indice 2 à $n$
- Si $tableau[i] > maximum$, mettre à jour maximum
Exemple pour $n = 5$ :
Tableau : $[7, 2, 9, 1, 5]$
Affichage : Le maximum du tableau est : $9$",
"id_category": "1",
"id_number": "27"
},
{
"category": "exercise",
"question": "Écrire un programme Pascal qui remplit un tableau de $n$ entiers, puis affiche le nombre de valeurs positives, négatives et nulles dans le tableau.",
"choices": [
"A Corrige Type"
],
"correct": [
"A"
],
"explanation": "Solution complète :
Programme Pascal :
program ClassificationTableau;\nconst\n MAX = 10;\nvar\n tableau : array[1..MAX] of integer;\n n, i, cptPositifs, cptNegatifs, cptNuls : integer;\nbegin\n write('Entrez la taille du tableau (max 10) : ');\n readln(n);\n \n if n <= 0 or n > MAX then\n begin\n writeln('Erreur : taille invalide');\n end\n else\n begin\n writeln('Remplissez le tableau :');\n for i := 1 to n do\n begin\n write('Élément ', i, ' : ');\n readln(tableau[i]);\n end;\n \n cptPositifs := 0;\n cptNegatifs := 0;\n cptNuls := 0;\n \n for i := 1 to n do\n begin\n if tableau[i] > 0 then\n cptPositifs := cptPositifs + 1\n else if tableau[i] < 0 then\n cptNegatifs := cptNegatifs + 1\n else\n cptNuls := cptNuls + 1;\n end;\n \n writeln('Valeurs positives : ', cptPositifs);\n writeln('Valeurs négatives : ', cptNegatifs);\n writeln('Valeurs nulles : ', cptNuls);\n end;\n \n readln;\nend.
Explication :
Variables compteurs :
- $cptPositifs$ : compte les valeurs $> 0$
- $cptNegatifs$ : compte les valeurs $< 0$
- $cptNuls$ : compte les valeurs égales à 0
Classification :
Boucle qui parcourt chaque élément et l'incrémente le compteur approprié
Condition imbriquée :
$if...then...else if...then...else$ pour classifier chaque élément
Exemple pour $n = 5$ :
Tableau : $[5, -2, 0, 8, -3]$
Affichage :
Valeurs positives : 2
Valeurs négatives : 2
Valeurs nulles : 1$",
"id_category": "1",
"id_number": "28"
},
{
"category": "exercise",
"question": "Écrire un programme Pascal qui remplit un tableau $2 \\times 3$ (2 lignes, 3 colonnes) de réels, puis affiche la matrice et calcule la somme de tous ses éléments.",
"choices": [
"A Corrige Type"
],
"correct": [
"A"
],
"explanation": "Solution complète :
Programme Pascal :
program MatriceRéelle;\nvar\n matrice : array[1..2, 1..3] of real;\n i, j : integer;\n somme : real;\nbegin\n writeln('Remplissez la matrice 2x3 :');\n \n for i := 1 to 2 do\n begin\n for j := 1 to 3 do\n begin\n write('Élément [', i, ',', j, '] : ');\n readln(matrice[i, j]);\n end;\n end;\n \n writeln('Affichage de la matrice :');\n for i := 1 to 2 do\n begin\n for j := 1 to 3 do\n write(matrice[i, j]:8:2, ' ');\n writeln;\n end;\n \n somme := 0;\n for i := 1 to 2 do\n begin\n for j := 1 to 3 do\n somme := somme + matrice[i, j];\n end;\n \n writeln('Somme de tous les éléments : ', somme:8:2);\n \n readln;\nend.
Explication :
Déclaration de la matrice :
$matrice : array[1..2, 1..3] of real$ déclare une matrice 2×3 de réels
Boucles imbriquées pour remplissage :
Boucle externe pour les lignes (i = 1 à 2)
Boucle interne pour les colonnes (j = 1 à 3)
Accès aux éléments :
$matrice[i, j]$ accède à l'élément à la ligne $i$ et colonne $j$
Affichage formaté :
$matrice[i, j]:8:2$ affiche le réel avec 8 caractères et 2 décimales
Calcul de la somme :
Boucles imbriquées qui accumulent tous les éléments
Exemple pour une matrice :
$\\begin{bmatrix} 1.5 & 2.3 & 0.8 \\\\ 4.1 & 3.2 & 1.9 \\end{bmatrix}$
Somme = $1.5 + 2.3 + 0.8 + 4.1 + 3.2 + 1.9 = 13.8$",
"id_category": "1",
"id_number": "29"
},
{
"category": "exercise",
"question": "Écrire un programme Pascal avec une procédure qui échange les valeurs de deux variables. Le programme doit lire deux entiers, les passer à la procédure qui les échange, puis afficher les valeurs échangées.",
"choices": [
"A Corrige Type"
],
"correct": [
"A"
],
"explanation": "Solution complète :
Programme Pascal :
program EchangeVariables;\n\nprocedure Echanger(var a, b : integer);\nvar\n temp : integer;\nbegin\n temp := a;\n a := b;\n b := temp;\nend;\n\nvar\n x, y : integer;\n\nbegin\n write('Entrez le premier entier x : ');\n readln(x);\n write('Entrez le second entier y : ');\n readln(y);\n \n writeln('Avant l''échange : x = ', x, ', y = ', y);\n \n Echanger(x, y);\n \n writeln('Après l''échange : x = ', x, ', y = ', y);\n \n readln;\nend.
Explication :
Procédure Echanger :
Paramètres de passage par référence ($var a, b$) pour modifier les variables originales
Technique d'échange :
- Sauvegarde $a$ dans une variable temporaire : $temp := a$
- Assigne la valeur de $b$ à $a$ : $a := b$
- Assigne la valeur temporaire à $b$ : $b := temp$
Passage par référence :
$var a, b$ permet à la procédure de modifier les variables passées en arguments
Appel de la procédure :
$Echanger(x, y)$ échange les valeurs de x et y
Exemple :
Avant l'échange : $x = 5$, $y = 3$
Après l'échange : $x = 3$, $y = 5$",
"id_category": "1",
"id_number": "30"
},
{
"category": "exercise",
"question": "Écrire un programme Pascal avec une fonction qui calcule et retourne le carré d'un nombre réel. Le programme doit lire un réel, l'envoyer à la fonction, puis afficher le résultat.",
"choices": [
"A Corrige Type"
],
"correct": [
"A"
],
"explanation": "Solution complète :
Programme Pascal :
program CalculCarré;\n\nfunction Carré(x : real) : real;\nbegin\n Carré := x * x;\nend;\n\nvar\n nombre, resultat : real;\n\nbegin\n write('Entrez un nombre réel : ');\n readln(nombre);\n \n resultat := Carré(nombre);\n \n writeln('Le carré de ', nombre:8:2, ' est ', resultat:8:2);\n \n readln;\nend.
Explication :
Définition de la fonction :
$function Carré(x : real) : real$ définit une fonction qui prend un réel et retourne un réel
Calcul et retour :
$Carré := x \\times x$ affecte le carré à la variable de fonction
Le nom de la fonction :
Le nom de la fonction est utilisé comme variable pour retourner le résultat
Appel de la fonction :
$resultat := Carré(nombre)$ appelle la fonction et stocke le résultat
Affichage formaté :
$nombre:8:2$ et $resultat:8:2$ affichent les réels avec 2 décimales
Exemple :
Saisie : $4.5$
Calcul : $4.5 \\times 4.5 = 20.25$
Affichage : Le carré de 4.50 est 20.25$",
"id_category": "1",
"id_number": "31"
},
{
"category": "exercise",
"question": "Écrire un programme Pascal avec une procédure qui reçoit un entier $n$ et affiche les $n$ premiers nombres de la suite de Fibonacci. La suite commence par 0 et 1, et chaque terme est la somme des deux précédents.",
"choices": [
"A Corrige Type"
],
"correct": [
"A"
],
"explanation": "Solution complète :
Programme Pascal :
program SuiteFibonacci;\n\nprocedure AfficheFibonacci(n : integer);\nvar\n i : integer;\n fib0, fib1, fib2 : longint;\nbegin\n if n <= 0 then\n writeln('Erreur : n doit être > 0')\n else if n = 1 then\n writeln('0')\n else\n begin\n fib0 := 0;\n fib1 := 1;\n write(fib0, ' ');\n write(fib1, ' ');\n \n for i := 3 to n do\n begin\n fib2 := fib0 + fib1;\n write(fib2, ' ');\n fib0 := fib1;\n fib1 := fib2;\n end;\n writeln;\n end;\nend;\n\nvar\n n : integer;\n\nbegin\n write('Entrez le nombre de termes (n) : ');\n readln(n);\n \n write('Les ', n, ' premiers termes de Fibonacci : ');\n AfficheFibonacci(n);\n \n readln;\nend.
Explication :
Suite de Fibonacci :
$F_0 = 0, F_1 = 1, F_n = F_{n-1} + F_{n-2}$ pour $n \\geq 2$
Variables :
- $fib0$ : le terme précédent
- $fib1$ : le terme actuel
- $fib2$ : le nouveau terme (somme des deux précédents)
Algorithme :
1. Afficher les deux premiers termes (0 et 1)
2. Boucle de 3 à $n$ : calculer chaque nouveau terme
3. Décaler les variables : $fib0 \\leftarrow fib1$ et $fib1 \\leftarrow fib2$
Exemple pour $n = 7$ :
Affichage : $0 1 1 2 3 5 8$
Vérification :
$0 + 1 = 1$, $1 + 1 = 2$, $1 + 2 = 3$, $2 + 3 = 5$, $3 + 5 = 8$",
"id_category": "1",
"id_number": "32"
},
{
"category": "exercise",
"question": "Écrire un programme Pascal qui demande à l'utilisateur de saisir un mot (chaîne de caractères), puis affiche le nombre de voyelles et le nombre de consonnes dans ce mot. Considérer les voyelles comme a, e, i, o, u (minuscules).",
"choices": [
"A Corrige Type"
],
"correct": [
"A"
],
"explanation": "Solution complète :
Programme Pascal :
program ComptageVoyelles;\nvar\n mot : string;\n i, voyelles, consonnes : integer;\n car : char;\n\nbegin\n write('Entrez un mot : ');\n readln(mot);\n \n voyelles := 0;\n consonnes := 0;\n \n for i := 1 to length(mot) do\n begin\n car := lowercase(mot[i]);\n \n if (car = 'a') or (car = 'e') or (car = 'i') or (car = 'o') or (car = 'u') then\n voyelles := voyelles + 1\n else if ((car >= 'a') and (car <= 'z')) then\n consonnes := consonnes + 1;\n end;\n \n writeln('Nombre de voyelles : ', voyelles);\n writeln('Nombre de consonnes : ', consonnes);\n \n readln;\nend.
Explication :
Variables :
- $mot$ : la chaîne de caractères saisie
- $i$ : compteur de la boucle
- $car$ : le caractère actuel
- $voyelles, consonnes$ : compteurs
Fonction length :
$length(mot)$ retourne le nombre de caractères du mot
Accès aux caractères :
$mot[i]$ accède au $i$-ème caractère du mot
Conversion en minuscules :
$lowercase(car)$ convertit le caractère en minuscule pour uniformiser
Identification :
- Voyelle : $car \\in \\{a, e, i, o, u\\}$
- Consonne : $car$ est une lettre mais pas une voyelle
Exemple pour mot = \"Algorithmique\" :
Caractères : A(voyelle), l(consonne), g(consonne), o(voyelle), r(consonne), i(voyelle), t(consonne), h(consonne), m(consonne), i(voyelle), q(consonne), u(voyelle), e(voyelle)
Affichage :
Nombre de voyelles : 6
Nombre de consonnes : 7$",
"id_category": "1",
"id_number": "33"
},
{
"category": "exercise",
"question": "Écrire un programme Pascal qui lit $n$ notes (réels entre 0 et 20), les stocke dans un tableau, puis calcule et affiche la moyenne, la note minimale et la note maximale.",
"choices": [
"A Corrige Type"
],
"correct": [
"A"
],
"explanation": "Solution complète :
Programme Pascal :
program StatistiquesNotes;\nconst\n MAX = 20;\nvar\n notes : array[1..MAX] of real;\n n, i : integer;\n somme, moyenne, minimum, maximum : real;\n\nbegin\n write('Entrez le nombre de notes (max 20) : ');\n readln(n);\n \n if n <= 0 or n > MAX then\n begin\n writeln('Erreur : nombre de notes invalide');\n end\n else\n begin\n writeln('Entrez les notes :');\n for i := 1 to n do\n begin\n write('Note ', i, ' : ');\n readln(notes[i]);\n end;\n \n somme := 0;\n for i := 1 to n do\n somme := somme + notes[i];\n \n moyenne := somme / n;\n \n minimum := notes[1];\n maximum := notes[1];\n for i := 2 to n do\n begin\n if notes[i] < minimum then\n minimum := notes[i];\n if notes[i] > maximum then\n maximum := notes[i];\n end;\n \n writeln('Moyenne : ', moyenne:8:2);\n writeln('Minimum : ', minimum:8:2);\n writeln('Maximum : ', maximum:8:2);\n end;\n \n readln;\nend.
Explication :
Calcul de la moyenne :
$moyenne = \\frac{\\sum_{i=1}^{n} notes[i]}{n}$
Recherche du minimum :
Initialiser $minimum = notes[1]$, puis comparer avec chaque note
Recherche du maximum :
Initialiser $maximum = notes[1]$, puis comparer avec chaque note
Boucles successives :
- Première boucle : accumulation pour la somme
- Deuxième boucle : recherche du minimum et maximum
Exemple pour $n = 5$ :
Notes : $15.5, 18.0, 12.5, 19.0, 16.5$
Somme : $81.5$
Moyenne : $16.30$
Minimum : $12.50$
Maximum : $19.00$",
"id_category": "1",
"id_number": "34"
},
{
"category": "exercise",
"question": "Écrire un programme Pascal avec une fonction qui vérifie si un nombre entier est un nombre premier. Le programme doit lire un entier et afficher s'il est premier ou non.",
"choices": [
"A Corrige Type"
],
"correct": [
"A"
],
"explanation": "Solution complète :
Programme Pascal :
program VerificationPremier;\n\nfunction EstPremier(n : integer) : boolean;\nvar\n i, limite : integer;\n premier : boolean;\nbegin\n if n <= 1 then\n premier := false\n else if n = 2 then\n premier := true\n else if n mod 2 = 0 then\n premier := false\n else\n begin\n premier := true;\n limite := round(sqrt(n));\n for i := 3 to limite do\n begin\n if n mod i = 0 then\n begin\n premier := false;\n i := limite + 1;\n end;\n end;\n end;\n EstPremier := premier;\nend;\n\nvar\n nombre : integer;\n\nbegin\n write('Entrez un entier n : ');\n readln(nombre);\n \n if EstPremier(nombre) then\n writeln(nombre, ' est un nombre PREMIER')\n else\n writeln(nombre, ' n''est PAS un nombre premier');\n \n readln;\nend.
Explication :
Définition de nombre premier :
Un nombre $n$ est premier si $n > 1$ et n'a aucun diviseur autre que 1 et lui-même
Cas particuliers :
- $n \\leq 1$ : pas premier
- $n = 2$ : premier
- $n$ pair : pas premier
Optimisation :
Vérifier les diviseurs seulement jusqu'à $\\sqrt{n}$ au lieu de jusqu'à $n$
Algorithme :
1. Si $n \\leq 1$ : pas premier
2. Si $n = 2$ : premier
3. Si $n$ est pair : pas premier
4. Vérifier les diviseurs impairs de 3 à $\\sqrt{n}$
5. Si diviseur trouvé : pas premier, sinon premier
Exemple pour $n = 17$ :
- $17 > 1$ : continue
- $17 \\mod 2 = 1$ : impair
- $\\sqrt{17} \\approx 4.1$, limite = 4
- Vérifier $17 \\mod 3 = 2$ (non divisible)
- Aucun diviseur trouvé
- Affichage : 17 est un nombre PREMIER$",
"id_category": "1",
"id_number": "35"
},
{
"category": "exercise",
"question": "Écrire un programme Pascal qui trie un tableau de $n$ entiers dans l'ordre croissant en utilisant l'algorithme de tri par sélection. Afficher le tableau avant et après le tri.",
"choices": [
"A Corrige Type"
],
"correct": [
"A"
],
"explanation": "Solution complète :
Programme Pascal :
program TriSélection;\nconst\n MAX = 20;\nvar\n tableau : array[1..MAX] of integer;\n n, i, j, min_idx, temp : integer;\n\nbegin\n write('Entrez la taille du tableau (max 20) : ');\n readln(n);\n \n if n <= 0 or n > MAX then\n begin\n writeln('Erreur : taille invalide');\n end\n else\n begin\n writeln('Remplissez le tableau :');\n for i := 1 to n do\n begin\n write('Élément ', i, ' : ');\n readln(tableau[i]);\n end;\n \n writeln('Tableau avant tri :');\n for i := 1 to n do\n write(tableau[i], ' ');\n writeln;\n \n for i := 1 to n - 1 do\n begin\n min_idx := i;\n for j := i + 1 to n do\n begin\n if tableau[j] < tableau[min_idx] then\n min_idx := j;\n end;\n \n temp := tableau[i];\n tableau[i] := tableau[min_idx];\n tableau[min_idx] := temp;\n end;\n \n writeln('Tableau après tri :');\n for i := 1 to n do\n write(tableau[i], ' ');\n writeln;\n end;\n \n readln;\nend.
Explication :
Algorithme de tri par sélection :
À chaque itération $i$, trouver l'indice du minimum dans $[i, n]$ et l'échanger avec l'élément à l'indice $i$
Étapes :
1. Pour chaque position $i$ de 1 à $n-1$
2. Trouver l'indice $min\\_idx$ du minimum dans $[i, n]$
3. Échanger $tableau[i]$ et $tableau[min\\_idx]$
Complexité :
Temps : $O(n^2)$ avec deux boucles imbriquées
Exemple pour $n = 5$ :
Avant tri : $[5, 2, 8, 1, 9]$
Itération 1 : min = 1 (indice 4), échange 5 et 1 → $[1, 2, 8, 5, 9]$
Itération 2 : min = 2 (indice 2), pas d'échange → $[1, 2, 8, 5, 9]$
Itération 3 : min = 5 (indice 4), échange 8 et 5 → $[1, 2, 5, 8, 9]$
Itération 4 : min = 8 (indice 4), pas d'échange → $[1, 2, 5, 8, 9]$
Après tri : $[1, 2, 5, 8, 9]$",
"id_category": "1",
"id_number": "36"
},
{
"category": "exercise",
"question": "Écrire un programme Pascal qui implémente une procédure pour calculer le PGCD (Plus Grand Commun Diviseur) de deux entiers positifs en utilisant l'algorithme d'Euclide.",
"choices": [
"A Corrige Type"
],
"correct": [
"A"
],
"explanation": "Solution complète :
Programme Pascal :
program CalculPGCD;\n\nprocedure CalculerPGCD(a, b : integer; var pgcd : integer);\nbegin\n while b <> 0 do\n begin\n pgcd := a mod b;\n a := b;\n b := pgcd;\n end;\n pgcd := a;\nend;\n\nvar\n x, y, resultat : integer;\n\nbegin\n write('Entrez le premier entier x : ');\n readln(x);\n write('Entrez le second entier y : ');\n readln(y);\n \n if (x <= 0) or (y <= 0) then\n writeln('Erreur : les entiers doivent être positifs')\n else\n begin\n CalculerPGCD(x, y, resultat);\n writeln('PGCD(', x, ', ', y, ') = ', resultat);\n end;\n \n readln;\nend.
Explication :
Algorithme d'Euclide :
$\\begin{align}\nPGCD(a, b) &= PGCD(b, a \\mod b) \\text{ si } b \\neq 0 \\\\\nPGCD(a, 0) &= a\n\\end{align}$
Principe :
Répéter : remplacer $a$ par $b$ et $b$ par $a \\mod b$ jusqu'à $b = 0$
Variables locales :
- $a, b$ : les entiers
- $pgcd$ : résultat (passage par référence)
Boucle while :
Tant que $b \\neq 0$ :
- Calculer $pgcd := a \\mod b$
- Mettre à jour $a := b$ et $b := pgcd$
Exemple pour $a = 48$, $b = 18$ :
$48 \\mod 18 = 12$, $a = 18$, $b = 12$
$18 \\mod 12 = 6$, $a = 12$, $b = 6$
$12 \\mod 6 = 0$, $a = 6$, $b = 0$
PGCD = $6$",
"id_category": "1",
"id_number": "37"
},
{
"category": "exercise",
"question": "Écrire un programme Pascal qui lit $n$ nombres entiers et utilise une procédure pour afficher les nombres et une fonction pour calculer le plus grand d'entre eux, puis affiche ce maximum.",
"choices": [
"A Corrige Type"
],
"correct": [
"A"
],
"explanation": "Solution complète :
Programme Pascal :
program MaximumNombres;\nconst\n MAX = 15;\n\nprocedure AfficherTableau(tableau : array of integer; n : integer);\nvar\n i : integer;\nbegin\n write('Nombres saisis : ');\n for i := 1 to n do\n write(tableau[i], ' ');\n writeln;\nend;\n\nfunction TrouverMaximum(tableau : array of integer; n : integer) : integer;\nvar\n i : integer;\n max : integer;\nbegin\n max := tableau[1];\n for i := 2 to n do\n begin\n if tableau[i] > max then\n max := tableau[i];\n end;\n TrouverMaximum := max;\nend;\n\nvar\n nombres : array[1..MAX] of integer;\n n, i, maximum : integer;\n\nbegin\n write('Entrez le nombre d''entiers (max 15) : ');\n readln(n);\n \n if n <= 0 or n > MAX then\n writeln('Erreur : nombre invalide')\n else\n begin\n writeln('Entrez les ', n, ' entiers :');\n for i := 1 to n do\n begin\n write('Nombre ', i, ' : ');\n readln(nombres[i]);\n end;\n \n AfficherTableau(nombres, n);\n \n maximum := TrouverMaximum(nombres, n);\n \n writeln('Le maximum est : ', maximum);\n end;\n \n readln;\nend.
Explication :
Procédure AfficherTableau :
Affiche tous les éléments du tableau passé en paramètre
Fonction TrouverMaximum :
- Initialiser $max = tableau[1]$
- Parcourir le tableau de 2 à $n$
- Comparer chaque élément avec $max$
- Retourner le maximum
Modularité :
Le programme utilise deux sous-programmes pour séparer les responsabilités
Appels des sous-programmes :
- $AfficherTableau(nombres, n)$ affiche le tableau
- $maximum := TrouverMaximum(nombres, n)$ récupère le maximum
Exemple pour $n = 4$ :
Entiers saisis : 7, 3, 9, 2
Affichage : Nombres saisis : 7 3 9 2
Maximum : 9$",
"id_category": "1",
"id_number": "38"
},
{
"category": "exercise",
"question": "Écrire un programme Pascal qui utilise une fonction pour vérifier si une année est bissextile. Une année est bissextile si elle est divisible par 4 et non par 100, ou si elle est divisible par 400. Afficher le résultat.",
"choices": [
"A Corrige Type"
],
"correct": [
"A"
],
"explanation": "Solution complète :
Programme Pascal :
program VerificationBissextile;\n\nfunction EstBissextile(année : integer) : boolean;\nbegin\n if (année mod 400 = 0) then\n EstBissextile := true\n else if (année mod 100 = 0) then\n EstBissextile := false\n else if (année mod 4 = 0) then\n EstBissextile := true\n else\n EstBissextile := false;\nend;\n\nvar\n annee : integer;\n\nbegin\n write('Entrez une année : ');\n readln(annee);\n \n if annee <= 0 then\n writeln('Erreur : l''année doit être positive')\n else\n begin\n if EstBissextile(annee) then\n writeln(annee, ' est une année BISSEXTILE')\n else\n writeln(annee, ' n''est PAS une année bissextile');\n end;\n \n readln;\nend.
Explication :
Règle de bissextilité :
Une année $A$ est bissextile si et seulement si :
- $A \\mod 400 = 0$ (divisible par 400), OU
- $A \\mod 4 = 0$ ET $A \\mod 100 \\neq 0$ (divisible par 4 mais pas par 100)
Ordre de vérification (prioritaire au moins prioritaire) :
1. Divisible par 400 → bissextile
2. Divisible par 100 → pas bissextile
3. Divisible par 4 → bissextile
4. Sinon → pas bissextile
Fonction retournant un booléen :
$EstBissextile := true$ ou $EstBissextile := false$
Exemples :
- 2000 : $2000 \\mod 400 = 0$ → BISSEXTILE
- 1900 : $1900 \\mod 400 \\neq 0$ mais $1900 \\mod 100 = 0$ → pas bissextile
- 2004 : $2004 \\mod 400 \\neq 0$, $2004 \\mod 100 \\neq 0$, $2004 \\mod 4 = 0$ → BISSEXTILE
- 2001 : $2001 \\mod 4 \\neq 0$ → pas bissextile$",
"id_category": "1",
"id_number": "39"
},
{
"category": "exercise",
"question": "Écrire un programme Pascal qui remplit deux tableaux de $n$ réels chacun, puis utilise une procédure pour calculer la somme élément par élément et stocker les résultats dans un troisième tableau. Afficher les trois tableaux.",
"choices": [
"A Corrige Type"
],
"correct": [
"A"
],
"explanation": "Solution complète :
Programme Pascal :
program SommeTableaux;\nconst\n MAX = 10;\n\nprocedure SommerTableaux(tab1, tab2 : array of real; var tab3 : array of real; n : integer);\nvar\n i : integer;\nbegin\n for i := 1 to n do\n tab3[i] := tab1[i] + tab2[i];\nend;\n\nprocedure AfficherTableau(tab : array of real; n : integer; nom : string);\nvar\n i : integer;\nbegin\n write(nom, ' : ');\n for i := 1 to n do\n write(tab[i]:8:2, ' ');\n writeln;\nend;\n\nvar\n tableau1, tableau2, tableau3 : array[1..MAX] of real;\n n, i : integer;\n\nbegin\n write('Entrez la taille des tableaux (max 10) : ');\n readln(n);\n \n if n <= 0 or n > MAX then\n writeln('Erreur : taille invalide')\n else\n begin\n writeln('Remplissez le tableau 1 :');\n for i := 1 to n do\n begin\n write('Élément ', i, ' : ');\n readln(tableau1[i]);\n end;\n \n writeln('Remplissez le tableau 2 :');\n for i := 1 to n do\n begin\n write('Élément ', i, ' : ');\n readln(tableau2[i]);\n end;\n \n SommerTableaux(tableau1, tableau2, tableau3, n);\n \n writeln('Résultats :');\n AfficherTableau(tableau1, n, 'Tableau 1');\n AfficherTableau(tableau2, n, 'Tableau 2');\n AfficherTableau(tableau3, n, 'Somme');\n end;\n \n readln;\nend.
Explication :
Procédure SommerTableaux :
Calcule $tab3[i] = tab1[i] + tab2[i]$ pour chaque indice $i$
Procédure AfficherTableau :
Affiche un tableau avec un nom et un formatage des réels
Passage de paramètres :
- Les tableaux 1 et 2 en lecture (passage par valeur)
- Le tableau 3 en modification (passage par variable/référence)
Calcul élément par élément :
Pour chaque position $i$ de 1 à $n$ :
$tab3[i] = tab1[i] + tab2[i]$
Exemple pour $n = 3$ :
Tableau 1 : $[1.5, 2.3, 0.8]$
Tableau 2 : $[2.5, 1.7, 3.2]$
Somme : $[4.0, 4.0, 4.0]$",
"id_category": "1",
"id_number": "40"
},
{
"category": "exercise",
"question": "Écrire un programme Pascal avec une fonction qui compte le nombre de diviseurs d'un entier $n$. Le programme doit lire un entier et afficher le nombre total de ses diviseurs.",
"choices": [
"A Corrige Type"
],
"correct": [
"A"
],
"explanation": "Solution complète :
Programme Pascal :
program CompteurDiviseurs;\n\nfunction CompterDiviseurs(n : integer) : integer;\nvar\n i, compteur : integer;\nbegin\n compteur := 0;\n for i := 1 to n do\n begin\n if n mod i = 0 then\n compteur := compteur + 1;\n end;\n CompterDiviseurs := compteur;\nend;\n\nvar\n nombre, nbDiviseurs : integer;\n\nbegin\n write('Entrez un entier positif n : ');\n readln(nombre);\n \n if nombre <= 0 then\n writeln('Erreur : n doit être positif')\n else\n begin\n nbDiviseurs := CompterDiviseurs(nombre);\n writeln('Nombre de diviseurs de ', nombre, ' : ', nbDiviseurs);\n end;\n \n readln;\nend.
Explication :
Fonction CompterDiviseurs :
Parcourt tous les entiers de 1 à $n$ et compte ceux qui divisent $n$
Condition de divisibilité :
$n \\mod i = 0$ teste si $i$ divise $n$
Compteur :
Incrémenter compteur à chaque diviseur trouvé
Valeur retournée :
Le nombre total de diviseurs
Exemple pour $n = 12$ :
Diviseurs : 1, 2, 3, 4, 6, 12
Nombre de diviseurs : 6
Exemple pour $n = 7$ (nombre premier) :
Diviseurs : 1, 7
Nombre de diviseurs : 2$",
"id_category": "1",
"id_number": "41"
},
{
"category": "exercise",
"question": "Écrire un programme Pascal qui génère et affiche les $n$ premiers nombres parfaits (un nombre est parfait s'il est égal à la somme de ses diviseurs, sauf lui-même). Utiliser une fonction pour vérifier si un nombre est parfait.",
"choices": [
"A Corrige Type"
],
"correct": [
"A"
],
"explanation": "Solution complète :
Programme Pascal :
program NombresPaifaits;\n\nfunction SommeDiviseurs(n : integer) : integer;\nvar\n i, somme : integer;\nbegin\n somme := 0;\n for i := 1 to n div 2 do\n begin\n if n mod i = 0 then\n somme := somme + i;\n end;\n SommeDiviseurs := somme;\nend;\n\nfunction EstParfait(n : integer) : boolean;\nbegin\n EstParfait := (SommeDiviseurs(n) = n);\nend;\n\nvar\n nombre, compte : integer;\n\nbegin\n writeln('Les nombres parfaits jusqu''à 10000 :');\n compte := 0;\n nombre := 1;\n \n while (nombre <= 10000) and (compte < 5) do\n begin\n if EstParfait(nombre) then\n begin\n compte := compte + 1;\n writeln('Nombre parfait ', compte, ' : ', nombre);\n end;\n nombre := nombre + 1;\n end;\n \n if compte = 0 then\n writeln('Aucun nombre parfait trouvé');\n \n readln;\nend.
Explication :
Définition nombre parfait :
Un nombre $n$ est parfait si $n = \\sum_{d|n, d
Fonction SommeDiviseurs :
Calcule la somme de tous les diviseurs propres (sauf lui-même)
- Parcourir de 1 à $n/2$
- Ajouter $i$ si $n \\mod i = 0$
Fonction EstParfait :
Vérifie si la somme des diviseurs propres égale $n$
Boucle de recherche :
- Parcourir les nombres jusqu'à 10000
- Vérifier chaque nombre
- Arrêter après avoir trouvé 5 nombres parfaits
Exemples de nombres parfaits :
$6 = 1 + 2 + 3$
$28 = 1 + 2 + 4 + 7 + 14$
$496 = 1 + 2 + 4 + 8 + 16 + 31 + 62 + 124 + 248$
$8128$",
"id_category": "1",
"id_number": "42"
},
{
"category": "exercise",
"question": "Écrire un programme Pascal qui implémente une recherche dichotomique (binaire) pour trouver un élément dans un tableau trié de $n$ entiers. Le programme doit lire l'élément à chercher et afficher son indice s'il est trouvé, sinon afficher un message d'erreur.",
"choices": [
"A Corrige Type"
],
"correct": [
"A"
],
"explanation": "Solution complète :
Programme Pascal :
program RechercheDichotomique;\nconst\n MAX = 20;\nvar\n tableau : array[1..MAX] of integer;\n n, element, position : integer;\n trouve : boolean;\n\nprocedure RechercheDicho(tab : array of integer; n, elem : integer; var pos : integer; var found : boolean);\nvar\n bas, haut, milieu : integer;\nbegin\n bas := 1;\n haut := n;\n found := false;\n pos := -1;\n \n while bas <= haut do\n begin\n milieu := (bas + haut) div 2;\n \n if tab[milieu] = elem then\n begin\n found := true;\n pos := milieu;\n bas := haut + 1;\n end\n else if tab[milieu] < elem then\n bas := milieu + 1\n else\n haut := milieu - 1;\n end;\nend;\n\nbegin\n write('Entrez la taille du tableau trié (max 20) : ');\n readln(n);\n \n if n <= 0 or n > MAX then\n writeln('Erreur : taille invalide')\n else\n begin\n writeln('Entrez les ', n, ' entiers triés en ordre croissant :');\n for position := 1 to n do\n begin\n write('Élément ', position, ' : ');\n readln(tableau[position]);\n end;\n \n write('Entrez l''élément à chercher : ');\n readln(element);\n \n RechercheDicho(tableau, n, element, position, trouve);\n \n if trouve then\n writeln('Élément trouvé à l''indice ', position)\n else\n writeln('Élément non trouvé dans le tableau');\n end;\n \n readln;\nend.
Explication :
Procédure RechercheDicho :
Implémente l'algorithme dichotomique
Variables limites :
- $bas = 1$ : borne inférieure
- $haut = n$ : borne supérieure
- $milieu = (bas + haut) \\div 2$ : point de division
Trois cas :
1. Si $tab[milieu] = elem$ : élément trouvé
2. Si $tab[milieu] < elem$ : chercher dans $[milieu+1, haut]$
3. Si $tab[milieu] > elem$ : chercher dans $[bas, milieu-1]$
Conditions d'arrêt :
- Élément trouvé ou $bas > haut$
Exemple pour tableau $[1, 3, 5, 7, 9, 11, 13]$ et élément $7$ :
Itération 1 : $bas=1, haut=7, milieu=4, tab[4]=7 \\Rightarrow trouvé à l'indice 4$",
"id_category": "1",
"id_number": "43"
},
{
"category": "exercise",
"question": "Écrire un programme Pascal qui utilise une procédure pour inverser les éléments d'un tableau de $n$ entiers, puis affiche le tableau avant et après inversion.",
"choices": [
"A Corrige Type"
],
"correct": [
"A"
],
"explanation": "Solution complète :
Programme Pascal :
program InversionTableau;\nconst\n MAX = 15;\nvar\n tableau : array[1..MAX] of integer;\n n, i : integer;\n\nprocedure InverserTableau(var tab : array of integer; n : integer);\nvar\n i, j, temp : integer;\nbegin\n i := 1;\n j := n;\n \n while i < j do\n begin\n temp := tab[i];\n tab[i] := tab[j];\n tab[j] := temp;\n \n i := i + 1;\n j := j - 1;\n end;\nend;\n\nprocedure AfficherTableau(tab : array of integer; n : integer);\nvar\n i : integer;\nbegin\n for i := 1 to n do\n write(tab[i], ' ');\n writeln;\nend;\n\nbegin\n write('Entrez la taille du tableau (max 15) : ');\n readln(n);\n \n if n <= 0 or n > MAX then\n writeln('Erreur : taille invalide')\n else\n begin\n writeln('Entrez les ', n, ' entiers :');\n for i := 1 to n do\n begin\n write('Élément ', i, ' : ');\n readln(tableau[i]);\n end;\n \n write('Tableau avant inversion : ');\n AfficherTableau(tableau, n);\n \n InverserTableau(tableau, n);\n \n write('Tableau après inversion : ');\n AfficherTableau(tableau, n);\n end;\n \n readln;\nend.
Explication :
Procédure InverserTableau :
Utilise deux pointeurs qui convergent vers le centre du tableau
Algorithme d'inversion :
- $i$ commence à 1 (premier élément)
- $j$ commence à $n$ (dernier élément)
- Échanger $tab[i]$ et $tab[j]$
- Incrémenter $i$ et décrémenter $j$
- Arrêter quand $i \\geq j$
Procédure AfficherTableau :
Affiche tous les éléments du tableau
Exemple pour $n = 5$ :
Avant : $[1, 2, 3, 4, 5]$
Après : $[5, 4, 3, 2, 1]$",
"id_category": "1",
"id_number": "44"
},
{
"category": "exercise",
"question": "Écrire un programme Pascal qui calcule l'intersection de deux tableaux d'entiers (éléments communs). Utiliser une fonction booléenne pour vérifier si un élément existe dans un tableau.",
"choices": [
"A Corrige Type"
],
"correct": [
"A"
],
"explanation": "Solution complète :
Programme Pascal :
program IntersectionTableaux;\nconst\n MAX = 10;\nvar\n tab1, tab2, intersection : array[1..MAX] of integer;\n n1, n2, nIntersection, i, j : integer;\n\nfunction ElementExiste(tab : array of integer; n, elem : integer) : boolean;\nvar\n i : integer;\n trouve : boolean;\nbegin\n trouve := false;\n for i := 1 to n do\n begin\n if tab[i] = elem then\n begin\n trouve := true;\n i := n + 1;\n end;\n end;\n ElementExiste := trouve;\nend;\n\nprocedure RemplirTableau(var tab : array of integer; var n : integer; max : integer);\nvar\n i : integer;\nbegin\n write('Entrez la taille du tableau (max ', max, ') : ');\n readln(n);\n \n if n > 0 and n <= max then\n begin\n for i := 1 to n do\n begin\n write('Élément ', i, ' : ');\n readln(tab[i]);\n end;\n end\n else\n n := 0;\nend;\n\nbegin\n writeln('Remplissage du premier tableau :');\n RemplirTableau(tab1, n1, MAX);\n \n writeln('Remplissage du second tableau :');\n RemplirTableau(tab2, n2, MAX);\n \n nIntersection := 0;\n \n for i := 1 to n1 do\n begin\n if ElementExiste(tab2, n2, tab1[i]) then\n begin\n nIntersection := nIntersection + 1;\n intersection[nIntersection] := tab1[i];\n end;\n end;\n \n if nIntersection = 0 then\n writeln('Les tableaux n''ont pas d''éléments communs')\n else\n begin\n write('Intersection : ');\n for i := 1 to nIntersection do\n write(intersection[i], ' ');\n writeln;\n end;\n \n readln;\nend.
Explication :
Fonction ElementExiste :
Vérifie si un élément apparaît dans un tableau
Algorithme d'intersection :
Pour chaque élément $tab1[i]$ du premier tableau :
- Vérifier s'il existe dans le second tableau
- Si oui, l'ajouter au tableau intersection
Procédure RemplirTableau :
Remplir un tableau de manière modulaire
Exemple :
Tab1 = $[1, 2, 3, 4, 5]$
Tab2 = $[3, 4, 5, 6, 7]$
Intersection = $[3, 4, 5]$",
"id_category": "1",
"id_number": "45"
},
{
"category": "exercise",
"question": "Écrire un programme Pascal qui utilise une procédure pour fusionner deux tableaux triés d'entiers en un seul tableau trié. Afficher les trois tableaux.",
"choices": [
"A Corrige Type"
],
"correct": [
"A"
],
"explanation": "Solution complète :
Programme Pascal :
program FusionTableaux;\nconst\n MAX = 10;\nvar\n tab1, tab2, fusion : array[1..2*MAX] of integer;\n n1, n2, nFusion, i : integer;\n\nprocedure FusionnerTrié(tab1 : array of integer; n1 : integer; tab2 : array of integer; n2 : integer; var fusion : array of integer; var nF : integer);\nvar\n i, j, k : integer;\nbegin\n i := 1;\n j := 1;\n k := 1;\n nF := 0;\n \n while (i <= n1) and (j <= n2) do\n begin\n if tab1[i] <= tab2[j] then\n begin\n fusion[k] := tab1[i];\n i := i + 1;\n end\n else\n begin\n fusion[k] := tab2[j];\n j := j + 1;\n end;\n k := k + 1;\n end;\n \n while i <= n1 do\n begin\n fusion[k] := tab1[i];\n i := i + 1;\n k := k + 1;\n end;\n \n while j <= n2 do\n begin\n fusion[k] := tab2[j];\n j := j + 1;\n k := k + 1;\n end;\n \n nF := k - 1;\nend;\n\nprocedure AfficherTableau(tab : array of integer; n : integer; nom : string);\nvar\n i : integer;\nbegin\n write(nom, ' : ');\n for i := 1 to n do\n write(tab[i], ' ');\n writeln;\nend;\n\nbegin\n writeln('Remplissage du premier tableau trié :');\n write('Taille : ');\n readln(n1);\n for i := 1 to n1 do\n begin\n write('Élément ', i, ' : ');\n readln(tab1[i]);\n end;\n \n writeln('Remplissage du second tableau trié :');\n write('Taille : ');\n readln(n2);\n for i := 1 to n2 do\n begin\n write('Élément ', i, ' : ');\n readln(tab2[i]);\n end;\n \n FusionnerTrié(tab1, n1, tab2, n2, fusion, nFusion);\n \n AfficherTableau(tab1, n1, 'Tableau 1');\n AfficherTableau(tab2, n2, 'Tableau 2');\n AfficherTableau(fusion, nFusion, 'Fusion');\n \n readln;\nend.
Explication :
Procédure FusionnerTrié :
Fusionne deux tableaux triés en maintenant l'ordre croissant
Trois phases :
1. Comparer les éléments des deux tableaux
- Si $tab1[i] \\leq tab2[j]$, ajouter $tab1[i]$
- Sinon, ajouter $tab2[j]$
2. Ajouter les éléments restants de tab1
3. Ajouter les éléments restants de tab2
Complexité :
Temps : $O(n_1 + n_2)$
Exemple :
Tab1 = $[1, 3, 5, 7]$
Tab2 = $[2, 4, 6, 8]$
Fusion = $[1, 2, 3, 4, 5, 6, 7, 8]$",
"id_category": "1",
"id_number": "46"
},
{
"category": "exercise",
"question": "Écrire un programme Pascal qui utilise une fonction pour calculer le plus petit élément commun multiple (PPCM) de deux entiers positifs. Le programme doit lire deux entiers et afficher leur PPCM.",
"choices": [
"A Corrige Type"
],
"correct": [
"A"
],
"explanation": "Solution complète :
Programme Pascal :
program CalculPPCM;\n\nfunction CalculerPGCD(a, b : integer) : integer;\nbegin\n while b <> 0 do\n begin\n a := a mod b;\n if a = 0 then\n CalculerPGCD := b\n else\n begin\n b := b mod a;\n if b = 0 then\n CalculerPGCD := a\n else\n a := a mod b;\n end;\n end;\n CalculerPGCD := a;\nend;\n\nfunction CalculerPPCM(a, b : integer) : longint;\nvar\n pgcd : integer;\nbegin\n pgcd := CalculerPGCD(a, b);\n CalculerPPCM := longint(a) * longint(b) div longint(pgcd);\nend;\n\nvar\n x, y : integer;\n ppcm : longint;\n\nbegin\n write('Entrez le premier entier x : ');\n readln(x);\n write('Entrez le second entier y : ');\n readln(y);\n \n if (x <= 0) or (y <= 0) then\n writeln('Erreur : les entiers doivent être positifs')\n else\n begin\n ppcm := CalculerPPCM(x, y);\n writeln('PPCM(', x, ', ', y, ') = ', ppcm);\n end;\n \n readln;\nend.
Explication :
Formule du PPCM :
$PPCM(a, b) = \\frac{a \\times b}{PGCD(a, b)}$
Fonction CalculerPGCD :
Calcule le PGCD en utilisant l'algorithme d'Euclide
Fonction CalculerPPCM :
- Calcule d'abord le PGCD
- Applique la formule : $PPCM = \\frac{a \\times b}{PGCD}$
- Utilise longint pour éviter les débordements
Exemple pour $a = 12$, $b = 18$ :
PGCD(12, 18) = 6
PPCM(12, 18) = $\\frac{12 \\times 18}{6} = \\frac{216}{6} = 36$
Vérification :
Multiples de 12 : 12, 24, 36, 48, ...
Multiples de 18 : 18, 36, 54, ...
Plus petit multiple commun : 36$",
"id_category": "1",
"id_number": "47"
},
{
"category": "exercise",
"question": "Écrire un programme Pascal qui utilise une procédure pour calculer les statistiques (moyenne, variance, écart-type) d'un tableau de $n$ réels. Afficher tous les résultats.",
"choices": [
"A Corrige Type"
],
"correct": [
"A"
],
"explanation": "Solution complète :
Programme Pascal :
program StatistiquesAvancées;\nconst\n MAX = 20;\nvar\n donnees : array[1..MAX] of real;\n n : integer;\n\nprocedure CalculerStatistiques(tab : array of real; n : integer; var moyenne, variance, ecartType : real);\nvar\n i : integer;\n somme, sommeCarre : real;\nbegin\n somme := 0;\n sommeCarre := 0;\n \n for i := 1 to n do\n somme := somme + tab[i];\n \n moyenne := somme / n;\n \n for i := 1 to n do\n sommeCarre := sommeCarre + sqr(tab[i] - moyenne);\n \n variance := sommeCarre / n;\n ecartType := sqrt(variance);\nend;\n\nbegin\n write('Entrez le nombre de données (max 20) : ');\n readln(n);\n \n if n <= 0 or n > MAX then\n writeln('Erreur : nombre invalide')\n else\n begin\n writeln('Entrez les ', n, ' données réelles :');\n for i := 1 to n do\n begin\n write('Donnée ', i, ' : ');\n readln(donnees[i]);\n end;\n \n CalculerStatistiques(donnees, n, moyenne, variance, ecartType);\n \n writeln('Résultats statistiques :');\n writeln('Moyenne : ', moyenne:8:2);\n writeln('Variance : ', variance:8:2);\n writeln('Écart-type : ', ecartType:8:2);\n end;\n \n readln;\nend.
Explication :
Formules statistiques :
$\\text{Moyenne} = \\frac{\\sum_{i=1}^{n} x_i}{n}$
$\\text{Variance} = \\frac{\\sum_{i=1}^{n} (x_i - \\text{Moyenne})^2}{n}$
$\\text{Écart-type} = \\sqrt{\\text{Variance}}$
Étapes :
1. Calculer la somme de tous les éléments
2. Calculer la moyenne
3. Calculer la somme des carrés des écarts à la moyenne
4. Calculer la variance
5. Calculer l'écart-type (racine carrée de la variance)
Exemple pour données = [2, 4, 6, 8, 10] :
Somme = 30
Moyenne = 6
Écarts : -4, -2, 0, 2, 4
Carrés des écarts : 16, 4, 0, 4, 16
Somme des carrés = 40
Variance = 8
Écart-type ≈ 2.83$",
"id_category": "1",
"id_number": "48"
},
{
"category": "exercise",
"question": "Écrire un programme Pascal qui génère les $n$ premiers nombres de la suite de Syracuse (Collatz). La suite est définie par : si $n$ est pair, $n \\leftarrow n/2$, sinon $n \\leftarrow 3n+1$. La suite s'arrête quand elle atteint 1.",
"choices": [
"A Corrige Type"
],
"correct": [
"A"
],
"explanation": "Solution complète :
Programme Pascal :
program SuiteSyracuse;\n\nprocedure AfficheSyracuse(n : integer);\nvar\n etape : integer;\nbegin\n writeln('Suite de Syracuse pour n = ', n, ' :');\n etape := 0;\n \n while n <> 1 do\n begin\n write(n, ' ');\n etape := etape + 1;\n \n if etape mod 10 = 0 then\n writeln;\n \n if n mod 2 = 0 then\n n := n div 2\n else\n n := 3 * n + 1;\n end;\n \n writeln(1);\n writeln('Nombre total d''étapes : ', etape);\nend;\n\nvar\n nombre : integer;\n\nbegin\n write('Entrez un entier positif : ');\n readln(nombre);\n \n if nombre <= 0 then\n writeln('Erreur : entrez un entier positif')\n else\n AfficheSyracuse(nombre);\n \n readln;\nend.
Explication :
Suite de Syracuse (Collatz) :
Conjecture : toute suite de Syracuse finit par atteindre 1
Règles :
- Si $n$ est pair : $n \\leftarrow \\frac{n}{2}$
- Si $n$ est impair : $n \\leftarrow 3n + 1$
- Arrêt : quand $n = 1$
Algorithme :
1. Afficher le nombre courant
2. Si $n \\mod 2 = 0$ : diviser par 2
3. Sinon : multiplier par 3 et ajouter 1
4. Répéter jusqu'à $n = 1$
Exemple pour $n = 10$ :
10 → 5 → 16 → 8 → 4 → 2 → 1
Nombre d'étapes : 6
Exemple pour $n = 27$ :
Suite plus longue avec plusieurs montées et descentes
Nombre d'étapes : 111$",
"id_category": "1",
"id_number": "49"
},
{
"category": "exercise",
"question": "Écrire un programme Pascal qui utilise une fonction récursive pour calculer la somme des chiffres d'un nombre entier positif. Le programme doit lire un entier et afficher la somme de ses chiffres.",
"choices": [
"A Corrige Type"
],
"correct": [
"A"
],
"explanation": "Solution complète :
Programme Pascal :
program SommeChiffres;\n\nfunction SommeChiffresRec(n : integer) : integer;\nbegin\n if n < 10 then\n SommeChiffresRec := n\n else\n SommeChiffresRec := (n mod 10) + SommeChiffresRec(n div 10);\nend;\n\nvar\n nombre, somme : integer;\n\nbegin\n write('Entrez un entier positif : ');\n readln(nombre);\n \n if nombre < 0 then\n writeln('Erreur : entrez un entier positif')\n else\n begin\n somme := SommeChiffresRec(nombre);\n writeln('Somme des chiffres de ', nombre, ' : ', somme);\n end;\n \n readln;\nend.
Explication :
Fonction récursive :
Décompose le nombre progressivement
Cas de base :
Si $n < 10$ (un seul chiffre), retourner $n$
Cas récursif :
$SommeChiffres(n) = (n \\mod 10) + SommeChiffres(n \\div 10)$
Extraction des chiffres :
- $n \\mod 10$ : dernier chiffre
- $n \\div 10$ : nombre sans le dernier chiffre
Trace pour $n = 1234$ :
SommeChiffres(1234)
= 4 + SommeChiffres(123)
= 4 + 3 + SommeChiffres(12)
= 4 + 3 + 2 + SommeChiffres(1)
= 4 + 3 + 2 + 1
= 10$",
"id_category": "1",
"id_number": "50"
},
{
"category": "exercise",
"question": "Écrire un programme Pascal qui utilise une fonction pour déterminer si une chaîne de caractères est un palindrome. Le programme doit lire une chaîne et afficher si elle est palindrome ou non.",
"choices": [
"A Corrige Type"
],
"correct": [
"A"
],
"explanation": "Solution complète :
Programme Pascal :
program VerificationPalindrome;\n\nfunction EstPalindrome(s : string) : boolean;\nvar\n i, n : integer;\n estPalin : boolean;\nbegin\n n := length(s);\n estPalin := true;\n i := 1;\n \n while (i <= n div 2) and estPalin do\n begin\n if lowercase(s[i]) <> lowercase(s[n - i + 1]) then\n estPalin := false;\n i := i + 1;\n end;\n \n EstPalindrome := estPalin;\nend;\n\nprocedure NettoierChaîne(var s : string);\nvar\n i, j, n : integer;\n temp : string;\nbegin\n temp := '';\n n := length(s);\n \n for i := 1 to n do\n begin\n if s[i] <> ' ' then\n temp := temp + s[i];\n end;\n \n s := temp;\nend;\n\nvar\n texte : string;\n\nbegin\n write('Entrez une chaîne de caractères : ');\n readln(texte);\n \n NettoierChaîne(texte);\n \n if EstPalindrome(texte) then\n writeln('\"', texte, '\" est un PALINDROME')\n else\n writeln('\"', texte, '\" n''est PAS un palindrome');\n \n readln;\nend.
Explication :
Définition palindrome :
Une chaîne qui se lit de la même manière de gauche à droite et de droite à gauche
Fonction EstPalindrome :
Compare les caractères symétriques
Algorithme :
- $n = length(s)$ : longueur de la chaîne
- Pour $i$ de 1 à $n \\div 2$ :
- Vérifier si $s[i] = s[n - i + 1]$
- Ignorer la casse avec lowercase
Procédure NettoierChaîne :
Supprime les espaces pour améliorer la détection
Exemples :
- \"radar\" → PALINDROME
- \"elu par cette crapule\" → \"eluparcettecrapule\" → PALINDROME (après nettoyage)
- \"bonjour\" → pas palindrome
Complexité :
Temps : $O(n)$ où $n$ est la longueur de la chaîne$",
"id_category": "1",
"id_number": "51"
},
{
"category": "exercise",
"question": "Écrire un programme Pascal qui utilise une procédure pour effectuer une recherche et remplace tous les caractères d'une chaîne. Le programme doit lire une chaîne, un caractère à chercher et son remplacement, puis afficher la chaîne modifiée.",
"choices": [
"A Corrige Type"
],
"correct": [
"A"
],
"explanation": "Solution complète :
Programme Pascal :
program RechercheRemplacement;\n\nprocedure RemplacerCaractères(var s : string; ancienCar, nouveauCar : char);\nvar\n i, nb : integer;\nbegin\n nb := 0;\n \n for i := 1 to length(s) do\n begin\n if s[i] = ancienCar then\n begin\n s[i] := nouveauCar;\n nb := nb + 1;\n end;\n end;\n \n writeln('Nombre de remplacements effectués : ', nb);\nend;\n\nvar\n texte : string;\n ancienCar, nouveauCar : char;\n\nbegin\n write('Entrez une chaîne de caractères : ');\n readln(texte);\n \n write('Entrez le caractère à chercher : ');\n readln(ancienCar);\n \n write('Entrez le caractère de remplacement : ');\n readln(nouveauCar);\n \n writeln('Chaîne avant remplacement : ', texte);\n \n RemplacerCaractères(texte, ancienCar, nouveauCar);\n \n writeln('Chaîne après remplacement : ', texte);\n \n readln;\nend.
Explication :
Procédure RemplacerCaractères :
Parcourt la chaîne et remplace tous les caractères correspondants
Algorithme :
1. Pour chaque position $i$ dans la chaîne
2. Si $s[i] = ancienCar$ :
- Remplacer par $nouveauCar$
- Incrémenter le compteur
Passage par référence :
La procédure reçoit $var s$ pour modifier la chaîne originale
Accès aux caractères :
$s[i]$ accède au $i$-ème caractère
Exemple :
Chaîne : \"Bonjour le monde\"
Chercher : 'o'
Remplacer par : '0'
Résultat : \"B0nj0ur le m0nde\"
Nombre de remplacements : 3$",
"id_category": "1",
"id_number": "52"
}
]
