informatique 1 en pascal Recherche avancée

 [
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un algorithme puis un programme Pascal qui calcule le factoriel d'un nombre entier positif $N$. Le factoriel est défini par $N! = 1 \\times 2 \\times 3 \\times ... \\times N$. Calculer $5!$ (factoriel de $5$).",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Étape 1 : Analyse du problème
Le factoriel de $N$ est : $N! = \\prod_{i=1}^{N} i = 1 \\times 2 \\times 3 \\times ... \\times N$
Convention : $0! = 1$

Étape 2 : Algorithme
Algorithme Factoriel\nVariables :\n  N, i : Entier\n  F : Réel\nDébut\n  Écrire(\"Entrez N : \")\n  Lire(N)\n  F ← 1\n  Pour i de 1 à N faire\n    F ← F × i\n  FinPour\n  Écrire(\"Le factoriel de \", N, \" est : \", F)\nFin
Étape 3 : Programme Pascal
program Factoriel;\nvar\n  N, i : integer;\n  F : real;\nbegin\n  writeln('Entrez N : ');\n  readln(N);\n  F := 1;  { Initialisation }\n  for i := 1 to N do\n    F := F * i;  { Produit cumulatif }\n  writeln('Le factoriel de ', N, ' est : ', F:0:0);\nend.
Étape 4 : Application numérique
Calcul de $5!$

Initialisation : $F = 1$
Itération $i = 1$ : $F = 1 \\times 1 = 1$
Itération $i = 2$ : $F = 1 \\times 2 = 2$
Itération $i = 3$ : $F = 2 \\times 3 = 6$
Itération $i = 4$ : $F = 6 \\times 4 = 24$
Itération $i = 5$ : $F = 24 \\times 5 = 120$

Résultat final : $5! = 120$",
    "id_category": "1",
    "id_number": "1"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un algorithme puis un programme Pascal qui calcule la puissance $x^n$ d'un nombre réel $x$ élevé à la puissance entière $n$ en utilisant une boucle. Calculer $2^8$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Étape 1 : Analyse du problème
Calculer $x^n = x \\times x \\times x \\times ... \\times x$ ($n$ fois)

Étape 2 : Algorithme
Algorithme Puissance\nVariables :\n  x, resultat : Réel\n  n, i : Entier\nDébut\n  Écrire(\"Entrez la base x : \")\n  Lire(x)\n  Écrire(\"Entrez l'exposant n : \")\n  Lire(n)\n  resultat ← 1\n  Pour i de 1 à n faire\n    resultat ← resultat × x\n  FinPour\n  Écrire(x, \" à la puissance \", n, \" est : \", resultat)\nFin
Étape 3 : Programme Pascal
program Puissance;\nvar\n  x, resultat : real;\n  n, i : integer;\nbegin\n  writeln('Entrez la base x : ');\n  readln(x);\n  writeln('Entrez l''exposant n : ');\n  readln(n);\n  resultat := 1;  { Initialisation }\n  for i := 1 to n do\n    resultat := resultat * x;  { Multiplication répétée }\n  writeln(x:0:0, ' a la puissance ', n, ' est : ', resultat:0:0);\nend.
Étape 4 : Application numérique
Calcul de $2^8$

Initialisation : $\\text{resultat} = 1$
Itération $i = 1$ : $\\text{resultat} = 1 \\times 2 = 2$
Itération $i = 2$ : $\\text{resultat} = 2 \\times 2 = 4$
Itération $i = 3$ : $\\text{resultat} = 4 \\times 2 = 8$
Itération $i = 4$ : $\\text{resultat} = 8 \\times 2 = 16$
Itération $i = 5$ : $\\text{resultat} = 16 \\times 2 = 32$
Itération $i = 6$ : $\\text{resultat} = 32 \\times 2 = 64$
Itération $i = 7$ : $\\text{resultat} = 64 \\times 2 = 128$
Itération $i = 8$ : $\\text{resultat} = 128 \\times 2 = 256$

Résultat final : $2^8 = 256$",
    "id_category": "1",
    "id_number": "2"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un algorithme puis un programme Pascal qui calcule le maximum de trois nombres réels $a$, $b$ et $c$. Tester avec $a = 15.2$, $b = 23.7$ et $c = 18.9$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Étape 1 : Analyse du problème
Comparer trois nombres pour déterminer le maximum.

Étape 2 : Algorithme
Algorithme Maximum_Trois_Nombres\nVariables :\n  a, b, c, max : Réel\nDébut\n  Écrire(\"Entrez le premier nombre : \")\n  Lire(a)\n  Écrire(\"Entrez le deuxième nombre : \")\n  Lire(b)\n  Écrire(\"Entrez le troisième nombre : \")\n  Lire(c)\n  max ← a\n  Si (b > max) Alors\n    max ← b\n  FinSi\n  Si (c > max) Alors\n    max ← c\n  FinSi\n  Écrire(\"Le maximum est : \", max)\nFin
Étape 3 : Programme Pascal
program Maximum_Trois_Nombres;\nvar\n  a, b, c, max : real;\nbegin\n  writeln('Entrez le premier nombre : ');\n  readln(a);\n  writeln('Entrez le deuxieme nombre : ');\n  readln(b);\n  writeln('Entrez le troisieme nombre : ');\n  readln(c);\n  max := a;  { Initialisation avec le premier nombre }\n  if (b > max) then  { Comparaison avec b }\n    max := b;\n  if (c > max) then  { Comparaison avec c }\n    max := c;\n  writeln('Le maximum est : ', max:0:2);\nend.
Étape 4 : Application numérique
Avec $a = 15.2$, $b = 23.7$, $c = 18.9$

Initialisation : $\\text{max} = a = 15.2$

Comparaison 1 : $b > \\text{max}$ ?
$23.7 > 15.2$ (vrai)
Donc : $\\text{max} = b = 23.7$

Comparaison 2 : $c > \\text{max}$ ?
$18.9 > 23.7$ (faux)
Donc : $\\text{max}$ reste $23.7$

Résultat final : Le maximum est $\\text{max} = 23.7$",
    "id_category": "1",
    "id_number": "3"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un algorithme puis un programme Pascal qui calcule la somme des carrés des $N$ premiers entiers naturels : $S = 1^2 + 2^2 + 3^2 + ... + N^2$. Calculer cette somme pour $N = 5$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Étape 1 : Analyse du problème
Calculer $S = \\sum_{i=1}^{N} i^2 = 1^2 + 2^2 + 3^2 + ... + N^2$

Étape 2 : Algorithme
Algorithme Somme_Carres\nVariables :\n  N, i : Entier\n  S : Réel\nDébut\n  Écrire(\"Entrez N : \")\n  Lire(N)\n  S ← 0\n  Pour i de 1 à N faire\n    S ← S + i × i\n  FinPour\n  Écrire(\"La somme des carrés est : \", S)\nFin
Étape 3 : Programme Pascal
program Somme_Carres;\nvar\n  N, i : integer;\n  S : real;\nbegin\n  writeln('Entrez N : ');\n  readln(N);\n  S := 0;  { Initialisation de la somme }\n  for i := 1 to N do\n    S := S + i * i;  { Ajout du carré de i }\n  writeln('La somme des carres est : ', S:0:0);\nend.
Étape 4 : Application numérique
Calcul de $S = 1^2 + 2^2 + 3^2 + 4^2 + 5^2$ pour $N = 5$

Initialisation : $S = 0$
Itération $i = 1$ : $1^2 = 1$, donc $S = 0 + 1 = 1$
Itération $i = 2$ : $2^2 = 4$, donc $S = 1 + 4 = 5$
Itération $i = 3$ : $3^2 = 9$, donc $S = 5 + 9 = 14$
Itération $i = 4$ : $4^2 = 16$, donc $S = 14 + 16 = 30$
Itération $i = 5$ : $5^2 = 25$, donc $S = 30 + 25 = 55$

Résultat final : La somme des carrés est $S = 55$",
    "id_category": "1",
    "id_number": "4"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un algorithme puis un programme Pascal qui vérifie si un nombre entier $N$ est divisible par $3$ et par $5$ simultanément. Tester avec $N = 30$ puis avec $N = 18$. Un nombre est divisible par $k$ si $N \\bmod k = 0$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Étape 1 : Analyse du problème
Un nombre $N$ est divisible par $3$ et par $5$ si : $N \\bmod 3 = 0$ ET $N \\bmod 5 = 0$

Étape 2 : Algorithme
Algorithme Divisibilite_3_et_5\nVariables :\n  N : Entier\nDébut\n  Écrire(\"Entrez un nombre entier : \")\n  Lire(N)\n  Si (N mod 3 = 0) ET (N mod 5 = 0) Alors\n    Écrire(N, \" est divisible par 3 et par 5\")\n  Sinon\n    Écrire(N, \" n'est pas divisible par 3 et 5 simultanément\")\n  FinSi\nFin
Étape 3 : Programme Pascal
program Divisibilite_3_et_5;\nvar\n  N : integer;\nbegin\n  writeln('Entrez un nombre entier : ');\n  readln(N);\n  if ((N mod 3 = 0) and (N mod 5 = 0)) then  { Test double }\n    writeln(N, ' est divisible par 3 et par 5')\n  else\n    writeln(N, ' n''est pas divisible par 3 et 5 simultanement');\nend.
Étape 4 : Application numérique

Test 1 avec $N = 30$ :
Calcul de $30 \\bmod 3$ : $30 \\div 3 = 10$ reste $0$, donc $30 \\bmod 3 = 0$ (vrai)
Calcul de $30 \\bmod 5$ : $30 \\div 5 = 6$ reste $0$, donc $30 \\bmod 5 = 0$ (vrai)
Les deux conditions sont vraies
Conclusion : $30$ est divisible par $3$ et par $5$

Test 2 avec $N = 18$ :
Calcul de $18 \\bmod 3$ : $18 \\div 3 = 6$ reste $0$, donc $18 \\bmod 3 = 0$ (vrai)
Calcul de $18 \\bmod 5$ : $18 \\div 5 = 3$ reste $3$, donc $18 \\bmod 5 = 3 \\neq 0$ (faux)
Une condition est fausse
Conclusion : $18$ n'est pas divisible par $3$ et $5$ simultanément",
    "id_category": "1",
    "id_number": "5"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un algorithme puis un programme Pascal qui calcule la distance euclidienne entre deux points $A(x_1, y_1)$ et $B(x_2, y_2)$ dans le plan. La formule est $d = \\sqrt{(x_2 - x_1)^2 + (y_2 - y_1)^2}$. Calculer la distance entre $A(3, 4)$ et $B(7, 1)$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Étape 1 : Analyse du problème
Formule de la distance euclidienne : $d = \\sqrt{(x_2 - x_1)^2 + (y_2 - y_1)^2}$

Étape 2 : Algorithme
Algorithme Distance_Euclidienne\nVariables :\n  x1, y1, x2, y2, dx, dy, d : Réel\nDébut\n  Écrire(\"Entrez x1 : \")\n  Lire(x1)\n  Écrire(\"Entrez y1 : \")\n  Lire(y1)\n  Écrire(\"Entrez x2 : \")\n  Lire(x2)\n  Écrire(\"Entrez y2 : \")\n  Lire(y2)\n  dx ← x2 - x1\n  dy ← y2 - y1\n  d ← racine_carrée(dx × dx + dy × dy)\n  Écrire(\"La distance est : \", d)\nFin
Étape 3 : Programme Pascal
program Distance_Euclidienne;\nvar\n  x1, y1, x2, y2, dx, dy, d : real;\nbegin\n  writeln('Entrez x1 : ');\n  readln(x1);\n  writeln('Entrez y1 : ');\n  readln(y1);\n  writeln('Entrez x2 : ');\n  readln(x2);\n  writeln('Entrez y2 : ');\n  readln(y2);\n  dx := x2 - x1;  { Différence en x }\n  dy := y2 - y1;  { Différence en y }\n  d := sqrt(dx * dx + dy * dy);  { Distance euclidienne }\n  writeln('La distance est : ', d:0:2);\nend.
Étape 4 : Application numérique
Avec $A(3, 4)$ et $B(7, 1)$
Donc $x_1 = 3$, $y_1 = 4$, $x_2 = 7$, $y_2 = 1$

Calcul des différences :
$dx = x_2 - x_1 = 7 - 3 = 4$
$dy = y_2 - y_1 = 1 - 4 = -3$

Calcul des carrés :
$dx^2 = 4^2 = 16$
$dy^2 = (-3)^2 = 9$

Calcul de la somme : $dx^2 + dy^2 = 16 + 9 = 25$

Calcul de la distance :
Formule : $d = \\sqrt{25} = 5$

Résultat final : La distance entre $A$ et $B$ est $d = 5$",
    "id_category": "1",
    "id_number": "6"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un algorithme puis un programme Pascal qui calcule le PGCD (Plus Grand Commun Diviseur) de deux entiers positifs $a$ et $b$ en utilisant l'algorithme d'Euclide. Calculer le PGCD de $48$ et $18$. L'algorithme d'Euclide : tant que $b \\neq 0$, on remplace $(a, b)$ par $(b, a \\bmod b)$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Étape 1 : Analyse du problème
Algorithme d'Euclide : Tant que $b \\neq 0$, on effectue $(a, b) \\leftarrow (b, a \\bmod b)$
Quand $b = 0$, le PGCD est $a$

Étape 2 : Algorithme
Algorithme PGCD_Euclide\nVariables :\n  a, b, reste : Entier\nDébut\n  Écrire(\"Entrez a : \")\n  Lire(a)\n  Écrire(\"Entrez b : \")\n  Lire(b)\n  TantQue (b ≠ 0) Faire\n    reste ← a mod b\n    a ← b\n    b ← reste\n  FinTantQue\n  Écrire(\"Le PGCD est : \", a)\nFin
Étape 3 : Programme Pascal
program PGCD_Euclide;\nvar\n  a, b, reste : integer;\nbegin\n  writeln('Entrez a : ');\n  readln(a);\n  writeln('Entrez b : ');\n  readln(b);\n  while (b <> 0) do  { Algorithme d'Euclide }\n  begin\n    reste := a mod b;  { Calcul du reste }\n    a := b;  { Mise à jour de a }\n    b := reste;  { Mise à jour de b }\n  end;\n  writeln('Le PGCD est : ', a);\nend.
Étape 4 : Application numérique
Calcul du PGCD de $48$ et $18$

Initialisation : $a = 48$, $b = 18$

Itération 1 :
$\\text{reste} = 48 \\bmod 18$ : $48 = 2 \\times 18 + 12$, donc $\\text{reste} = 12$
$a \\leftarrow 18$, $b \\leftarrow 12$

Itération 2 :
$\\text{reste} = 18 \\bmod 12$ : $18 = 1 \\times 12 + 6$, donc $\\text{reste} = 6$
$a \\leftarrow 12$, $b \\leftarrow 6$

Itération 3 :
$\\text{reste} = 12 \\bmod 6$ : $12 = 2 \\times 6 + 0$, donc $\\text{reste} = 0$
$a \\leftarrow 6$, $b \\leftarrow 0$

Condition : $b = 0$, boucle terminée

Résultat final : Le PGCD de $48$ et $18$ est $6$",
    "id_category": "1",
    "id_number": "7"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un algorithme puis un programme Pascal qui détermine si un nombre entier $N$ est premier. Un nombre premier est divisible uniquement par $1$ et par lui-même. Tester avec $N = 17$ puis avec $N = 15$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Étape 1 : Analyse du problème
Un nombre $N > 1$ est premier si aucun nombre de $2$ à $N-1$ ne le divise.
Optimisation : il suffit de tester jusqu'à $\\sqrt{N}$

Étape 2 : Algorithme
Algorithme Nombre_Premier\nVariables :\n  N, i : Entier\n  estPremier : Booléen\nDébut\n  Écrire(\"Entrez un nombre : \")\n  Lire(N)\n  Si (N <= 1) Alors\n    estPremier ← Faux\n  Sinon\n    estPremier ← Vrai\n    Pour i de 2 à N-1 faire\n      Si (N mod i = 0) Alors\n        estPremier ← Faux\n      FinSi\n    FinPour\n  FinSi\n  Si (estPremier) Alors\n    Écrire(N, \" est premier\")\n  Sinon\n    Écrire(N, \" n'est pas premier\")\n  FinSi\nFin
Étape 3 : Programme Pascal
program Nombre_Premier;\nvar\n  N, i : integer;\n  estPremier : boolean;\nbegin\n  writeln('Entrez un nombre : ');\n  readln(N);\n  if (N <= 1) then\n    estPremier := false\n  else\n  begin\n    estPremier := true;  { Hypothèse : N est premier }\n    for i := 2 to N-1 do\n      if (N mod i = 0) then  { Test de divisibilité }\n        estPremier := false;\n  end;\n  if (estPremier) then\n    writeln(N, ' est premier')\n  else\n    writeln(N, ' n''est pas premier');\nend.
Étape 4 : Application numérique

Test 1 avec $N = 17$ :
Test des diviseurs de $2$ à $16$ :
$17 \\bmod 2 = 1 \\neq 0$
$17 \\bmod 3 = 2 \\neq 0$
$17 \\bmod 4 = 1 \\neq 0$
$17 \\bmod 5 = 2 \\neq 0$
... (aucun diviseur trouvé)
$17 \\bmod 16 = 1 \\neq 0$
Conclusion : $17$ est premier

Test 2 avec $N = 15$ :
Test des diviseurs :
$15 \\bmod 2 = 1 \\neq 0$
$15 \\bmod 3 = 0$ (divisible !)
Un diviseur trouvé : $3$
Conclusion : $15$ n'est pas premier (car $15 = 3 \\times 5$)",
    "id_category": "1",
    "id_number": "8"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un algorithme puis un programme Pascal qui inverse un nombre entier à trois chiffres. Par exemple, si $N = 457$, le résultat doit être $754$. Utiliser les opérations modulo et division entière.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Étape 1 : Analyse du problème
Pour inverser un nombre à trois chiffres $N$ :
- Chiffre des unités : $c_1 = N \\bmod 10$
- Chiffre des dizaines : $c_2 = (N \\div 10) \\bmod 10$
- Chiffre des centaines : $c_3 = N \\div 100$
- Nombre inversé : $\\text{inv} = c_1 \\times 100 + c_2 \\times 10 + c_3$

Étape 2 : Algorithme
Algorithme Inverser_Nombre\nVariables :\n  N, c1, c2, c3, inv : Entier\nDébut\n  Écrire(\"Entrez un nombre à 3 chiffres : \")\n  Lire(N)\n  c1 ← N mod 10\n  c2 ← (N div 10) mod 10\n  c3 ← N div 100\n  inv ← c1 × 100 + c2 × 10 + c3\n  Écrire(\"Le nombre inversé est : \", inv)\nFin
Étape 3 : Programme Pascal
program Inverser_Nombre;\nvar\n  N, c1, c2, c3, inv : integer;\nbegin\n  writeln('Entrez un nombre a 3 chiffres : ');\n  readln(N);\n  c1 := N mod 10;  { Unités }\n  c2 := (N div 10) mod 10;  { Dizaines }\n  c3 := N div 100;  { Centaines }\n  inv := c1 * 100 + c2 * 10 + c3;  { Reconstruction }\n  writeln('Le nombre inverse est : ', inv);\nend.
Étape 4 : Application numérique
Avec $N = 457$

Extraction du chiffre des unités :
$c_1 = 457 \\bmod 10 = 7$

Extraction du chiffre des dizaines :
Division entière : $457 \\div 10 = 45$
$c_2 = 45 \\bmod 10 = 5$

Extraction du chiffre des centaines :
$c_3 = 457 \\div 100 = 4$

Reconstruction du nombre inversé :
Formule : $\\text{inv} = c_1 \\times 100 + c_2 \\times 10 + c_3$
Calcul : $\\text{inv} = 7 \\times 100 + 5 \\times 10 + 4$
Calcul : $\\text{inv} = 700 + 50 + 4 = 754$

Résultat final : Le nombre inversé de $457$ est $754$",
    "id_category": "1",
    "id_number": "9"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un algorithme puis un programme Pascal qui calcule la somme des chiffres d'un nombre entier positif $N$. Par exemple, pour $N = 1234$, la somme des chiffres est $1 + 2 + 3 + 4 = 10$. Utiliser une boucle et les opérations modulo et division entière.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Étape 1 : Analyse du problème
Pour extraire les chiffres successivement :
- Dernier chiffre : $N \\bmod 10$
- Supprimer le dernier chiffre : $N \\leftarrow N \\div 10$
Répéter jusqu'à $N = 0$

Étape 2 : Algorithme
Algorithme Somme_Chiffres\nVariables :\n  N, somme, chiffre : Entier\nDébut\n  Écrire(\"Entrez un nombre entier : \")\n  Lire(N)\n  somme ← 0\n  TantQue (N > 0) Faire\n    chiffre ← N mod 10\n    somme ← somme + chiffre\n    N ← N div 10\n  FinTantQue\n  Écrire(\"La somme des chiffres est : \", somme)\nFin
Étape 3 : Programme Pascal
program Somme_Chiffres;\nvar\n  N, somme, chiffre : integer;\nbegin\n  writeln('Entrez un nombre entier : ');\n  readln(N);\n  somme := 0;  { Initialisation de la somme }\n  while (N > 0) do\n  begin\n    chiffre := N mod 10;  { Extraction du dernier chiffre }\n    somme := somme + chiffre;  { Ajout à la somme }\n    N := N div 10;  { Suppression du dernier chiffre }\n  end;\n  writeln('La somme des chiffres est : ', somme);\nend.
Étape 4 : Application numérique
Calcul de la somme des chiffres de $N = 1234$

Initialisation : $\\text{somme} = 0$, $N = 1234$

Itération 1 :
$\\text{chiffre} = 1234 \\bmod 10 = 4$
$\\text{somme} = 0 + 4 = 4$
$N = 1234 \\div 10 = 123$

Itération 2 :
$\\text{chiffre} = 123 \\bmod 10 = 3$
$\\text{somme} = 4 + 3 = 7$
$N = 123 \\div 10 = 12$

Itération 3 :
$\\text{chiffre} = 12 \\bmod 10 = 2$
$\\text{somme} = 7 + 2 = 9$
$N = 12 \\div 10 = 1$

Itération 4 :
$\\text{chiffre} = 1 \\bmod 10 = 1$
$\\text{somme} = 9 + 1 = 10$
$N = 1 \\div 10 = 0$

Condition : $N = 0$, boucle terminée

Résultat final : La somme des chiffres de $1234$ est $10$",
    "id_category": "1",
    "id_number": "10"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un algorithme puis un programme Pascal qui calcule le $n$-ième terme de la suite de Fibonacci. La suite est définie par $F_0 = 0$, $F_1 = 1$ et $F_n = F_{n-1} + F_{n-2}$ pour $n \\geq 2$. Calculer $F_8$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Étape 1 : Analyse du problème
Suite de Fibonacci : $F_0 = 0$, $F_1 = 1$, $F_n = F_{n-1} + F_{n-2}$
Méthode itérative avec deux variables.

Étape 2 : Algorithme
Algorithme Fibonacci\nVariables :\n  n, i : Entier\n  F0, F1, Fn : Entier\nDébut\n  Écrire(\"Entrez n : \")\n  Lire(n)\n  Si (n = 0) Alors\n    Écrire(\"F(0) = 0\")\n  Sinon Si (n = 1) Alors\n    Écrire(\"F(1) = 1\")\n  Sinon\n    F0 ← 0\n    F1 ← 1\n    Pour i de 2 à n faire\n      Fn ← F0 + F1\n      F0 ← F1\n      F1 ← Fn\n    FinPour\n    Écrire(\"F(\", n, \") = \", Fn)\n  FinSi\nFin
Étape 3 : Programme Pascal
program Fibonacci;\nvar\n  n, i : integer;\n  F0, F1, Fn : integer;\nbegin\n  writeln('Entrez n : ');\n  readln(n);\n  if (n = 0) then\n    writeln('F(0) = 0')\n  else if (n = 1) then\n    writeln('F(1) = 1')\n  else\n  begin\n    F0 := 0;  { F(0) }\n    F1 := 1;  { F(1) }\n    for i := 2 to n do\n    begin\n      Fn := F0 + F1;  { F(n) = F(n-2) + F(n-1) }\n      F0 := F1;  { Mise à jour }\n      F1 := Fn;\n    end;\n    writeln('F(', n, ') = ', Fn);\n  end;\nend.
Étape 4 : Application numérique
Calcul de $F_8$

Initialisation : $F_0 = 0$, $F_1 = 1$

Itération $i = 2$ : $F_2 = F_0 + F_1 = 0 + 1 = 1$, puis $F_0 = 1$, $F_1 = 1$
Itération $i = 3$ : $F_3 = 1 + 1 = 2$, puis $F_0 = 1$, $F_1 = 2$
Itération $i = 4$ : $F_4 = 1 + 2 = 3$, puis $F_0 = 2$, $F_1 = 3$
Itération $i = 5$ : $F_5 = 2 + 3 = 5$, puis $F_0 = 3$, $F_1 = 5$
Itération $i = 6$ : $F_6 = 3 + 5 = 8$, puis $F_0 = 5$, $F_1 = 8$
Itération $i = 7$ : $F_7 = 5 + 8 = 13$, puis $F_0 = 8$, $F_1 = 13$
Itération $i = 8$ : $F_8 = 8 + 13 = 21$, puis $F_0 = 13$, $F_1 = 21$

Résultat final : $F_8 = 21$",
    "id_category": "1",
    "id_number": "11"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un algorithme puis un programme Pascal qui calcule la moyenne pondérée de trois notes avec leurs coefficients respectifs. Un étudiant a obtenu $N_1 = 15$ (coefficient $c_1 = 2$), $N_2 = 12$ (coefficient $c_2 = 3$) et $N_3 = 14$ (coefficient $c_3 = 1$). La formule est $M = \\frac{N_1 c_1 + N_2 c_2 + N_3 c_3}{c_1 + c_2 + c_3}$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Étape 1 : Analyse du problème
Moyenne pondérée : $M = \\frac{\\sum N_i c_i}{\\sum c_i} = \\frac{N_1 c_1 + N_2 c_2 + N_3 c_3}{c_1 + c_2 + c_3}$

Étape 2 : Algorithme
Algorithme Moyenne_Ponderee\nVariables :\n  N1, N2, N3, c1, c2, c3 : Réel\n  sommeNotes, sommeCoeff, moyenne : Réel\nDébut\n  Écrire(\"Entrez N1 : \")\n  Lire(N1)\n  Écrire(\"Entrez le coefficient c1 : \")\n  Lire(c1)\n  Écrire(\"Entrez N2 : \")\n  Lire(N2)\n  Écrire(\"Entrez le coefficient c2 : \")\n  Lire(c2)\n  Écrire(\"Entrez N3 : \")\n  Lire(N3)\n  Écrire(\"Entrez le coefficient c3 : \")\n  Lire(c3)\n  sommeNotes ← N1 × c1 + N2 × c2 + N3 × c3\n  sommeCoeff ← c1 + c2 + c3\n  moyenne ← sommeNotes / sommeCoeff\n  Écrire(\"La moyenne pondérée est : \", moyenne)\nFin
Étape 3 : Programme Pascal
program Moyenne_Ponderee;\nvar\n  N1, N2, N3, c1, c2, c3 : real;\n  sommeNotes, sommeCoeff, moyenne : real;\nbegin\n  writeln('Entrez N1 : ');\n  readln(N1);\n  writeln('Entrez le coefficient c1 : ');\n  readln(c1);\n  writeln('Entrez N2 : ');\n  readln(N2);\n  writeln('Entrez le coefficient c2 : ');\n  readln(c2);\n  writeln('Entrez N3 : ');\n  readln(N3);\n  writeln('Entrez le coefficient c3 : ');\n  readln(c3);\n  sommeNotes := N1 * c1 + N2 * c2 + N3 * c3;  { Somme pondérée }\n  sommeCoeff := c1 + c2 + c3;  { Somme des coefficients }\n  moyenne := sommeNotes / sommeCoeff;  { Moyenne pondérée }\n  writeln('La moyenne ponderee est : ', moyenne:0:2);\nend.
Étape 4 : Application numérique
Avec $N_1 = 15$, $c_1 = 2$, $N_2 = 12$, $c_2 = 3$, $N_3 = 14$, $c_3 = 1$

Calcul de la somme pondérée des notes :
Formule : $\\text{sommeNotes} = N_1 c_1 + N_2 c_2 + N_3 c_3$
Calcul de $N_1 c_1$ : $15 \\times 2 = 30$
Calcul de $N_2 c_2$ : $12 \\times 3 = 36$
Calcul de $N_3 c_3$ : $14 \\times 1 = 14$
Somme totale : $\\text{sommeNotes} = 30 + 36 + 14 = 80$

Calcul de la somme des coefficients :
Formule : $\\text{sommeCoeff} = c_1 + c_2 + c_3$
Calcul : $\\text{sommeCoeff} = 2 + 3 + 1 = 6$

Calcul de la moyenne pondérée :
Formule : $M = \\frac{\\text{sommeNotes}}{\\text{sommeCoeff}}$
Calcul : $M = \\frac{80}{6} = 13.3333$

Résultat final : La moyenne pondérée est $M = 13.33$",
    "id_category": "1",
    "id_number": "12"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un algorithme puis un programme Pascal qui calcule et affiche la surface d'un rectangle. L'utilisateur doit saisir la longueur $L$ et la largeur $l$ du rectangle. La formule de calcul est $S = L \\times l$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "

**Algorithme :**
Algorithme Surface_Rectangle\nVariables\n  L, l, S : Réel\nDébut\n  Écrire(\"Entrez la longueur : \")\n  Lire(L)\n  Écrire(\"Entrez la largeur : \")\n  Lire(l)\n  S ← L × l\n  Écrire(\"La surface du rectangle est : \", S)\nFin

**Programme Pascal :**
program Surface_Rectangle;\nvar\n  L, l, S : real;\nbegin\n  writeln('Entrez la longueur : ');\n  readln(L);\n  writeln('Entrez la largeur : ');\n  readln(l);\n  { Calcul de la surface }\n  S := L * l;\n  writeln('La surface du rectangle est : ', S:0:2);\nend.

**Explication détaillée :**
1. On déclare trois variables de type réel : $L$ (longueur), $l$ (largeur), et $S$ (surface).
2. On demande à l'utilisateur de saisir la longueur et on la stocke dans $L$.
3. On demande la largeur et on la stocke dans $l$.
4. On calcule la surface avec la formule : $S = L \\times l$.
5. On affiche le résultat.

**Exemple d'exécution :**
Si $L = 5.5$ et $l = 3.2$ :
$S = 5.5 \\times 3.2 = 17.60$",
    "id_category": "1",
    "id_number": "13"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un algorithme puis un programme Pascal qui convertit une température en degrés Celsius $C$ en degrés Fahrenheit $F$. La formule de conversion est $F = \\frac{9}{5} \\times C + 32$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "

**Algorithme :**
Algorithme Conversion_Temperature\nVariables\n  C, F : Réel\nDébut\n  Écrire(\"Entrez la température en Celsius : \")\n  Lire(C)\n  F ← (9/5) × C + 32\n  Écrire(\"La température en Fahrenheit est : \", F)\nFin

**Programme Pascal :**
program Conversion_Temperature;\nvar\n  C, F : real;\nbegin\n  writeln('Entrez la temperature en Celsius : ');\n  readln(C);\n  { Conversion Celsius vers Fahrenheit }\n  F := (9/5) * C + 32;\n  writeln('La temperature en Fahrenheit est : ', F:0:2);\nend.

**Explication détaillée :**
1. On déclare deux variables réelles : $C$ pour Celsius et $F$ pour Fahrenheit.
2. On lit la température en Celsius depuis l'utilisateur.
3. On applique la formule de conversion : $F = \\frac{9}{5} \\times C + 32$.
4. On affiche la température convertie en Fahrenheit.

**Exemple d'exécution :**
Si $C = 25$ :
$F = \\frac{9}{5} \\times 25 + 32 = 1.8 \\times 25 + 32 = 45 + 32 = 77$",
    "id_category": "1",
    "id_number": "14"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un algorithme puis un programme Pascal qui lit deux nombres entiers $a$ et $b$, puis calcule et affiche leur somme $S$, leur différence $D$, leur produit $P$ et leur quotient $Q$. Utiliser les formules : $S = a + b$, $D = a - b$, $P = a \\times b$, $Q = \\frac{a}{b}$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "

**Algorithme :**
Algorithme Operations_Arithmetiques\nVariables\n  a, b : Entier\n  S, D, P : Entier\n  Q : Réel\nDébut\n  Écrire(\"Entrez le premier nombre : \")\n  Lire(a)\n  Écrire(\"Entrez le deuxième nombre : \")\n  Lire(b)\n  S ← a + b\n  D ← a - b\n  P ← a × b\n  Q ← a / b\n  Écrire(\"Somme : \", S)\n  Écrire(\"Différence : \", D)\n  Écrire(\"Produit : \", P)\n  Écrire(\"Quotient : \", Q)\nFin

**Programme Pascal :**
program Operations_Arithmetiques;\nvar\n  a, b : integer;\n  S, D, P : integer;\n  Q : real;\nbegin\n  writeln('Entrez le premier nombre : ');\n  readln(a);\n  writeln('Entrez le deuxieme nombre : ');\n  readln(b);\n  { Calculs des opérations }\n  S := a + b;\n  D := a - b;\n  P := a * b;\n  Q := a / b;\n  writeln('Somme : ', S);\n  writeln('Difference : ', D);\n  writeln('Produit : ', P);\n  writeln('Quotient : ', Q:0:2);\nend.

**Explication détaillée :**
1. On déclare $a$ et $b$ comme entiers, $S$, $D$, $P$ comme entiers, et $Q$ comme réel (car la division peut donner un résultat décimal).
2. On lit les deux nombres.$
3. On calcule : $S = a + b$, $D = a - b$, $P = a \\times b$, $Q = \\frac{a}{b}$.
4. On affiche tous les résultats.

**Exemple d'exécution :**
Si $a = 15$ et $b = 4$ :
$S = 15 + 4 = 19$
$D = 15 - 4 = 11$
$P = 15 \\times 4 = 60$
$Q = \\frac{15}{4} = 3.75$",
    "id_category": "1",
    "id_number": "15"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un algorithme puis un programme Pascal qui calcule le périmètre $P$ et l'aire $A$ d'un cercle de rayon $r$ donné par l'utilisateur. Utiliser les formules : $P = 2 \\times \\pi \\times r$ et $A = \\pi \\times r^2$. Prendre $\\pi = 3.14159$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "

**Algorithme :**
Algorithme Cercle\nConstantes\n  pi = 3.14159\nVariables\n  r, P, A : Réel\nDébut\n  Écrire(\"Entrez le rayon du cercle : \")\n  Lire(r)\n  P ← 2 × pi × r\n  A ← pi × r²\n  Écrire(\"Périmètre : \", P)\n  Écrire(\"Aire : \", A)\nFin

**Programme Pascal :**
program Cercle;\nconst\n  pi = 3.14159;\nvar\n  r, P, A : real;\nbegin\n  writeln('Entrez le rayon du cercle : ');\n  readln(r);\n  { Calcul du périmètre }\n  P := 2 * pi * r;\n  { Calcul de l''aire }\n  A := pi * r * r;\n  writeln('Perimetre : ', P:0:2);\n  writeln('Aire : ', A:0:2);\nend.

**Explication détaillée :**
1. On déclare une constante $\\pi = 3.14159$.
2. On déclare les variables $r$ (rayon), $P$ (périmètre), et $A$ (aire) de type réel.
3. On lit le rayon depuis l'utilisateur.
4. On calcule le périmètre avec : $P = 2 \\times \\pi \\times r$.
5. On calcule l'aire avec : $A = \\pi \\times r^2$.
6. On affiche les deux résultats.

**Exemple d'exécution :**
Si $r = 5$ :
$P = 2 \\times 3.14159 \\times 5 = 31.4159$
$A = 3.14159 \\times 5^2 = 3.14159 \\times 25 = 78.53975$",
    "id_category": "1",
    "id_number": "16"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un algorithme puis un programme Pascal qui lit un nombre entier $n$ et détermine s'il est pair ou impair. Un nombre est pair si $n \\mod 2 = 0$, sinon il est impair.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "

**Algorithme :**
Algorithme Parite\nVariables\n  n, reste : Entier\nDébut\n  Écrire(\"Entrez un nombre entier : \")\n  Lire(n)\n  reste ← n mod 2\n  Si (reste = 0) Alors\n    Écrire(n, \" est pair\")\n  Sinon\n    Écrire(n, \" est impair\")\n  FinSi\nFin

**Programme Pascal :**
program Parite;\nvar\n  n, reste : integer;\nbegin\n  writeln('Entrez un nombre entier : ');\n  readln(n);\n  { Calcul du reste de la division par 2 }\n  reste := n mod 2;\n  if (reste = 0) then\n    writeln(n, ' est pair')\n  else\n    writeln(n, ' est impair');\nend.

**Explication détaillée :**
1. On déclare $n$ pour le nombre et $reste$ pour le résultat du modulo.
2. On lit le nombre depuis l'utilisateur.
3. On calcule $reste = n \\mod 2$ (reste de la division par $2$).
4. Si $reste = 0$, le nombre est divisible par $2$, donc pair.
5. Sinon, le nombre est impair.

**Exemples d'exécution :**
Si $n = 8$ : $8 \\mod 2 = 0$, donc $8$ est pair.
Si $n = 13$ : $13 \\mod 2 = 1$, donc $13$ est impair.",
    "id_category": "1",
    "id_number": "17"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un algorithme puis un programme Pascal qui lit trois nombres réels $a$, $b$, $c$ et calcule leur moyenne arithmétique $M$. La formule est $M = \\frac{a + b + c}{3}$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "

**Algorithme :**
Algorithme Moyenne_Trois_Nombres\nVariables\n  a, b, c, M : Réel\nDébut\n  Écrire(\"Entrez le premier nombre : \")\n  Lire(a)\n  Écrire(\"Entrez le deuxième nombre : \")\n  Lire(b)\n  Écrire(\"Entrez le troisième nombre : \")\n  Lire(c)\n  M ← (a + b + c) / 3\n  Écrire(\"La moyenne est : \", M)\nFin

**Programme Pascal :**
program Moyenne_Trois_Nombres;\nvar\n  a, b, c, M : real;\nbegin\n  writeln('Entrez le premier nombre : ');\n  readln(a);\n  writeln('Entrez le deuxieme nombre : ');\n  readln(b);\n  writeln('Entrez le troisieme nombre : ');\n  readln(c);\n  { Calcul de la moyenne }\n  M := (a + b + c) / 3;\n  writeln('La moyenne est : ', M:0:2);\nend.

**Explication détaillée :**
1. On déclare quatre variables réelles : $a$, $b$, $c$ pour les nombres, et $M$ pour la moyenne.
2. On lit les trois nombres depuis l'utilisateur.
3. On calcule la moyenne avec la formule : $M = \\frac{a + b + c}{3}$.
4. On additionne d'abord les trois nombres, puis on divise par $3$.
5. On affiche le résultat.

**Exemple d'exécution :**
Si $a = 12$, $b = 15$, $c = 18$ :
$M = \\frac{12 + 15 + 18}{3} = \\frac{45}{3} = 15$",
    "id_category": "1",
    "id_number": "18"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un algorithme puis un programme Pascal qui lit deux nombres réels $x$ et $y$, puis affiche le plus grand des deux. Utiliser une structure conditionnelle.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "

**Algorithme :**
Algorithme Maximum_Deux_Nombres\nVariables\n  x, y, max : Réel\nDébut\n  Écrire(\"Entrez le premier nombre : \")\n  Lire(x)\n  Écrire(\"Entrez le deuxième nombre : \")\n  Lire(y)\n  Si (x > y) Alors\n    max ← x\n  Sinon\n    max ← y\n  FinSi\n  Écrire(\"Le maximum est : \", max)\nFin

**Programme Pascal :**
program Maximum_Deux_Nombres;\nvar\n  x, y, max : real;\nbegin\n  writeln('Entrez le premier nombre : ');\n  readln(x);\n  writeln('Entrez le deuxieme nombre : ');\n  readln(y);\n  { Détermination du maximum }\n  if (x > y) then\n    max := x\n  else\n    max := y;\n  writeln('Le maximum est : ', max:0:2);\nend.

**Explication détaillée :**
1. On déclare trois variables réelles : $x$, $y$ pour les nombres à comparer, et $max$ pour le maximum.
2. On lit les deux nombres.$
3. On compare : si $x > y$, alors $max \\leftarrow x$.
4. Sinon, $max \\leftarrow y$.
5. On affiche le maximum.

**Exemples d'exécution :**
Si $x = 7.5$ et $y = 4.2$ : $max = 7.5$
Si $x = 3.1$ et $y = 9.8$ : $max = 9.8$",
    "id_category": "1",
    "id_number": "19"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un algorithme puis un programme Pascal qui lit un nombre entier $n$ et calcule la somme des $n$ premiers entiers naturels en utilisant la formule $S = \\frac{n \\times (n + 1)}{2}$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "

**Algorithme :**
Algorithme Somme_N_Premiers\nVariables\n  n : Entier\n  S : Réel\nDébut\n  Écrire(\"Entrez n : \")\n  Lire(n)\n  S ← (n × (n + 1)) / 2\n  Écrire(\"La somme des \", n, \" premiers entiers est : \", S)\nFin

**Programme Pascal :**
program Somme_N_Premiers;\nvar\n  n : integer;\n  S : real;\nbegin\n  writeln('Entrez n : ');\n  readln(n);\n  { Calcul de la somme avec la formule }\n  S := (n * (n + 1)) / 2;\n  writeln('La somme des ', n, ' premiers entiers est : ', S:0:0);\nend.

**Explication détaillée :**
1. On déclare $n$ comme entier et $S$ comme réel pour stocker la somme.
2. On lit $n$ depuis l'utilisateur.
3. On applique la formule directe : $S = \\frac{n \\times (n + 1)}{2}$.
4. Cette formule calcule $1 + 2 + 3 + \\ldots + n$ sans boucle.
5. On affiche le résultat.

**Exemple d'exécution :**
Si $n = 10$ :
$S = \\frac{10 \\times (10 + 1)}{2} = \\frac{10 \\times 11}{2} = \\frac{110}{2} = 55$
Vérification : $1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 = 55$",
    "id_category": "1",
    "id_number": "20"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un algorithme puis un programme Pascal qui lit un nombre entier positif $n$ et calcule sa factorielle $n!$ en utilisant une boucle. Rappel : $n! = n \\times (n-1) \\times (n-2) \\times \\ldots \\times 2 \\times 1$ et $0! = 1$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "

**Algorithme :**
Algorithme Factorielle\nVariables\n  n, i : Entier\n  fact : Réel\nDébut\n  Écrire(\"Entrez un nombre entier positif : \")\n  Lire(n)\n  fact ← 1\n  Pour i de 1 à n Faire\n    fact ← fact × i\n  FinPour\n  Écrire(\"La factorielle de \", n, \" est : \", fact)\nFin

**Programme Pascal :**
program Factorielle;\nvar\n  n, i : integer;\n  fact : real;\nbegin\n  writeln('Entrez un nombre entier positif : ');\n  readln(n);\n  { Initialisation }\n  fact := 1;\n  { Calcul de la factorielle }\n  for i := 1 to n do\n    fact := fact * i;\n  writeln('La factorielle de ', n, ' est : ', fact:0:0);\nend.

**Explication détaillée :**
1. On déclare $n$ et $i$ comme entiers, et $fact$ comme réel (les factorielles deviennent grandes rapidement).
2. On initialise $fact \\leftarrow 1$.
3. On utilise une boucle pour $i$ de $1$ à $n$ :
   - À chaque itération, on multiplie $fact$ par $i$.
4. Après la boucle, $fact$ contient $n!$.

**Exemple d'exécution :**
Si $n = 5$ :
Itération $1$ : $fact = 1 \\times 1 = 1$
Itération $2$ : $fact = 1 \\times 2 = 2$
Itération $3$ : $fact = 2 \\times 3 = 6$
Itération $4$ : $fact = 6 \\times 4 = 24$
Itération $5$ : $fact = 24 \\times 5 = 120$
Donc $5! = 120$",
    "id_category": "1",
    "id_number": "21"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un algorithme puis un programme Pascal qui lit un nombre réel $x$ et un entier $n$, puis calcule $x^n$ (x puissance n) en utilisant une boucle.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "

**Algorithme :**
Algorithme Puissance\nVariables\n  x, resultat : Réel\n  n, i : Entier\nDébut\n  Écrire(\"Entrez la base x : \")\n  Lire(x)\n  Écrire(\"Entrez l'exposant n : \")\n  Lire(n)\n  resultat ← 1\n  Pour i de 1 à n Faire\n    resultat ← resultat × x\n  FinPour\n  Écrire(x, \" puissance \", n, \" = \", resultat)\nFin

**Programme Pascal :**
program Puissance;\nvar\n  x, resultat : real;\n  n, i : integer;\nbegin\n  writeln('Entrez la base x : ');\n  readln(x);\n  writeln('Entrez l''exposant n : ');\n  readln(n);\n  { Initialisation }\n  resultat := 1;\n  { Calcul de x puissance n }\n  for i := 1 to n do\n    resultat := resultat * x;\n  writeln(x:0:2, ' puissance ', n, ' = ', resultat:0:2);\nend.

**Explication détaillée :**
1. On déclare $x$ et $resultat$ comme réels, $n$ et $i$ comme entiers.
2. On lit la base $x$ et l'exposant $n$.
3. On initialise $resultat \\leftarrow 1$.
4. On utilise une boucle pour multiplier $resultat$ par $x$ exactement $n$ fois.
5. Après la boucle, $resultat = x^n$.

**Exemple d'exécution :**
Si $x = 2$ et $n = 4$ :
Itération $1$ : $resultat = 1 \\times 2 = 2$
Itération $2$ : $resultat = 2 \\times 2 = 4$
Itération $3$ : $resultat = 4 \\times 2 = 8$
Itération $4$ : $resultat = 8 \\times 2 = 16$
Donc $2^4 = 16$",
    "id_category": "1",
    "id_number": "22"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un algorithme puis un programme Pascal qui lit un nombre entier $n$ et affiche la table de multiplication de $n$ de $1$ à $10$. Pour chaque ligne $i$, afficher : $n \\times i = resultat$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "

**Algorithme :**
Algorithme Table_Multiplication\nVariables\n  n, i, resultat : Entier\nDébut\n  Écrire(\"Entrez un nombre : \")\n  Lire(n)\n  Pour i de 1 à 10 Faire\n    resultat ← n × i\n    Écrire(n, \" × \", i, \" = \", resultat)\n  FinPour\nFin

**Programme Pascal :**
program Table_Multiplication;\nvar\n  n, i, resultat : integer;\nbegin\n  writeln('Entrez un nombre : ');\n  readln(n);\n  writeln('Table de multiplication de ', n, ' :');\n  { Affichage de la table }\n  for i := 1 to 10 do\n  begin\n    resultat := n * i;\n    writeln(n, ' x ', i, ' = ', resultat);\n  end;\nend.

**Explication détaillée :**
1. On déclare $n$, $i$, et $resultat$ comme entiers.
2. On lit le nombre $n$ depuis l'utilisateur.
3. On utilise une boucle pour $i$ de $1$ à $10$ :
   - On calcule $resultat = n \\times i$.
   - On affiche la ligne $n \\times i = resultat$.

**Exemple d'exécution :**
Si $n = 7$ :
$7 \\times 1 = 7$
$7 \\times 2 = 14$
$7 \\times 3 = 21$
$7 \\times 4 = 28$
$7 \\times 5 = 35$
$7 \\times 6 = 42$
$7 \\times 7 = 49$
$7 \\times 8 = 56$
$7 \\times 9 = 63$
$7 \\times 10 = 70$",
    "id_category": "1",
    "id_number": "23"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un algorithme puis un programme Pascal qui lit trois nombres réels $a$, $b$, $c$ et détermine le plus grand parmi eux. Utiliser des structures conditionnelles imbriquées.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "

**Algorithme :**
Algorithme Maximum_Trois_Nombres\nVariables\n  a, b, c, max : Réel\nDébut\n  Écrire(\"Entrez le premier nombre : \")\n  Lire(a)\n  Écrire(\"Entrez le deuxième nombre : \")\n  Lire(b)\n  Écrire(\"Entrez le troisième nombre : \")\n  Lire(c)\n  Si (a > b) Alors\n    Si (a > c) Alors\n      max ← a\n    Sinon\n      max ← c\n    FinSi\n  Sinon\n    Si (b > c) Alors\n      max ← b\n    Sinon\n      max ← c\n    FinSi\n  FinSi\n  Écrire(\"Le maximum est : \", max)\nFin

**Programme Pascal :**
program Maximum_Trois_Nombres;\nvar\n  a, b, c, max : real;\nbegin\n  writeln('Entrez le premier nombre : ');\n  readln(a);\n  writeln('Entrez le deuxieme nombre : ');\n  readln(b);\n  writeln('Entrez le troisieme nombre : ');\n  readln(c);\n  { Détermination du maximum }\n  if (a > b) then\n  begin\n    if (a > c) then\n      max := a\n    else\n      max := c;\n  end\n  else\n  begin\n    if (b > c) then\n      max := b\n    else\n      max := c;\n  end;\n  writeln('Le maximum est : ', max:0:2);\nend.

**Explication détaillée :**
1. On déclare quatre variables réelles.$
2. On lit les trois nombres.$
3. On compare d'abord $a$ et $b$ :
   - Si $a > b$, on compare $a$ avec $c$ pour trouver le maximum.
   - Si $b \\geq a$, on compare $b$ avec $c$ pour trouver le maximum.
4. On affiche le résultat.

**Exemple d'exécution :**
Si $a = 12.5$, $b = 8.3$, $c = 15.7$ :
Comparaison : $a > b$ (vrai), donc on compare $a$ et $c$.
Comparaison : $a > c$ (faux, car $12.5 < 15.7$), donc $max = c = 15.7$",
    "id_category": "1",
    "id_number": "24"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un algorithme puis un programme Pascal qui lit un nombre entier $n$ et calcule la somme de ses chiffres. Par exemple, si $n = 1234$, la somme est $1 + 2 + 3 + 4 = 10$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "

**Algorithme :**
Algorithme Somme_Chiffres\nVariables\n  n, somme, chiffre : Entier\nDébut\n  Écrire(\"Entrez un nombre entier : \")\n  Lire(n)\n  somme ← 0\n  Tant que (n > 0) Faire\n    chiffre ← n mod 10\n    somme ← somme + chiffre\n    n ← n div 10\n  FinTantQue\n  Écrire(\"La somme des chiffres est : \", somme)\nFin

**Programme Pascal :**
program Somme_Chiffres;\nvar\n  n, somme, chiffre : integer;\nbegin\n  writeln('Entrez un nombre entier : ');\n  readln(n);\n  { Initialisation }\n  somme := 0;\n  { Extraction et somme des chiffres }\n  while (n > 0) do\n  begin\n    chiffre := n mod 10;  { Dernier chiffre }\n    somme := somme + chiffre;\n    n := n div 10;  { Suppression du dernier chiffre }\n  end;\n  writeln('La somme des chiffres est : ', somme);\nend.

**Explication détaillée :**
1. On déclare $n$ (nombre), $somme$, et $chiffre$.
2. On initialise $somme \\leftarrow 0$.
3. Tant que $n > 0$ :
   - On extrait le dernier chiffre : $chiffre = n \\mod 10$.
   - On ajoute ce chiffre à la somme : $somme \\leftarrow somme + chiffre$.
   - On supprime le dernier chiffre : $n \\leftarrow n \\div 10$.

**Exemple d'exécution :**
Si $n = 1234$ :
Itération $1$ : $chiffre = 1234 \\mod 10 = 4$, $somme = 0 + 4 = 4$, $n = 1234 \\div 10 = 123$
Itération $2$ : $chiffre = 123 \\mod 10 = 3$, $somme = 4 + 3 = 7$, $n = 123 \\div 10 = 12$
Itération $3$ : $chiffre = 12 \\mod 10 = 2$, $somme = 7 + 2 = 9$, $n = 12 \\div 10 = 1$
Itération $4$ : $chiffre = 1 \\mod 10 = 1$, $somme = 9 + 1 = 10$, $n = 1 \\div 10 = 0$
Résultat : $somme = 10$",
    "id_category": "1",
    "id_number": "25"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un algorithme puis un programme Pascal qui lit un nombre entier $n$ et affiche tous les diviseurs de $n$. Un nombre $d$ est un diviseur de $n$ si $n \\mod d = 0$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "

**Algorithme :**
Algorithme Diviseurs\nVariables\n  n, i : Entier\nDébut\n  Écrire(\"Entrez un nombre entier : \")\n  Lire(n)\n  Écrire(\"Les diviseurs de \", n, \" sont :\")\n  Pour i de 1 à n Faire\n    Si (n mod i = 0) Alors\n      Écrire(i)\n    FinSi\n  FinPour\nFin

**Programme Pascal :**
program Diviseurs;\nvar\n  n, i : integer;\nbegin\n  writeln('Entrez un nombre entier : ');\n  readln(n);\n  writeln('Les diviseurs de ', n, ' sont :');\n  { Recherche des diviseurs }\n  for i := 1 to n do\n  begin\n    if (n mod i = 0) then\n      writeln(i);\n  end;\nend.

**Explication détaillée :**
1. On déclare $n$ (le nombre) et $i$ (compteur pour tester les diviseurs).
2. On lit $n$.$
3. On parcourt tous les entiers de $1$ à $n$ :
   - Pour chaque $i$, on teste si $n \\mod i = 0$.
   - Si oui, $i$ est un diviseur et on l'affiche.

**Exemple d'exécution :**
Si $n = 12$ :
Test $i = 1$ : $12 \\mod 1 = 0$ → $1$ est diviseur
Test $i = 2$ : $12 \\mod 2 = 0$ → $2$ est diviseur
Test $i = 3$ : $12 \\mod 3 = 0$ → $3$ est diviseur
Test $i = 4$ : $12 \\mod 4 = 0$ → $4$ est diviseur
Test $i = 5$ : $12 \\mod 5 = 2$ → non diviseur
Test $i = 6$ : $12 \\mod 6 = 0$ → $6$ est diviseur
Test $i = 12$ : $12 \\mod 12 = 0$ → $12$ est diviseur
Diviseurs de $12$ : $1, 2, 3, 4, 6, 12$",
    "id_category": "1",
    "id_number": "26"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un algorithme puis un programme Pascal qui lit un nombre entier $n$ et vérifie s'il est premier. Un nombre premier $n > 1$ n'a que deux diviseurs : $1$ et $n$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "

**Algorithme :**
Algorithme Nombre_Premier\nVariables\n  n, i, compteur : Entier\nDébut\n  Écrire(\"Entrez un nombre entier : \")\n  Lire(n)\n  compteur ← 0\n  Pour i de 1 à n Faire\n    Si (n mod i = 0) Alors\n      compteur ← compteur + 1\n    FinSi\n  FinPour\n  Si (compteur = 2) Alors\n    Écrire(n, \" est un nombre premier\")\n  Sinon\n    Écrire(n, \" n'est pas un nombre premier\")\n  FinSi\nFin

**Programme Pascal :**
program Nombre_Premier;\nvar\n  n, i, compteur : integer;\nbegin\n  writeln('Entrez un nombre entier : ');\n  readln(n);\n  { Comptage des diviseurs }\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  { Test de primalité }\n  if (compteur = 2) then\n    writeln(n, ' est un nombre premier')\n  else\n    writeln(n, ' n''est pas un nombre premier');\nend.

**Explication détaillée :**
1. On déclare $n$, $i$, et $compteur$ (pour compter les diviseurs).
2. On initialise $compteur \\leftarrow 0$.
3. On parcourt tous les entiers de $1$ à $n$ :
   - Si $n \\mod i = 0$, on incrémente $compteur$.
4. Un nombre premier a exactement $2$ diviseurs ($1$ et lui-même).
5. Si $compteur = 2$, le nombre est premier.

**Exemples d'exécution :**
Si $n = 7$ :
Diviseurs : $1$ et $7$ → $compteur = 2$ → $7$ est premier.

Si $n = 12$ :
Diviseurs : $1, 2, 3, 4, 6, 12$ → $compteur = 6$ → $12$ n'est pas premier.",
    "id_category": "1",
    "id_number": "27"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un algorithme puis un programme Pascal qui lit un nombre entier positif $n$ et calcule la somme des carrés des $n$ premiers entiers : $S = 1^2 + 2^2 + 3^2 + \\ldots + n^2$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "

**Algorithme :**
Algorithme Somme_Carres\nVariables\n  n, i, S : Entier\nDébut\n  Écrire(\"Entrez n : \")\n  Lire(n)\n  S ← 0\n  Pour i de 1 à n Faire\n    S ← S + i²\n  FinPour\n  Écrire(\"La somme des carrés est : \", S)\nFin

**Programme Pascal :**
program Somme_Carres;\nvar\n  n, i, S : integer;\nbegin\n  writeln('Entrez n : ');\n  readln(n);\n  { Initialisation }\n  S := 0;\n  { Calcul de la somme des carrés }\n  for i := 1 to n do\n    S := S + i * i;\n  writeln('La somme des carres est : ', S);\nend.

**Explication détaillée :**
1. On déclare $n$, $i$, et $S$ comme entiers.
2. On initialise $S \\leftarrow 0$.
3. On utilise une boucle pour $i$ de $1$ à $n$ :
   - À chaque itération, on ajoute $i^2$ à $S$.
4. Après la boucle, $S$ contient la somme $1^2 + 2^2 + \\ldots + n^2$.

**Exemple d'exécution :**
Si $n = 5$ :
Itération $1$ : $S = 0 + 1^2 = 0 + 1 = 1$
Itération $2$ : $S = 1 + 2^2 = 1 + 4 = 5$
Itération $3$ : $S = 5 + 3^2 = 5 + 9 = 14$
Itération $4$ : $S = 14 + 4^2 = 14 + 16 = 30$
Itération $5$ : $S = 30 + 5^2 = 30 + 25 = 55$
Résultat : $S = 55$",
    "id_category": "1",
    "id_number": "28"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un algorithme puis un programme Pascal qui lit deux nombres entiers $a$ et $b$ et calcule leur PGCD (Plus Grand Commun Diviseur) en utilisant l'algorithme d'Euclide. L'algorithme : tant que $b \\neq 0$, on répète : $r \\leftarrow a \\mod b$, puis $a \\leftarrow b$, puis $b \\leftarrow r$. Le PGCD est la valeur finale de $a$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "

**Algorithme :**
Algorithme PGCD_Euclide\nVariables\n  a, b, r : Entier\nDébut\n  Écrire(\"Entrez le premier nombre : \")\n  Lire(a)\n  Écrire(\"Entrez le deuxième nombre : \")\n  Lire(b)\n  Tant que (b ≠ 0) Faire\n    r ← a mod b\n    a ← b\n    b ← r\n  FinTantQue\n  Écrire(\"Le PGCD est : \", a)\nFin

**Programme Pascal :**
program PGCD_Euclide;\nvar\n  a, b, r : integer;\nbegin\n  writeln('Entrez le premier nombre : ');\n  readln(a);\n  writeln('Entrez le deuxieme nombre : ');\n  readln(b);\n  { Algorithme d''Euclide }\n  while (b <> 0) do\n  begin\n    r := a mod b;\n    a := b;\n    b := r;\n  end;\n  writeln('Le PGCD est : ', a);\nend.

**Explication détaillée :**
1. On déclare $a$, $b$, et $r$ (reste).
2. On lit les deux nombres.$
3. On applique l'algorithme d'Euclide :
   - Tant que $b \\neq 0$ :
     - On calcule $r = a \\mod b$ (reste de la division).
     - On remplace $a$ par $b$ et $b$ par $r$.
4. Quand $b = 0$, la valeur de $a$ est le PGCD.

**Exemple d'exécution :**
Si $a = 48$ et $b = 18$ :
Itération $1$ : $r = 48 \\mod 18 = 12$, $a = 18$, $b = 12$
Itération $2$ : $r = 18 \\mod 12 = 6$, $a = 12$, $b = 6$
Itération $3$ : $r = 12 \\mod 6 = 0$, $a = 6$, $b = 0$
Boucle s'arrête, PGCD $= 6$",
    "id_category": "1",
    "id_number": "29"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un algorithme puis un programme Pascal qui lit un nombre entier $n$ et affiche les $n$ premiers termes de la suite de Fibonacci. La suite commence par $F_0 = 0$ et $F_1 = 1$, et chaque terme suivant est la somme des deux précédents : $F_i = F_{i-1} + F_{i-2}$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "

**Algorithme :**
Algorithme Suite_Fibonacci\nVariables\n  n, i, F0, F1, F_suivant : Entier\nDébut\n  Écrire(\"Entrez n : \")\n  Lire(n)\n  F0 ← 0\n  F1 ← 1\n  Écrire(\"Suite de Fibonacci :\")\n  Écrire(F0)\n  Si (n > 1) Alors\n    Écrire(F1)\n  FinSi\n  Pour i de 3 à n Faire\n    F_suivant ← F0 + F1\n    Écrire(F_suivant)\n    F0 ← F1\n    F1 ← F_suivant\n  FinPour\nFin

**Programme Pascal :**
program Suite_Fibonacci;\nvar\n  n, i, F0, F1, F_suivant : integer;\nbegin\n  writeln('Entrez n : ');\n  readln(n);\n  { Initialisation des deux premiers termes }\n  F0 := 0;\n  F1 := 1;\n  writeln('Suite de Fibonacci :');\n  writeln(F0);\n  if (n > 1) then\n    writeln(F1);\n  { Calcul des termes suivants }\n  for i := 3 to n do\n  begin\n    F_suivant := F0 + F1;\n    writeln(F_suivant);\n    F0 := F1;  { Mise à jour }\n    F1 := F_suivant;\n  end;\nend.

**Explication détaillée :**
1. On initialise $F_0 = 0$ et $F_1 = 1$.
2. On affiche les deux premiers termes.
3. Pour $i$ de $3$ à $n$ :
   - On calcule $F_{suivant} = F_0 + F_1$.
   - On affiche $F_{suivant}$.
   - On met à jour : $F_0 \\leftarrow F_1$ et $F_1 \\leftarrow F_{suivant}$.

**Exemple d'exécution :**
Si $n = 8$ :
$F_0 = 0$
$F_1 = 1$
$F_2 = 0 + 1 = 1$
$F_3 = 1 + 1 = 2$
$F_4 = 1 + 2 = 3$
$F_5 = 2 + 3 = 5$
$F_6 = 3 + 5 = 8$
$F_7 = 5 + 8 = 13$
Suite : $0, 1, 1, 2, 3, 5, 8, 13$",
    "id_category": "1",
    "id_number": "30"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un algorithme puis un programme Pascal qui lit un nombre réel $P$ (prix initial), un taux de remise $r$ (en pourcentage), et calcule le prix final après remise $P_f$. La formule est : $P_f = P - (P \\times \\frac{r}{100})$ ou $P_f = P \\times (1 - \\frac{r}{100})$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "

**Algorithme :**
Algorithme Prix_Apres_Remise\nVariables\n  P, r, remise, P_f : Réel\nDébut\n  Écrire(\"Entrez le prix initial : \")\n  Lire(P)\n  Écrire(\"Entrez le taux de remise (%) : \")\n  Lire(r)\n  remise ← P × (r / 100)\n  P_f ← P - remise\n  Écrire(\"Montant de la remise : \", remise)\n  Écrire(\"Prix final : \", P_f)\nFin

**Programme Pascal :**
program Prix_Apres_Remise;\nvar\n  P, r, remise, P_f : real;\nbegin\n  writeln('Entrez le prix initial : ');\n  readln(P);\n  writeln('Entrez le taux de remise (%) : ');\n  readln(r);\n  { Calcul de la remise }\n  remise := P * (r / 100);\n  { Calcul du prix final }\n  P_f := P - remise;\n  writeln('Montant de la remise : ', remise:0:2);\n  writeln('Prix final : ', P_f:0:2);\nend.

**Explication détaillée :**
1. On déclare $P$ (prix initial), $r$ (taux), $remise$, et $P_f$ (prix final).
2. On lit le prix initial et le taux de remise.
3. On calcule le montant de la remise : $remise = P \\times \\frac{r}{100}$.
4. On calcule le prix final : $P_f = P - remise$.
5. On affiche la remise et le prix final.

**Exemple d'exécution :**
Si $P = 250$ et $r = 15$ :
$remise = 250 \\times \\frac{15}{100} = 250 \\times 0.15 = 37.5$
$P_f = 250 - 37.5 = 212.5$
Autre formule : $P_f = 250 \\times (1 - \\frac{15}{100}) = 250 \\times 0.85 = 212.5$",
    "id_category": "1",
    "id_number": "31"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un algorithme puis un programme Pascal qui lit un nombre entier $n$ et affiche s'il est un nombre parfait. Un nombre parfait est égal à la somme de ses diviseurs propres (diviseurs strictement inférieurs à $n$). Par exemple, $6 = 1 + 2 + 3$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "

**Algorithme :**
Algorithme Nombre_Parfait\nVariables\n  n, i, somme : Entier\nDébut\n  Écrire(\"Entrez un nombre entier : \")\n  Lire(n)\n  somme ← 0\n  Pour i de 1 à (n-1) Faire\n    Si (n mod i = 0) Alors\n      somme ← somme + i\n    FinSi\n  FinPour\n  Si (somme = n) Alors\n    Écrire(n, \" est un nombre parfait\")\n  Sinon\n    Écrire(n, \" n'est pas un nombre parfait\")\n  FinSi\nFin

**Programme Pascal :**
program Nombre_Parfait;\nvar\n  n, i, somme : integer;\nbegin\n  writeln('Entrez un nombre entier : ');\n  readln(n);\n  { Initialisation }\n  somme := 0;\n  { Calcul de la somme des diviseurs propres }\n  for i := 1 to (n-1) do\n  begin\n    if (n mod i = 0) then\n      somme := somme + i;\n  end;\n  { Test de perfection }\n  if (somme = n) then\n    writeln(n, ' est un nombre parfait')\n  else\n    writeln(n, ' n''est pas un nombre parfait');\nend.

**Explication détaillée :**
1. On initialise $somme \\leftarrow 0$.
2. On parcourt tous les entiers de $1$ à $n-1$ :
   - Si $i$ divise $n$ ($n \\mod i = 0$), on ajoute $i$ à la somme.
3. Si $somme = n$, le nombre est parfait.

**Exemples d'exécution :**
Si $n = 6$ :
Diviseurs propres : $1, 2, 3$
$somme = 1 + 2 + 3 = 6$
Comme $somme = n$, $6$ est parfait.

Si $n = 28$ :
Diviseurs propres : $1, 2, 4, 7, 14$
$somme = 1 + 2 + 4 + 7 + 14 = 28$
Comme $somme = n$, $28$ est parfait.",
    "id_category": "1",
    "id_number": "32"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un algorithme puis un programme Pascal qui lit un nombre entier $n$ et calcule le nombre d'inversions nécessaires pour obtenir son inverse. Par exemple, si $n = 1234$, l'inverse est $4321$. Utiliser une boucle pour extraire les chiffres et construire l'inverse.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "

**Algorithme :**
Algorithme Inverse_Nombre\nVariables\n  n, inverse, chiffre : Entier\nDébut\n  Écrire(\"Entrez un nombre entier : \")\n  Lire(n)\n  inverse ← 0\n  Tant que (n > 0) Faire\n    chiffre ← n mod 10\n    inverse ← inverse × 10 + chiffre\n    n ← n div 10\n  FinTantQue\n  Écrire(\"L'inverse est : \", inverse)\nFin

**Programme Pascal :**
program Inverse_Nombre;\nvar\n  n, inverse, chiffre : integer;\nbegin\n  writeln('Entrez un nombre entier : ');\n  readln(n);\n  { Initialisation }\n  inverse := 0;\n  { Construction de l''inverse }\n  while (n > 0) do\n  begin\n    chiffre := n mod 10;  { Extraction du dernier chiffre }\n    inverse := inverse * 10 + chiffre;  { Ajout à l''inverse }\n    n := n div 10;  { Suppression du dernier chiffre }\n  end;\n  writeln('L''inverse est : ', inverse);\nend.

**Explication détaillée :**
1. On initialise $inverse \\leftarrow 0$.
2. Tant que $n > 0$ :
   - On extrait le dernier chiffre : $chiffre = n \\mod 10$.
   - On ajoute ce chiffre à droite de $inverse$ : $inverse = inverse \\times 10 + chiffre$.
   - On supprime le dernier chiffre de $n$ : $n = n \\div 10$.

**Exemple d'exécution :**
Si $n = 1234$ :
Itération $1$ : $chiffre = 1234 \\mod 10 = 4$, $inverse = 0 \\times 10 + 4 = 4$, $n = 123$
Itération $2$ : $chiffre = 123 \\mod 10 = 3$, $inverse = 4 \\times 10 + 3 = 43$, $n = 12$
Itération $3$ : $chiffre = 12 \\mod 10 = 2$, $inverse = 43 \\times 10 + 2 = 432$, $n = 1$
Itération $4$ : $chiffre = 1 \\mod 10 = 1$, $inverse = 432 \\times 10 + 1 = 4321$, $n = 0$
Résultat : $inverse = 4321$",
    "id_category": "1",
    "id_number": "33"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un programme Pascal qui lit un entier $n$ et affiche tous les entiers de $1$ à $n$. Utiliser une boucle for.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Algorithme en Pascal :
program AffichageEntiers;\nvar\n  n, i : integer;\nbegin\n  write('Entrez un entier n : ');\n  readln(n);\n  \n  if n < 1 then\n    writeln('Erreur : n doit etre >= 1')\n  else\n  begin\n    writeln('Affichage de 1 a ', n, ' :');\n    for i := 1 to n do\n      write(i, ' ');\n    writeln;\n  end;\n  \n  readln;\nend.

Explication :

Variables :
- $n$ : entier saisi par l'utilisateur
- $i$ : compteur de boucle

Boucle for :
La structure $for i := 1 to n do$ répète le bloc pour $i$ = 1, 2, 3, ..., n$

Exemple pour $n = 5$ :
Affichage : $1 2 3 4 5$",
    "id_category": "1",
    "id_number": "34"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un programme Pascal qui lit deux entiers $a$ et $b$ et affiche leur somme, leur différence et leur produit.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Algorithme en Pascal :
program OperationsSimples;\nvar\n  a, b : integer;\nbegin\n  write('Entrez le premier entier a : ');\n  readln(a);\n  write('Entrez le deuxieme entier b : ');\n  readln(b);\n  \n  writeln;\n  writeln('Somme : ', a, ' + ', b, ' = ', a + b);\n  writeln('Difference : ', a, ' - ', b, ' = ', a - b);\n  writeln('Produit : ', a, ' x ', b, ' = ', a * b);\n  \n  readln;\nend.

Explication :

Variables :
- $a, b$ : deux entiers

Opérations :
- Addition : $a + b$
- Soustraction : $a - b$
- Multiplication : $a * b$

Exemple pour $a = 10$ et $b = 3$ :
$10 + 3 = 13$
$10 - 3 = 7$
$10 × 3 = 30$",
    "id_category": "1",
    "id_number": "35"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un programme Pascal qui lit un entier $n$ et vérifie s'il est pair ou impair.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Algorithme en Pascal :
program PairOuImpair;\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 PAIR')\n  else\n    writeln(n, ' est IMPAIR');\n  \n  readln;\nend.

Explication :

Opération modulo :
$n \\mod 2$ retourne le reste de la division de $n$ par $2$

Test :
- Si $n \\mod 2 = 0$ : $n$ est pair
- Si $n \\mod 2 = 1$ : $n$ est impair

Exemples :
$8 \\mod 2 = 0$ → $8$ est pair
$7 \\mod 2 = 1$ → $7$ est impair

",
    "id_category": "1",
    "id_number": "36"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un programme Pascal qui lit un entier $n$ et calcule la somme des entiers de $1$ à $n$ avec une boucle while.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Algorithme en Pascal :
program SommeBoucleWhile;\nvar\n  n, i, somme : integer;\nbegin\n  write('Entrez un entier n : ');\n  readln(n);\n  \n  somme := 0;\n  i := 1;\n  \n  while i <= n do\n  begin\n    somme := somme + i;\n    i := i + 1;\n  end;\n  \n  writeln('Somme de 1 a ', n, ' = ', somme);\n  \n  readln;\nend.

Explication :

Boucle while :
La boucle $while i <= n do$ répète tant que la condition est vraie.

Trace pour $n = 5$ :
- $i = 1$ : $somme = 0 + 1 = 1$
- $i = 2$ : $somme = 1 + 2 = 3$
- $i = 3$ : $somme = 3 + 3 = 6$
- $i = 4$ : $somme = 6 + 4 = 10$
- $i = 5$ : $somme = 10 + 5 = 15$

Résultat : $15$",
    "id_category": "1",
    "id_number": "37"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un programme Pascal qui lit une note et affiche si l'étudiant est reçu (note >= 10) ou recalé (note < 10).",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Algorithme en Pascal :
program ResultatExamen;\nvar\n  note : real;\nbegin\n  write('Entrez la note : ');\n  readln(note);\n  \n  if note >= 10 then\n    writeln('Resultat : RECU')\n  else\n    writeln('Resultat : RECALE');\n  \n  readln;\nend.

Explication :

Condition if :
- Si $note \\geq 10$ : afficher RECU
- Sinon : afficher RECALE

Exemple :
- note = 12 → RECU
- note = 8 → RECALE
",
    "id_category": "1",
    "id_number": "38"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un programme Pascal qui lit trois nombres et affiche le plus grand parmi eux.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Algorithme en Pascal :
program PlusGrand;\nvar\n  a, b, c, max : real;\nbegin\n  write('Entrez le premier nombre a : ');\n  readln(a);\n  write('Entrez le deuxieme nombre b : ');\n  readln(b);\n  write('Entrez le troisieme nombre c : ');\n  readln(c);\n  \n  max := a;\n  \n  if b > max then\n    max := b;\n  \n  if c > max then\n    max := c;\n  \n  writeln('Le plus grand nombre est : ', max:0:2);\n  \n  readln;\nend.

Explication :

Algorithme :
1. Supposer que $a$ est le plus grand
2. Si $b > max$, alors $max = b$
3. Si $c > max$, alors $max = c$

Exemple pour $a = 5, b = 12, c = 8$ :
- $max = 5$
- $12 > 5$ → $max = 12$
- $8 < 12$ → $max = 12$
- Résultat : $12$",
    "id_category": "1",
    "id_number": "39"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un programme Pascal qui affiche la table de multiplication d'un nombre $n$ (de $1 \\times n$ à $10 \\times n$).",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Algorithme en Pascal :
program TableMultiplication;\nvar\n  n, i : integer;\nbegin\n  write('Entrez un nombre n : ');\n  readln(n);\n  \n  writeln('Table de multiplication de ', n, ' :');\n  writeln;\n  \n  for i := 1 to 10 do\n    writeln(i, ' x ', n, ' = ', i * n);\n  \n  readln;\nend.

Explication :

Boucle for :
Pour $i$ de $1$ à $10$, afficher $i \\times n$

Exemple pour $n = 7$ :
1 × 7 = 7
2 × 7 = 14
3 × 7 = 21
...
10 × 7 = 70
",
    "id_category": "1",
    "id_number": "40"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un programme Pascal qui lit une température en Celsius et la convertit en Fahrenheit. Formule : $F = C \\times 1.8 + 32$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Algorithme en Pascal :
program ConversionTemperature;\nvar\n  celsius, fahrenheit : real;\nbegin\n  write('Entrez la temperature en Celsius : ');\n  readln(celsius);\n  \n  fahrenheit := celsius * 1.8 + 32;\n  \n  writeln(celsius:0:2, ' °C = ', fahrenheit:0:2, ' °F');\n  \n  readln;\nend.

Explication :

Formule de conversion :
$F = C \\times 1.8 + 32$

Exemple pour $C = 25$ :
$F = 25 \\times 1.8 + 32 = 45 + 32 = 77$ °F
",
    "id_category": "1",
    "id_number": "41"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un programme Pascal qui lit un nombre et affiche ses trois premiers multiples.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Algorithme en Pascal :
program MultiplesNombre;\nvar\n  n, i : integer;\nbegin\n  write('Entrez un nombre n : ');\n  readln(n);\n  \n  writeln('Les 3 premiers multiples de ', n, ' sont :');\n  \n  for i := 1 to 3 do\n    writeln(i, ' x ', n, ' = ', i * n);\n  \n  readln;\nend.

Explication :

Multiples :
Les multiples de $n$ sont $n, 2n, 3n, 4n, ...$

Exemple pour $n = 7$ :
1 × 7 = 7
2 × 7 = 14
3 × 7 = 21
",
    "id_category": "1",
    "id_number": "42"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un programme Pascal qui lit deux nombres et affiche si le premier est divisible par le second.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Algorithme en Pascal :
program TestDivisibilite;\nvar\n  a, b : integer;\nbegin\n  write('Entrez le premier nombre a : ');\n  readln(a);\n  write('Entrez le deuxieme nombre b : ');\n  readln(b);\n  \n  if b = 0 then\n    writeln('Erreur : division par zero')\n  else if a mod b = 0 then\n    writeln(a, ' est divisible par ', b)\n  else\n    writeln(a, ' n''est pas divisible par ', b);\n  \n  readln;\nend.

Explication :

Test de divisibilité :
$a$ est divisible par $b$ si $a \\mod b = 0$

Exemple :
- $20 \\mod 5 = 0$ → $20$ est divisible par $5$
- $20 \\mod 3 = 2$ → $20$ n'est pas divisible par $3$",
    "id_category": "1",
    "id_number": "43"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un programme Pascal qui lit l'âge d'une personne et affiche si elle est majeure (>= 18) ou mineure.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Algorithme en Pascal :
program VerificationAge;\nvar\n  age : integer;\nbegin\n  write('Entrez votre age : ');\n  readln(age);\n  \n  if age >= 18 then\n    writeln('Vous etes MAJEURE')\n  else\n    writeln('Vous etes MINEURE');\n  \n  readln;\nend.

Explication :

Condition :
- Si $age \\geq 18$ : majeur
- Sinon : mineur

Exemple :
- age = 20 → MAJEUR
- age = 15 → MINEUR
",
    "id_category": "1",
    "id_number": "44"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un programme Pascal qui compte de 1 à $n$ avec une boucle do-until.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Algorithme en Pascal :
program ComptageBoucleRepeat;\nvar\n  n, i : integer;\nbegin\n  write('Entrez un nombre n : ');\n  readln(n);\n  \n  writeln('Comptage de 1 a ', n, ' :');\n  \n  i := 1;\n  repeat\n  begin\n    write(i, ' ');\n    i := i + 1;\n  end\n  until i > n;\n  \n  writeln;\n  readln;\nend.

Explication :

Boucle repeat-until :
La boucle $repeat ... until$ répète au moins une fois, puis vérifie la condition.

Trace pour $n = 5$ :
- Affiche $1$, $i = 2$
- Affiche $2$, $i = 3$
- Affiche $3$, $i = 4$
- Affiche $4$, $i = 5$
- Affiche $5$, $i = 6$
- $i > n$ → arrêt
",
    "id_category": "1",
    "id_number": "45"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un programme Pascal qui lit une distance en kilomètres et la convertit en miles. Formule : $miles = km \\times 0.621371$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Algorithme en Pascal :
program ConversionDistance;\nvar\n  km, miles : real;\nbegin\n  write('Entrez une distance en kilometres : ');\n  readln(km);\n  \n  miles := km * 0.621371;\n  \n  writeln(km:0:2, ' km = ', miles:0:2, ' miles');\n  \n  readln;\nend.

Explication :

Formule de conversion :
$miles = km \\times 0.621371$

Exemple pour $km = 10$ :
$miles = 10 \\times 0.621371 = 6.21371$ miles
",
    "id_category": "1",
    "id_number": "46"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un programme Pascal qui lit le prix d'un produit et le pourcentage de réduction, puis affiche le prix final.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Algorithme en Pascal :
program CalculReduction;\nvar\n  prix_initial, pourcentage, reduction, prix_final : real;\nbegin\n  write('Entrez le prix initial : ');\n  readln(prix_initial);\n  write('Entrez le pourcentage de reduction : ');\n  readln(pourcentage);\n  \n  reduction := prix_initial * pourcentage / 100;\n  prix_final := prix_initial - reduction;\n  \n  writeln;\n  writeln('Prix initial : ', prix_initial:0:2, ' euros');\n  writeln('Reduction (' , pourcentage:0:0, '%) : ', reduction:0:2, ' euros');\n  writeln('Prix final : ', prix_final:0:2, ' euros');\n  \n  readln;\nend.

Explication :

Calcul de la réduction :
$reduction = prix\\_initial \\times \\frac{pourcentage}{100}$
$prix\\_final = prix\\_initial - reduction$

Exemple pour prix = 100 et réduction = 20% :
$reduction = 100 \\times 0.20 = 20$ euros
$prix\\_final = 100 - 20 = 80$ euros
",
    "id_category": "1",
    "id_number": "47"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un programme Pascal qui lit un nombre et affiche ses diviseurs (tous les nombres qui le divisent).",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Algorithme en Pascal :
program AffichageDiviseurs;\nvar\n  n, i : integer;\nbegin\n  write('Entrez un nombre n : ');\n  readln(n);\n  \n  if n <= 0 then\n    writeln('Erreur : n doit etre > 0')\n  else\n  begin\n    writeln('Diviseurs de ', n, ' :');\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 :

Algorithme :
Pour chaque nombre $i$ de $1$ à $n$ :
- Si $n \\mod i = 0$, alors $i$ est un diviseur

Exemple pour $n = 12$ :
Diviseurs : $1, 2, 3, 4, 6, 12$",
    "id_category": "1",
    "id_number": "48"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un programme Pascal qui lit le salaire mensuel et calcule le salaire annuel en sachant qu'il y a 13 mois (13 mois avec prime).",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Algorithme en Pascal :
program CalculSalaireAnnuel;\nvar\n  salaire_mensuel, salaire_annuel : real;\nbegin\n  write('Entrez le salaire mensuel : ');\n  readln(salaire_mensuel);\n  \n  salaire_annuel := salaire_mensuel * 13;\n  \n  writeln('Salaire mensuel : ', salaire_mensuel:0:2, ' euros');\n  writeln('Salaire annuel (13 mois) : ', salaire_annuel:0:2, ' euros');\n  \n  readln;\nend.

Explication :

Calcul :
$salaire\\_annuel = salaire\\_mensuel \\times 13$

Exemple pour salaire mensuel = 1500 :
$salaire\\_annuel = 1500 \\times 13 = 19500$ euros
",
    "id_category": "1",
    "id_number": "49"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un programme Pascal qui lit trois nombres et affiche leur moyenne.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Algorithme en Pascal :
program CalculMoyenne;\nvar\n  a, b, c, moyenne : real;\nbegin\n  write('Entrez le premier nombre a : ');\n  readln(a);\n  write('Entrez le deuxieme nombre b : ');\n  readln(b);\n  write('Entrez le troisieme nombre c : ');\n  readln(c);\n  \n  moyenne := (a + b + c) / 3;\n  \n  writeln('Moyenne : ', moyenne:0:2);\n  \n  readln;\nend.

Explication :

Formule de la moyenne :
$moyenne = \\frac{a + b + c}{3}$

Exemple pour a = 10, b = 12, c = 14 :
$moyenne = \\frac{10 + 12 + 14}{3} = \\frac{36}{3} = 12$",
    "id_category": "1",
    "id_number": "50"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un programme Pascal qui lit un nombre et affiche si c'est un nombre négatif, zéro ou positif.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Algorithme en Pascal :
program ClassificationNombre;\nvar\n  n : integer;\nbegin\n  write('Entrez un nombre : ');\n  readln(n);\n  \n  if n < 0 then\n    writeln('Le nombre est NEGATIF')\n  else if n = 0 then\n    writeln('Le nombre est ZERO')\n  else\n    writeln('Le nombre est POSITIF');\n  \n  readln;\nend.

Explication :

Conditions :
- Si $n < 0$ : négatif
- Si $n = 0$ : zéro
- Si $n > 0$ : positif

Exemple :
- n = -5 → NEGATIF
- n = 0 → ZERO
- n = 8 → POSITIF
",
    "id_category": "1",
    "id_number": "51"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un programme Pascal qui lit le nombre d'heures travaillées et le taux horaire, puis calcule le salaire brut.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Algorithme en Pascal :
program CalculSalaireBrut;\nvar\n  heures, taux_horaire, salaire_brut : real;\nbegin\n  write('Entrez le nombre d''heures travaillees : ');\n  readln(heures);\n  write('Entrez le taux horaire (en euros) : ');\n  readln(taux_horaire);\n  \n  salaire_brut := heures * taux_horaire;\n  \n  writeln('Nombre d''heures : ', heures:0:2);\n  writeln('Taux horaire : ', taux_horaire:0:2, ' euros/heure');\n  writeln('Salaire brut : ', salaire_brut:0:2, ' euros');\n  \n  readln;\nend.

Explication :

Formule :
$salaire\\_brut = heures \\times taux\\_horaire$

Exemple pour 35 heures à 12 euros/heure :
$salaire\\_brut = 35 \\times 12 = 420$ euros
",
    "id_category": "1",
    "id_number": "52"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un programme Pascal qui lit un prix HT (hors taxes) et affiche le prix TTC (toutes taxes comprises) avec TVA = 20%.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Algorithme en Pascal :
program CalculPrixTTC;\nvar\n  prix_ht, tva, prix_ttc : real;\nbegin\n  write('Entrez le prix HT : ');\n  readln(prix_ht);\n  \n  tva := prix_ht * 0.20;\n  prix_ttc := prix_ht + tva;\n  \n  writeln('Prix HT : ', prix_ht:0:2, ' euros');\n  writeln('TVA (20%) : ', tva:0:2, ' euros');\n  writeln('Prix TTC : ', prix_ttc:0:2, ' euros');\n  \n  readln;\nend.

Explication :

Calcul de la TVA :
$TVA = prix\\_HT \\times 0.20$
$prix\\_TTC = prix\\_HT + TVA$

Exemple pour prix HT = 100 :
$TVA = 100 \\times 0.20 = 20$ euros
$prix\\_TTC = 100 + 20 = 120$ euros
",
    "id_category": "1",
    "id_number": "53"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un algorithme puis un programme Pascal qui calcule la surface d'un rectangle. L'utilisateur saisit la longueur $L = 12.5$ cm et la largeur $l = 8.3$ cm. Calculer et afficher la surface $S$ en cm$^2$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Étape 1 : Analyse du problème
Nous devons calculer la surface d'un rectangle avec la formule : $S = L \\times l$

Étape 2 : Algorithme
Algorithme Surface_Rectangle\nVariables :\n  L, l, S : Réel\nDébut\n  Écrire(\"Entrez la longueur : \")\n  Lire(L)\n  Écrire(\"Entrez la largeur : \")\n  Lire(l)\n  S ← L × l\n  Écrire(\"La surface est : \", S, \" cm²\")\nFin
Étape 3 : Programme Pascal
program Surface_Rectangle;\nvar\n  L, l, S : real;\nbegin\n  writeln('Entrez la longueur : ');\n  readln(L);\n  writeln('Entrez la largeur : ');\n  readln(l);\n  S := L * l;  { Calcul de la surface }\n  writeln('La surface est : ', S:0:2, ' cm2');\nend.
Étape 4 : Application numérique
Formule : $S = L \\times l$
Avec $L = 12.5$ cm et $l = 8.3$ cm
Calcul : $S = 12.5 \\times 8.3 = 103.75$ cm$^2$

Résultat final : La surface du rectangle est $S = 103.75$ cm$^2$",
    "id_category": "1",
    "id_number": "54"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un algorithme puis un programme Pascal qui calcule la moyenne arithmétique de trois notes. Un étudiant a obtenu les notes suivantes : $N_1 = 14.5$, $N_2 = 16$ et $N_3 = 12.75$. Calculer et afficher la moyenne $M$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Étape 1 : Analyse du problème
La moyenne arithmétique de trois nombres est : $M = \\frac{N_1 + N_2 + N_3}{3}$

Étape 2 : Algorithme
Algorithme Moyenne_Trois_Notes\nVariables :\n  N1, N2, N3, M : Réel\nDébut\n  Écrire(\"Entrez la première note : \")\n  Lire(N1)\n  Écrire(\"Entrez la deuxième note : \")\n  Lire(N2)\n  Écrire(\"Entrez la troisième note : \")\n  Lire(N3)\n  M ← (N1 + N2 + N3) / 3\n  Écrire(\"La moyenne est : \", M)\nFin
Étape 3 : Programme Pascal
program Moyenne_Trois_Notes;\nvar\n  N1, N2, N3, M : real;\nbegin\n  writeln('Entrez la premiere note : ');\n  readln(N1);\n  writeln('Entrez la deuxieme note : ');\n  readln(N2);\n  writeln('Entrez la troisieme note : ');\n  readln(N3);\n  M := (N1 + N2 + N3) / 3;  { Calcul de la moyenne }\n  writeln('La moyenne est : ', M:0:2);\nend.
Étape 4 : Application numérique
Formule : $M = \\frac{N_1 + N_2 + N_3}{3}$
Avec $N_1 = 14.5$, $N_2 = 16$, $N_3 = 12.75$
Calcul de la somme : $N_1 + N_2 + N_3 = 14.5 + 16 + 12.75 = 43.25$
Calcul de la moyenne : $M = \\frac{43.25}{3} = 14.4167$

Résultat final : La moyenne est $M = 14.42$",
    "id_category": "1",
    "id_number": "55"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un algorithme puis un programme Pascal qui convertit une température en degrés Celsius en degrés Fahrenheit. La formule de conversion est $F = \\frac{9}{5} \\times C + 32$. Convertir $C = 25$ degrés Celsius.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Étape 1 : Analyse du problème
Nous utilisons la formule : $F = \\frac{9}{5} \\times C + 32$

Étape 2 : Algorithme
Algorithme Conversion_Temperature\nVariables :\n  C, F : Réel\nDébut\n  Écrire(\"Entrez la température en Celsius : \")\n  Lire(C)\n  F ← (9/5) × C + 32\n  Écrire(\"La température en Fahrenheit est : \", F)\nFin
Étape 3 : Programme Pascal
program Conversion_Temperature;\nvar\n  C, F : real;\nbegin\n  writeln('Entrez la temperature en Celsius : ');\n  readln(C);\n  F := (9/5) * C + 32;  { Conversion Celsius vers Fahrenheit }\n  writeln('La temperature en Fahrenheit est : ', F:0:2);\nend.
Étape 4 : Application numérique
Formule : $F = \\frac{9}{5} \\times C + 32$
Avec $C = 25$ degrés Celsius
Calcul du coefficient : $\\frac{9}{5} = 1.8$
Calcul du produit : $1.8 \\times 25 = 45$
Calcul final : $F = 45 + 32 = 77$

Résultat final : $25$ degrés Celsius équivalent à $F = 77$ degrés Fahrenheit",
    "id_category": "1",
    "id_number": "56"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un algorithme puis un programme Pascal qui calcule le périmètre et l'aire d'un cercle. L'utilisateur saisit le rayon $r = 7$ cm. Utiliser $\\pi = 3.14159$. Les formules sont : périmètre $P = 2 \\pi r$ et aire $A = \\pi r^2$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Étape 1 : Analyse du problème
Nous devons calculer deux valeurs :
Périmètre : $P = 2 \\pi r$
Aire : $A = \\pi r^2$

Étape 2 : Algorithme
Algorithme Cercle\nConstantes :\n  PI = 3.14159\nVariables :\n  r, P, A : Réel\nDébut\n  Écrire(\"Entrez le rayon : \")\n  Lire(r)\n  P ← 2 × PI × r\n  A ← PI × r × r\n  Écrire(\"Le périmètre est : \", P, \" cm\")\n  Écrire(\"L'aire est : \", A, \" cm²\")\nFin
Étape 3 : Programme Pascal
program Cercle;\nconst\n  PI = 3.14159;\nvar\n  r, P, A : real;\nbegin\n  writeln('Entrez le rayon : ');\n  readln(r);\n  P := 2 * PI * r;  { Calcul du périmètre }\n  A := PI * r * r;  { Calcul de l'aire }\n  writeln('Le perimetre est : ', P:0:2, ' cm');\n  writeln('L''aire est : ', A:0:2, ' cm2');\nend.
Étape 4 : Application numérique
Avec $r = 7$ cm et $\\pi = 3.14159$

Calcul du périmètre :
Formule : $P = 2 \\pi r$
Calcul : $P = 2 \\times 3.14159 \\times 7$
Calcul : $P = 6.28318 \\times 7 = 43.98226$ cm

Calcul de l'aire :
Formule : $A = \\pi r^2$
Calcul du carré : $r^2 = 7^2 = 49$
Calcul : $A = 3.14159 \\times 49 = 153.93791$ cm$^2$

Résultats finaux : $P = 43.98$ cm et $A = 153.94$ cm$^2$",
    "id_category": "1",
    "id_number": "57"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un algorithme puis un programme Pascal qui détermine si un nombre entier $N$ est pair ou impair. Tester avec $N = 17$ puis avec $N = 24$. Un nombre est pair si le reste de sa division par $2$ est égal à $0$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Étape 1 : Analyse du problème
Un nombre $N$ est pair si $N \\bmod 2 = 0$, sinon il est impair.

Étape 2 : Algorithme
Algorithme Parite\nVariables :\n  N : Entier\nDébut\n  Écrire(\"Entrez un nombre entier : \")\n  Lire(N)\n  Si (N mod 2 = 0) Alors\n    Écrire(N, \" est pair\")\n  Sinon\n    Écrire(N, \" est impair\")\n  FinSi\nFin
Étape 3 : Programme Pascal
program Parite;\nvar\n  N : integer;\nbegin\n  writeln('Entrez un nombre entier : ');\n  readln(N);\n  if (N mod 2 = 0) then  { Test de parité }\n    writeln(N, ' est pair')\n  else\n    writeln(N, ' est impair');\nend.
Étape 4 : Application numérique

Test 1 avec $N = 17$ :
Calcul : $17 \\bmod 2$
Division : $17 \\div 2 = 8$ reste $1$
Donc $17 \\bmod 2 = 1 \\neq 0$
Conclusion : $17$ est impair

Test 2 avec $N = 24$ :
Calcul : $24 \\bmod 2$
Division : $24 \\div 2 = 12$ reste $0$
Donc $24 \\bmod 2 = 0$
Conclusion : $24$ est pair",
    "id_category": "1",
    "id_number": "58"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un algorithme puis un programme Pascal qui calcule la somme des $N$ premiers entiers naturels. Utiliser la formule $S = \\frac{N(N+1)}{2}$. Calculer la somme pour $N = 10$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Étape 1 : Analyse du problème
La somme des $N$ premiers entiers est donnée par : $S = 1 + 2 + 3 + ... + N = \\frac{N(N+1)}{2}$

Étape 2 : Algorithme
Algorithme Somme_N_Entiers\nVariables :\n  N : Entier\n  S : Réel\nDébut\n  Écrire(\"Entrez N : \")\n  Lire(N)\n  S ← N × (N + 1) / 2\n  Écrire(\"La somme des \", N, \" premiers entiers est : \", S)\nFin
Étape 3 : Programme Pascal
program Somme_N_Entiers;\nvar\n  N : integer;\n  S : real;\nbegin\n  writeln('Entrez N : ');\n  readln(N);\n  S := N * (N + 1) / 2;  { Formule de la somme }\n  writeln('La somme des ', N, ' premiers entiers est : ', S:0:0);\nend.
Étape 4 : Application numérique
Formule : $S = \\frac{N(N+1)}{2}$
Avec $N = 10$
Calcul de $N + 1$ : $10 + 1 = 11$
Calcul du produit : $N(N+1) = 10 \\times 11 = 110$
Calcul final : $S = \\frac{110}{2} = 55$

Vérification : $1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 = 55$

Résultat final : La somme des $10$ premiers entiers est $S = 55$",
    "id_category": "1",
    "id_number": "59"
  },
  {
    "category": "Exercices corriges en pascal ",
    "question": "Écrire un algorithme puis un programme Pascal qui calcule la valeur absolue d'un nombre réel $x$ sans utiliser de fonction prédéfinie. Tester avec $x = -15.7$ puis avec $x = 23.4$. La valeur absolue est définie par : $|x| = x$ si $x \\geq 0$, et $|x| = -x$ si $x < 0$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Étape 1 : Analyse du problème
Définition de la valeur absolue :
$|x| = \\begin{cases} x & \\text{si } x \\geq 0 \\\\ -x & \\text{si } x < 0 \\end{cases}$

Étape 2 : Algorithme
Algorithme Valeur_Absolue\nVariables :\n  x, absX : Réel\nDébut\n  Écrire(\"Entrez un nombre réel : \")\n  Lire(x)\n  Si (x >= 0) Alors\n    absX ← x\n  Sinon\n    absX ← -x\n  FinSi\n  Écrire(\"La valeur absolue de \", x, \" est : \", absX)\nFin
Étape 3 : Programme Pascal
program Valeur_Absolue;\nvar\n  x, absX : real;\nbegin\n  writeln('Entrez un nombre reel : ');\n  readln(x);\n  if (x >= 0) then  { Test du signe }\n    absX := x\n  else\n    absX := -x;  { Changement de signe }\n  writeln('La valeur absolue de ', x:0:2, ' est : ', absX:0:2);\nend.
Étape 4 : Application numérique

Test 1 avec $x = -15.7$ :
Condition : $-15.7 < 0$ (vrai)
Donc : $|x| = -x = -(-15.7) = 15.7$
Résultat : $|-15.7| = 15.7$

Test 2 avec $x = 23.4$ :
Condition : $23.4 \\geq 0$ (vrai)
Donc : $|x| = x = 23.4$
Résultat : $|23.4| = 23.4$",
    "id_category": "1",
    "id_number": "60"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui lit deux tableaux $A$ et $B$ de $n$ entiers chacun (avec $n \\leq 8$) et calcule leur produit scalaire $P = \\sum_{i=1}^{n} A_i \\times B_i$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Programme C++ :
#include <iostream>\nusing namespace std;\n\nint main() {\n    int n;\n    int A[8], B[8];  // Deux tableaux\n    int produit_scalaire = 0;\n    \n    // Lecture de n\n    cout << \"Entrez n (n <= 8) : \";\n    cin >> n;\n    \n    // Lecture du tableau A\n    cout << \"Entrez les elements du tableau A :\" << endl;\n    for(int i = 0; i < n; i++) {\n        cout << \"A[\" << i << \"] = \";\n        cin >> A[i];\n    }\n    \n    // Lecture du tableau B\n    cout << \"Entrez les elements du tableau B :\" << endl;\n    for(int i = 0; i < n; i++) {\n        cout << \"B[\" << i << \"] = \";\n        cin >> B[i];\n    }\n    \n    // Calcul du produit scalaire\n    for(int i = 0; i < n; i++) {\n        produit_scalaire = produit_scalaire + A[i] * B[i];\n    }\n    \n    // Affichage\n    cout << \"Produit scalaire P = \" << produit_scalaire << endl;\n    \n    return 0;\n}

Explication détaillée :

Étape 1 : Déclaration
Deux tableaux $A[8]$ et $B[8]$
Accumulateur $produit\\_scalaire$ initialisé à $0$

Étape 2 : Lecture des données
Deux boucles distinctes pour remplir $A$ et $B$

Étape 3 : Calcul du produit scalaire
Formule appliquée : $P = \\sum_{i=0}^{n-1} A[i] \\times B[i]$
Boucle d'accumulation des produits terme à terme

Exemple pour $n = 3$ :
Soit $A = \\{2, 3, 4\\}$ et $B = \\{1, 5, 2\\}$

Calcul détaillé :
Terme $1$ : $A[0] \\times B[0] = 2 \\times 1 = 2$
Terme $2$ : $A[1] \\times B[1] = 3 \\times 5 = 15$
Terme $3$ : $A[2] \\times B[2] = 4 \\times 2 = 8$

Somme : $P = 2 + 15 + 8 = 25$",
    "id_category": "2",
    "id_number": "1"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui lit un tableau de $n$ nombres réels (avec $n \\leq 12$) et trouve l'élément maximal $max$ ainsi que sa position $pos$ dans le tableau.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Programme C++ :
#include <iostream>\nusing namespace std;\n\nint main() {\n    int n, pos = 0;\n    float tab[12];\n    float max;\n    \n    // Lecture de n\n    cout << \"Entrez n (n <= 12) : \";\n    cin >> n;\n    \n    // Lecture du tableau\n    cout << \"Entrez les elements :\" << endl;\n    for(int i = 0; i < n; i++) {\n        cout << \"Element \" << i << \" : \";\n        cin >> tab[i];\n    }\n    \n    // Initialisation du maximum\n    max = tab[0];\n    pos = 0;\n    \n    // Recherche du maximum\n    for(int i = 1; i < n; i++) {\n        if(tab[i] > max) {\n            max = tab[i];\n            pos = i;\n        }\n    }\n    \n    // Affichage\n    cout << \"Maximum = \" << max << endl;\n    cout << \"Position = \" << pos << endl;\n    \n    return 0;\n}

Explication détaillée :

Étape 1 : Lecture du tableau
Remplissage des $n$ éléments via une boucle

Étape 2 : Initialisation
On suppose que le premier élément est le maximum :
$max = tab[0]$
$pos = 0$

Étape 3 : Parcours et comparaison
Boucle de $i = 1$ à $i = n-1$
Condition : si $tab[i] > max$, alors mise à jour :
- $max = tab[i]$
- $pos = i$

Exemple pour $n = 5$ avec tableau $\\{3.2, 7.5, 2.1, 9.8, 4.3\\}$ :

Initialisation : $max = 3.2$, $pos = 0$
Itération $i = 1$ : $tab[1] = 7.5 > 3.2$ → $max = 7.5$, $pos = 1$
Itération $i = 2$ : $tab[2] = 2.1 \\not> 7.5$ → pas de changement
Itération $i = 3$ : $tab[3] = 9.8 > 7.5$ → $max = 9.8$, $pos = 3$
Itération $i = 4$ : $tab[4] = 4.3 \\not> 9.8$ → pas de changement

Résultat : $max = 9.8$ à la position $pos = 3$",
    "id_category": "2",
    "id_number": "2"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui lit une matrice $M$ de dimensions $3 \\times 3$ et calcule la somme de tous ses éléments $S = \\sum_{i=0}^{2}\\sum_{j=0}^{2} M_{ij}$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Programme C++ :
#include <iostream>\nusing namespace std;\n\nint main() {\n    int M[3][3];  // Matrice 3x3\n    int S = 0;\n    \n    // Lecture de la matrice\n    cout << \"Entrez les elements de la matrice 3x3 :\" << endl;\n    for(int i = 0; i < 3; i++) {\n        for(int j = 0; j < 3; j++) {\n            cout << \"M[\" << i << \"][\" << j << \"] = \";\n            cin >> M[i][j];\n        }\n    }\n    \n    // Calcul de la somme\n    for(int i = 0; i < 3; i++) {\n        for(int j = 0; j < 3; j++) {\n            S = S + M[i][j];\n        }\n    }\n    \n    // Affichage\n    cout << \"Somme totale S = \" << S << endl;\n    \n    return 0;\n}

Explication détaillée :

Étape 1 : Déclaration
Matrice $M[3][3]$ : tableau bidimensionnel
Accumulateur $S$ initialisé à $0$

Étape 2 : Lecture avec double boucle
Boucle externe : parcours des lignes ($i$ de $0$ à $2$)
Boucle interne : parcours des colonnes ($j$ de $0$ à $2$)
Lecture de chaque élément $M[i][j]$

Étape 3 : Accumulation
Double boucle pour additionner tous les éléments
Formule : $S = S + M[i][j]$ pour tout $i, j$

Exemple :
Soit la matrice :
$M = \\begin{pmatrix} 1 & 2 & 3 \\\\ 4 & 5 & 6 \\\\ 7 & 8 & 9 \\end{pmatrix}$

Calcul ligne par ligne :
Ligne $0$ : $1 + 2 + 3 = 6$
Ligne $1$ : $4 + 5 + 6 = 15$
Ligne $2$ : $7 + 8 + 9 = 24$

Somme totale : $S = 6 + 15 + 24 = 45$

Vérification :
$S = \\sum_{i=0}^{2}\\sum_{j=0}^{2} M_{ij} = 1+2+3+4+5+6+7+8+9 = 45$",
    "id_category": "2",
    "id_number": "3"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui lit un tableau de $n$ entiers (avec $n \\leq 10$) et calcule le nombre d'éléments pairs $N_p$ et le nombre d'éléments impairs $N_i$ dans ce tableau.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Programme C++ :
#include <iostream>\nusing namespace std;\n\nint main() {\n    int n;\n    int tab[10];\n    int N_p = 0, N_i = 0;  // Compteurs pairs et impairs\n    \n    // Lecture de n\n    cout << \"Entrez n (n <= 10) : \";\n    cin >> n;\n    \n    // Lecture du tableau\n    cout << \"Entrez les elements :\" << endl;\n    for(int i = 0; i < n; i++) {\n        cout << \"Element \" << i << \" : \";\n        cin >> tab[i];\n    }\n    \n    // Comptage pairs et impairs\n    for(int i = 0; i < n; i++) {\n        if(tab[i] % 2 == 0) {\n            N_p++;  // Element pair\n        }\n        else {\n            N_i++;  // Element impair\n        }\n    }\n    \n    // Affichage\n    cout << \"Nombre d'elements pairs : \" << N_p << endl;\n    cout << \"Nombre d'elements impairs : \" << N_i << endl;\n    \n    return 0;\n}

Explication détaillée :

Étape 1 : Déclaration
Deux compteurs initialisés à $0$ :
- $N_p$ pour les nombres pairs
- $N_i$ pour les nombres impairs

Étape 2 : Test de parité
Condition : $tab[i]\\ \\%\\ 2 == 0$
Si vrai → nombre pair → $N_p$ incrémenté
Sinon → nombre impair → $N_i$ incrémenté

Étape 3 : Exemple pour $n = 6$
Tableau : $\\{3, 8, 15, 22, 7, 10\\}$

Analyse élément par élément :
$tab[0] = 3$ : $3\\ \\%\\ 2 = 1$ → impair → $N_i = 1$
$tab[1] = 8$ : $8\\ \\%\\ 2 = 0$ → pair → $N_p = 1$
$tab[2] = 15$ : $15\\ \\%\\ 2 = 1$ → impair → $N_i = 2$
$tab[3] = 22$ : $22\\ \\%\\ 2 = 0$ → pair → $N_p = 2$
$tab[4] = 7$ : $7\\ \\%\\ 2 = 1$ → impair → $N_i = 3$
$tab[5] = 10$ : $10\\ \\%\\ 2 = 0$ → pair → $N_p = 3$

Résultats finaux :
$N_p = 3$ (éléments pairs : $8, 22, 10$)
$N_i = 3$ (éléments impairs : $3, 15, 7$)

Vérification : $N_p + N_i = 3 + 3 = 6 = n$",
    "id_category": "2",
    "id_number": "4"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui lit un entier $n$ et calcule la somme des carrés $S = 1^2 + 2^2 + 3^2 + ... + n^2 = \\sum_{i=1}^{n} i^2$. Vérifier avec la formule théorique $S = \\frac{n(n+1)(2n+1)}{6}$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Programme C++ :
#include <iostream>\nusing namespace std;\n\nint main() {\n    int n;\n    long long S = 0;  // Somme des carrés\n    long long S_theorique;\n    \n    // Lecture de n\n    cout << \"Entrez n : \";\n    cin >> n;\n    \n    // Calcul par boucle\n    for(int i = 1; i <= n; i++) {\n        S = S + i * i;  // Ajout de i^2\n    }\n    \n    // Calcul théorique\n    S_theorique = (n * (n + 1) * (2 * n + 1)) / 6;\n    \n    // Affichage\n    cout << \"Somme calculee : S = \" << S << endl;\n    cout << \"Somme theorique : S = \" << S_theorique << endl;\n    \n    return 0;\n}

Explication détaillée :

Étape 1 : Calcul itératif
Boucle de $i = 1$ à $i = n$
Accumulation : $S = S + i^2$

Étape 2 : Exemple pour $n = 4$
Itération $1$ : $S = 0 + 1^2 = 0 + 1 = 1$
Itération $2$ : $S = 1 + 2^2 = 1 + 4 = 5$
Itération $3$ : $S = 5 + 3^2 = 5 + 9 = 14$
Itération $4$ : $S = 14 + 4^2 = 14 + 16 = 30$

Résultat itératif : $S = 30$

Étape 3 : Vérification théorique
Application de la formule : $S = \\frac{n(n+1)(2n+1)}{6}$

Pour $n = 4$ :
Numérateur : $4 \\times 5 \\times 9 = 4 \\times 45 = 180$
Division : $S = \\frac{180}{6} = 30$

Vérification : Les deux méthodes donnent $S = 30$ ✓

Remarque : L'utilisation de $long\\ long$ évite le dépassement de capacité pour les grandes valeurs de $n$",
    "id_category": "2",
    "id_number": "5"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui lit une matrice carrée $A$ de dimension $4 \\times 4$ et calcule la trace $Tr(A) = \\sum_{i=0}^{3} A_{ii}$, c'est-à-dire la somme des éléments de la diagonale principale.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Programme C++ :
#include <iostream>\nusing namespace std;\n\nint main() {\n    int A[4][4];  // Matrice 4x4\n    int trace = 0;\n    \n    // Lecture de la matrice\n    cout << \"Entrez les elements de la matrice 4x4 :\" << endl;\n    for(int i = 0; i < 4; i++) {\n        for(int j = 0; j < 4; j++) {\n            cout << \"A[\" << i << \"][\" << j << \"] = \";\n            cin >> A[i][j];\n        }\n    }\n    \n    // Calcul de la trace\n    for(int i = 0; i < 4; i++) {\n        trace = trace + A[i][i];  // Elements diagonaux\n    }\n    \n    // Affichage\n    cout << \"Trace de A : Tr(A) = \" << trace << endl;\n    \n    return 0;\n}

Explication détaillée :

Étape 1 : Définition de la trace
La trace est la somme des éléments diagonaux :
$Tr(A) = A_{00} + A_{11} + A_{22} + A_{33}$

Étape 2 : Lecture de la matrice
Double boucle pour remplir les $16$ éléments

Étape 3 : Calcul de la trace
Boucle simple sur l'indice $i$ de $0$ à $3$
Accumulation : $trace = trace + A[i][i]$
Note : les indices $i$ et $j$ sont égaux pour la diagonale

Exemple :
Soit la matrice :
$A = \\begin{pmatrix} 5 & 2 & 1 & 3 \\\\ 7 & 9 & 4 & 6 \\\\ 2 & 8 & 3 & 1 \\\\ 4 & 5 & 7 & 2 \\end{pmatrix}$

Éléments diagonaux :
$A[0][0] = 5$
$A[1][1] = 9$
$A[2][2] = 3$
$A[3][3] = 2$

Calcul de la trace :
$Tr(A) = 5 + 9 + 3 + 2 = 19$

Propriété : Pour toute matrice carrée $n \\times n$, la trace est définie par $Tr(A) = \\sum_{i=0}^{n-1} A_{ii}$",
    "id_category": "2",
    "id_number": "6"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui lit un tableau de $n$ entiers (avec $n \\leq 15$) et inverse l'ordre des éléments dans ce tableau. Afficher le tableau avant et après l'inversion.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Programme C++ :
#include <iostream>\nusing namespace std;\n\nint main() {\n    int n;\n    int tab[15];\n    int temp;  // Variable temporaire pour l'échange\n    \n    // Lecture de n\n    cout << \"Entrez n (n <= 15) : \";\n    cin >> n;\n    \n    // Lecture du tableau\n    cout << \"Entrez les elements :\" << endl;\n    for(int i = 0; i < n; i++) {\n        cout << \"Element \" << i << \" : \";\n        cin >> tab[i];\n    }\n    \n    // Affichage avant inversion\n    cout << \"Tableau avant inversion : \";\n    for(int i = 0; i < n; i++) {\n        cout << tab[i] << \" \";\n    }\n    cout << endl;\n    \n    // Inversion du tableau\n    for(int i = 0; i < n/2; i++) {\n        temp = tab[i];\n        tab[i] = tab[n - 1 - i];\n        tab[n - 1 - i] = temp;\n    }\n    \n    // Affichage après inversion\n    cout << \"Tableau apres inversion : \";\n    for(int i = 0; i < n; i++) {\n        cout << tab[i] << \" \";\n    }\n    cout << endl;\n    \n    return 0;\n}

Explication détaillée :

Étape 1 : Principe de l'inversion
Échanger les éléments symétriques :
- $tab[0]$ ↔ $tab[n-1]$
- $tab[1]$ ↔ $tab[n-2]$
- Et ainsi de suite jusqu'au milieu

Étape 2 : Algorithme d'échange
Boucle de $i = 0$ à $i = n/2 - 1$
Pour chaque $i$ :
$temp = tab[i]$ (sauvegarde)
$tab[i] = tab[n-1-i]$ (copie de la fin)
$tab[n-1-i] = temp$ (restitution)

Étape 3 : Exemple pour $n = 5$
Tableau initial : $\\{10, 20, 30, 40, 50\\}$

Itération $i = 0$ :
Échange $tab[0]$ et $tab[4]$ : $\\{50, 20, 30, 40, 10\\}$

Itération $i = 1$ :
Échange $tab[1]$ et $tab[3]$ : $\\{50, 40, 30, 20, 10\\}$

Fin de boucle ($i = 2$ correspond au centre, pas d'échange)

Tableau final : $\\{50, 40, 30, 20, 10\\}$

Remarque : La boucle s'arrête à $n/2$ pour éviter de ré-inverser le tableau en parcourant la deuxième moitié",
    "id_category": "2",
    "id_number": "7"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui lit deux matrices $A$ et $B$ de dimensions $2 \\times 3$ et calcule leur somme $C = A + B$ où $C_{ij} = A_{ij} + B_{ij}$. Afficher la matrice résultante $C$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Programme C++ :
#include <iostream>\nusing namespace std;\n\nint main() {\n    int A[2][3], B[2][3], C[2][3];  // Trois matrices 2x3\n    \n    // Lecture de la matrice A\n    cout << \"Entrez les elements de la matrice A (2x3) :\" << endl;\n    for(int i = 0; i < 2; i++) {\n        for(int j = 0; j < 3; j++) {\n            cout << \"A[\" << i << \"][\" << j << \"] = \";\n            cin >> A[i][j];\n        }\n    }\n    \n    // Lecture de la matrice B\n    cout << \"Entrez les elements de la matrice B (2x3) :\" << endl;\n    for(int i = 0; i < 2; i++) {\n        for(int j = 0; j < 3; j++) {\n            cout << \"B[\" << i << \"][\" << j << \"] = \";\n            cin >> B[i][j];\n        }\n    }\n    \n    // Calcul de la somme C = A + B\n    for(int i = 0; i < 2; i++) {\n        for(int j = 0; j < 3; j++) {\n            C[i][j] = A[i][j] + B[i][j];\n        }\n    }\n    \n    // Affichage de la matrice C\n    cout << \"Matrice C = A + B :\" << endl;\n    for(int i = 0; i < 2; i++) {\n        for(int j = 0; j < 3; j++) {\n            cout << C[i][j] << \" \";\n        }\n        cout << endl;\n    }\n    \n    return 0;\n}

Explication détaillée :

Étape 1 : Déclaration
Trois matrices de dimensions $2 \\times 3$ :
- $A$ : première matrice
- $B$ : deuxième matrice
- $C$ : matrice résultat

Étape 2 : Lecture des matrices
Deux doubles boucles pour remplir $A$ et $B$

Étape 3 : Addition élément par élément
Double boucle pour calculer :
$C[i][j] = A[i][j] + B[i][j]$
Pour tout $i \\in \\{0,1\\}$ et $j \\in \\{0,1,2\\}$

Exemple :
Soit les matrices :
$A = \\begin{pmatrix} 1 & 2 & 3 \\\\ 4 & 5 & 6 \\end{pmatrix}, \\quad B = \\begin{pmatrix} 7 & 8 & 9 \\\\ 10 & 11 & 12 \\end{pmatrix}$

Calcul de la somme :
$C[0][0] = A[0][0] + B[0][0] = 1 + 7 = 8$
$C[0][1] = A[0][1] + B[0][1] = 2 + 8 = 10$
$C[0][2] = A[0][2] + B[0][2] = 3 + 9 = 12$
$C[1][0] = A[1][0] + B[1][0] = 4 + 10 = 14$
$C[1][1] = A[1][1] + B[1][1] = 5 + 11 = 16$
$C[1][2] = A[1][2] + B[1][2] = 6 + 12 = 18$

Matrice résultat :
$C = \\begin{pmatrix} 8 & 10 & 12 \\\\ 14 & 16 & 18 \\end{pmatrix}$",
    "id_category": "2",
    "id_number": "8"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui lit un tableau de $n$ entiers (avec $n \\leq 10$) et calcule la variance $\\sigma^2$ de ces valeurs. Formule : $\\sigma^2 = \\frac{1}{n}\\sum_{i=1}^{n}(x_i - \\mu)^2$ où $\\mu$ est la moyenne.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Programme C++ :
#include <iostream>\n#include <cmath>  // Pour pow()\nusing namespace std;\n\nint main() {\n    int n;\n    float tab[10];\n    float somme = 0, moyenne, variance = 0;\n    \n    // Lecture de n\n    cout << \"Entrez n (n <= 10) : \";\n    cin >> n;\n    \n    // Lecture du tableau\n    cout << \"Entrez les elements :\" << endl;\n    for(int i = 0; i < n; i++) {\n        cout << \"Element \" << i << \" : \";\n        cin >> tab[i];\n        somme = somme + tab[i];\n    }\n    \n    // Calcul de la moyenne\n    moyenne = somme / n;\n    \n    // Calcul de la variance\n    for(int i = 0; i < n; i++) {\n        variance = variance + pow(tab[i] - moyenne, 2);\n    }\n    variance = variance / n;\n    \n    // Affichage\n    cout << \"Moyenne = \" << moyenne << endl;\n    cout << \"Variance = \" << variance << endl;\n    \n    return 0;\n}

Explication détaillée :

Étape 1 : Calcul de la moyenne
Somme de tous les éléments : $somme = \\sum_{i=0}^{n-1} tab[i]$
Moyenne : $\\mu = \\frac{somme}{n}$

Étape 2 : Calcul de la variance
Pour chaque élément, calculer l'écart au carré : $(x_i - \\mu)^2$
Somme de tous les écarts au carré
Division par $n$ : $\\sigma^2 = \\frac{1}{n}\\sum_{i=0}^{n-1}(tab[i] - \\mu)^2$

Étape 3 : Exemple pour $n = 4$
Tableau : $\\{2, 4, 6, 8\\}$

Calcul de la moyenne :
$somme = 2 + 4 + 6 + 8 = 20$
$\\mu = \\frac{20}{4} = 5$

Calcul des écarts au carré :
$(2 - 5)^2 = (-3)^2 = 9$
$(4 - 5)^2 = (-1)^2 = 1$
$(6 - 5)^2 = (1)^2 = 1$
$(8 - 5)^2 = (3)^2 = 9$

Somme des écarts : $9 + 1 + 1 + 9 = 20$

Variance : $\\sigma^2 = \\frac{20}{4} = 5$

Interprétation : La variance mesure la dispersion des données autour de la moyenne. Une variance élevée indique des données très dispersées",
    "id_category": "2",
    "id_number": "9"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui lit un entier $n$ et un nombre réel $x$, puis calcule la valeur de $P_n(x) = 1 + x + x^2 + x^3 + ... + x^n = \\sum_{k=0}^{n} x^k$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Programme C++ :
#include <iostream>\n#include <cmath>  // Pour pow()\nusing namespace std;\n\nint main() {\n    int n;\n    float x, P = 0;\n    \n    // Lecture de n et x\n    cout << \"Entrez n : \";\n    cin >> n;\n    cout << \"Entrez x : \";\n    cin >> x;\n    \n    // Calcul du polynôme\n    for(int k = 0; k <= n; k++) {\n        P = P + pow(x, k);\n    }\n    \n    // Affichage\n    cout << \"P_\" << n << \"(\" << x << \") = \" << P << endl;\n    \n    return 0;\n}

Explication détaillée :

Étape 1 : Formulation du problème
Calculer la somme géométrique : $P_n(x) = \\sum_{k=0}^{n} x^k$

Étape 2 : Algorithme itératif
Boucle de $k = 0$ à $k = n$
À chaque itération : $P = P + x^k$
Utilisation de la fonction $pow(x, k)$ pour calculer $x^k$

Étape 3 : Exemple pour $n = 4$ et $x = 2$

Calcul terme par terme :
$k = 0$ : $x^0 = 2^0 = 1$, $P = 0 + 1 = 1$
$k = 1$ : $x^1 = 2^1 = 2$, $P = 1 + 2 = 3$
$k = 2$ : $x^2 = 2^2 = 4$, $P = 3 + 4 = 7$
$k = 3$ : $x^3 = 2^3 = 8$, $P = 7 + 8 = 15$
$k = 4$ : $x^4 = 2^4 = 16$, $P = 15 + 16 = 31$

Résultat : $P_4(2) = 31$

Vérification avec la formule géométrique :
Pour $x \\neq 1$ : $P_n(x) = \\frac{x^{n+1} - 1}{x - 1}$
Pour $n = 4$ et $x = 2$ :
$P_4(2) = \\frac{2^5 - 1}{2 - 1} = \\frac{32 - 1}{1} = 31$ ✓",
    "id_category": "2",
    "id_number": "10"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui lit une matrice $M$ de dimensions $3 \\times 3$ et vérifie si elle est symétrique, c'est-à-dire si $M_{ij} = M_{ji}$ pour tout $i, j$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Programme C++ :
#include <iostream>\nusing namespace std;\n\nint main() {\n    int M[3][3];\n    bool symetrique = true;\n    \n    // Lecture de la matrice\n    cout << \"Entrez les elements de la matrice 3x3 :\" << endl;\n    for(int i = 0; i < 3; i++) {\n        for(int j = 0; j < 3; j++) {\n            cout << \"M[\" << i << \"][\" << j << \"] = \";\n            cin >> M[i][j];\n        }\n    }\n    \n    // Vérification de la symétrie\n    for(int i = 0; i < 3; i++) {\n        for(int j = 0; j < 3; j++) {\n            if(M[i][j] != M[j][i]) {\n                symetrique = false;\n                break;\n            }\n        }\n        if(!symetrique) break;\n    }\n    \n    // Affichage du résultat\n    if(symetrique) {\n        cout << \"La matrice est symetrique\" << endl;\n    }\n    else {\n        cout << \"La matrice n'est pas symetrique\" << endl;\n    }\n    \n    return 0;\n}

Explication détaillée :

Étape 1 : Définition de la symétrie
Une matrice $M$ est symétrique si : $M^T = M$
Condition équivalente : $M_{ij} = M_{ji}$ pour tout $i, j$

Étape 2 : Algorithme de vérification
Initialisation : $symetrique = true$
Double boucle pour tester chaque paire $(i, j)$
Si $M[i][j] \\neq M[j][i]$, alors $symetrique = false$ et sortie

Étape 3 : Optimisation
Il suffit de vérifier pour $i < j$ (triangle supérieur)
Instruction $break$ pour arrêter dès qu'une asymétrie est détectée

Exemple 1 - Matrice symétrique :
$M = \\begin{pmatrix} 4 & 1 & 2 \\\\ 1 & 5 & 3 \\\\ 2 & 3 & 6 \\end{pmatrix}$

Vérifications :
$M[0][1] = 1 = M[1][0]$ ✓
$M[0][2] = 2 = M[2][0]$ ✓
$M[1][2] = 3 = M[2][1]$ ✓

Résultat : La matrice est symétrique

Exemple 2 - Matrice non symétrique :
$M = \\begin{pmatrix} 1 & 2 & 3 \\\\ 4 & 5 & 6 \\\\ 7 & 8 & 9 \\end{pmatrix}$

Test : $M[0][1] = 2 \\neq 4 = M[1][0]$

Résultat : La matrice n'est pas symétrique",
    "id_category": "2",
    "id_number": "11"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui lit un tableau de $n$ entiers (avec $n \\leq 12$) et trouve tous les éléments qui apparaissent plus d'une fois (les doublons). Afficher ces éléments sans répétition.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Programme C++ :
#include <iostream>\nusing namespace std;\n\nint main() {\n    int n;\n    int tab[12];\n    bool deja_affiche[12] = {false};  // Marquer les doublons affichés\n    \n    // Lecture de n\n    cout << \"Entrez n (n <= 12) : \";\n    cin >> n;\n    \n    // Lecture du tableau\n    cout << \"Entrez les elements :\" << endl;\n    for(int i = 0; i < n; i++) {\n        cout << \"Element \" << i << \" : \";\n        cin >> tab[i];\n    }\n    \n    // Recherche et affichage des doublons\n    cout << \"Elements en double : \";\n    bool doublon_trouve = false;\n    \n    for(int i = 0; i < n; i++) {\n        if(!deja_affiche[i]) {\n            int compteur = 0;\n            // Compter les occurrences de tab[i]\n            for(int j = 0; j < n; j++) {\n                if(tab[j] == tab[i]) {\n                    compteur++;\n                    if(j != i) deja_affiche[j] = true;\n                }\n            }\n            // Si apparaît plus d'une fois\n            if(compteur > 1) {\n                cout << tab[i] << \" \";\n                doublon_trouve = true;\n            }\n        }\n    }\n    \n    if(!doublon_trouve) {\n        cout << \"Aucun\";\n    }\n    cout << endl;\n    \n    return 0;\n}

Explication détaillée :

Étape 1 : Stratégie de détection
Pour chaque élément $tab[i]$ :
- Compter combien de fois il apparaît dans le tableau
- Si le compteur $> 1$, c'est un doublon
- Utiliser un tableau booléen pour éviter d'afficher plusieurs fois le même doublon

Étape 2 : Algorithme de comptage
Boucle externe : parcours de $i = 0$ à $i = n-1$
Boucle interne : comptage des occurrences de $tab[i]$
Si $compteur > 1$ et pas déjà affiché, afficher $tab[i]$

Étape 3 : Exemple pour $n = 8$
Tableau : $\\{5, 3, 7, 3, 5, 9, 5, 2\\}$

Analyse élément par élément :

Position $i = 0$, valeur $5$ :
Comptage : positions $0, 4, 6$ → compteur $= 3 > 1$
Affichage : $5$
Marquage des positions $4$ et $6$

Position $i = 1$, valeur $3$ :
Comptage : positions $1, 3$ → compteur $= 2 > 1$
Affichage : $3$
Marquage de la position $3$

Position $i = 2$, valeur $7$ :
Comptage : position $2$ uniquement → compteur $= 1$
Pas d'affichage

Positions $3, 4, 5, 6, 7$ : déjà traitées ou uniques

Résultat final : Éléments en double : $5$ $3$",
    "id_category": "2",
    "id_number": "12"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui lit deux matrices $A$ de dimensions $2 \\times 3$ et $B$ de dimensions $3 \\times 2$, puis calcule leur produit matriciel $C = A \\times B$ où $C_{ij} = \\sum_{k=0}^{2} A_{ik} \\times B_{kj}$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Programme C++ :
#include <iostream>\nusing namespace std;\n\nint main() {\n    int A[2][3], B[3][2], C[2][2];\n    \n    // Lecture de la matrice A (2x3)\n    cout << \"Entrez les elements de la matrice A (2x3) :\" << endl;\n    for(int i = 0; i < 2; i++) {\n        for(int j = 0; j < 3; j++) {\n            cout << \"A[\" << i << \"][\" << j << \"] = \";\n            cin >> A[i][j];\n        }\n    }\n    \n    // Lecture de la matrice B (3x2)\n    cout << \"Entrez les elements de la matrice B (3x2) :\" << endl;\n    for(int i = 0; i < 3; i++) {\n        for(int j = 0; j < 2; j++) {\n            cout << \"B[\" << i << \"][\" << j << \"] = \";\n            cin >> B[i][j];\n        }\n    }\n    \n    // Calcul du produit C = A x B\n    for(int i = 0; i < 2; i++) {\n        for(int j = 0; j < 2; j++) {\n            C[i][j] = 0;  // Initialisation\n            for(int k = 0; k < 3; k++) {\n                C[i][j] = C[i][j] + A[i][k] * B[k][j];\n            }\n        }\n    }\n    \n    // Affichage de la matrice C\n    cout << \"Matrice C = A x B (2x2) :\" << endl;\n    for(int i = 0; i < 2; i++) {\n        for(int j = 0; j < 2; j++) {\n            cout << C[i][j] << \" \";\n        }\n        cout << endl;\n    }\n    \n    return 0;\n}

Explication détaillée :

Étape 1 : Compatibilité des dimensions
Produit $A \\times B$ possible car :
- $A$ est $2 \\times 3$
- $B$ est $3 \\times 2$
- Nombre de colonnes de $A$ = nombre de lignes de $B$ = $3$
- Résultat $C$ est $2 \\times 2$

Étape 2 : Formule du produit matriciel
Pour chaque élément $C_{ij}$ :
$C_{ij} = \\sum_{k=0}^{2} A_{ik} \\times B_{kj}$
Triple boucle imbriquée :
- Boucle $i$ : lignes de $C$
- Boucle $j$ : colonnes de $C$
- Boucle $k$ : somme des produits

Étape 3 : Exemple numérique
Soit :
$A = \\begin{pmatrix} 1 & 2 & 3 \\\\ 4 & 5 & 6 \\end{pmatrix}, \\quad B = \\begin{pmatrix} 7 & 8 \\\\ 9 & 10 \\\\ 11 & 12 \\end{pmatrix}$

Calcul de $C_{00}$ :
$C_{00} = A_{00} \\times B_{00} + A_{01} \\times B_{10} + A_{02} \\times B_{20}$
$C_{00} = 1 \\times 7 + 2 \\times 9 + 3 \\times 11 = 7 + 18 + 33 = 58$

Calcul de $C_{01}$ :
$C_{01} = A_{00} \\times B_{01} + A_{01} \\times B_{11} + A_{02} \\times B_{21}$
$C_{01} = 1 \\times 8 + 2 \\times 10 + 3 \\times 12 = 8 + 20 + 36 = 64$

Calcul de $C_{10}$ :
$C_{10} = A_{10} \\times B_{00} + A_{11} \\times B_{10} + A_{12} \\times B_{20}$
$C_{10} = 4 \\times 7 + 5 \\times 9 + 6 \\times 11 = 28 + 45 + 66 = 139$

Calcul de $C_{11}$ :
$C_{11} = A_{10} \\times B_{01} + A_{11} \\times B_{11} + A_{12} \\times B_{21}$
$C_{11} = 4 \\times 8 + 5 \\times 10 + 6 \\times 12 = 32 + 50 + 72 = 154$

Matrice résultat :
$C = \\begin{pmatrix} 58 & 64 \\\\ 139 & 154 \\end{pmatrix}$",
    "id_category": "2",
    "id_number": "13"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui lit un tableau de $n$ entiers positifs (avec $n \\leq 10$) et calcule le PGCD (Plus Grand Commun Diviseur) de tous ces nombres en utilisant l'algorithme d'Euclide itératif.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Programme C++ :
#include <iostream>\nusing namespace std;\n\n// Fonction pour calculer le PGCD de deux nombres\nint pgcd(int a, int b) {\n    while(b != 0) {\n        int temp = b;\n        b = a % b;\n        a = temp;\n    }\n    return a;\n}\n\nint main() {\n    int n;\n    int tab[10];\n    int resultat;\n    \n    // Lecture de n\n    cout << \"Entrez n (n <= 10) : \";\n    cin >> n;\n    \n    // Lecture du tableau\n    cout << \"Entrez \" << n << \" entiers positifs :\" << endl;\n    for(int i = 0; i < n; i++) {\n        cout << \"Element \" << i << \" : \";\n        cin >> tab[i];\n    }\n    \n    // Calcul du PGCD de tous les éléments\n    resultat = tab[0];\n    for(int i = 1; i < n; i++) {\n        resultat = pgcd(resultat, tab[i]);\n    }\n    \n    // Affichage\n    cout << \"PGCD de tous les elements : \" << resultat << endl;\n    \n    return 0;\n}

Explication détaillée :

Étape 1 : Algorithme d'Euclide
Pour calculer $pgcd(a, b)$ :
Tant que $b \\neq 0$ :
- Sauvegarder $b$ dans $temp$
- $b = a\\ \\%\\ b$ (reste de la division)
- $a = temp$
Retourner $a$

Étape 2 : Propriété du PGCD
$pgcd(a_1, a_2, ..., a_n) = pgcd(...pgcd(pgcd(a_1, a_2), a_3)..., a_n)$
Application itérative : calculer le PGCD cumulatif

Étape 3 : Exemple pour $n = 4$
Tableau : $\\{48, 36, 60, 24\\}$

Initialisation : $resultat = tab[0] = 48$

Itération $i = 1$ : $resultat = pgcd(48, 36)$
Calcul de $pgcd(48, 36)$ :
- $a = 48, b = 36$
- $48\\ \\%\\ 36 = 12$ → $a = 36, b = 12$
- $36\\ \\%\\ 12 = 0$ → $a = 12, b = 0$
- Résultat : $12$
Donc $resultat = 12$

Itération $i = 2$ : $resultat = pgcd(12, 60)$
Calcul de $pgcd(12, 60)$ :
- $a = 12, b = 60$
- $12\\ \\%\\ 60 = 12$ → $a = 60, b = 12$
- $60\\ \\%\\ 12 = 0$ → $a = 12, b = 0$
- Résultat : $12$
Donc $resultat = 12$

Itération $i = 3$ : $resultat = pgcd(12, 24)$
Calcul de $pgcd(12, 24)$ :
- $a = 12, b = 24$
- $12\\ \\%\\ 24 = 12$ → $a = 24, b = 12$
- $24\\ \\%\\ 12 = 0$ → $a = 12, b = 0$
- Résultat : $12$

Résultat final : $PGCD(48, 36, 60, 24) = 12$",
    "id_category": "2",
    "id_number": "14"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui lit un tableau de $n$ entiers (avec $n \\leq 10$) et le trie par ordre croissant en utilisant l'algorithme du tri à bulles (bubble sort). Afficher le tableau avant et après le tri.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Programme C++ :
#include <iostream>\nusing namespace std;\n\nint main() {\n    int n;\n    int tab[10];\n    int temp;\n    \n    // Lecture de n\n    cout << \"Entrez n (n <= 10) : \";\n    cin >> n;\n    \n    // Lecture du tableau\n    cout << \"Entrez les elements :\" << endl;\n    for(int i = 0; i < n; i++) {\n        cout << \"Element \" << i << \" : \";\n        cin >> tab[i];\n    }\n    \n    // Affichage avant tri\n    cout << \"Tableau avant tri : \";\n    for(int i = 0; i < n; i++) {\n        cout << tab[i] << \" \";\n    }\n    cout << endl;\n    \n    // Tri à bulles\n    for(int i = 0; i < n-1; i++) {\n        for(int j = 0; j < n-1-i; j++) {\n            if(tab[j] > tab[j+1]) {\n                // Échange\n                temp = tab[j];\n                tab[j] = tab[j+1];\n                tab[j+1] = temp;\n            }\n        }\n    }\n    \n    // Affichage après tri\n    cout << \"Tableau apres tri : \";\n    for(int i = 0; i < n; i++) {\n        cout << tab[i] << \" \";\n    }\n    cout << endl;\n    \n    return 0;\n}

Explication détaillée :

Étape 1 : Principe du tri à bulles
Comparer les éléments adjacents
Si $tab[j] > tab[j+1]$, les échanger
Répéter jusqu'à ce que le tableau soit trié
À chaque passage, le plus grand élément \"remonte\" à la fin

Étape 2 : Structure de l'algorithme
Boucle externe : $i$ de $0$ à $n-2$ (nombre de passages)
Boucle interne : $j$ de $0$ à $n-2-i$ (comparaisons)
Optimisation : à chaque passage, les $i$ derniers éléments sont déjà triés

Étape 3 : Exemple pour $n = 5$
Tableau initial : $\\{64, 34, 25, 12, 22\\}$

Passage $i = 0$ :
$j = 0$ : $64 > 34$ → échange → $\\{34, 64, 25, 12, 22\\}$
$j = 1$ : $64 > 25$ → échange → $\\{34, 25, 64, 12, 22\\}$
$j = 2$ : $64 > 12$ → échange → $\\{34, 25, 12, 64, 22\\}$
$j = 3$ : $64 > 22$ → échange → $\\{34, 25, 12, 22, 64\\}$

Passage $i = 1$ :
$j = 0$ : $34 > 25$ → échange → $\\{25, 34, 12, 22, 64\\}$
$j = 1$ : $34 > 12$ → échange → $\\{25, 12, 34, 22, 64\\}$
$j = 2$ : $34 > 22$ → échange → $\\{25, 12, 22, 34, 64\\}$

Passage $i = 2$ :
$j = 0$ : $25 > 12$ → échange → $\\{12, 25, 22, 34, 64\\}$
$j = 1$ : $25 > 22$ → échange → $\\{12, 22, 25, 34, 64\\}$

Passage $i = 3$ :
$j = 0$ : $12 < 22$ → pas d'échange

Tableau final trié : $\\{12, 22, 25, 34, 64\\}$

Complexité : $O(n^2)$ dans le pire cas",
    "id_category": "2",
    "id_number": "15"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui lit une matrice carrée $M$ de dimension $3 \\times 3$ et calcule la somme de sa diagonale secondaire $S_d = \\sum_{i=0}^{2} M_{i,(2-i)}$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Programme C++ :
#include <iostream>\nusing namespace std;\n\nint main() {\n    int M[3][3];\n    int S_d = 0;  // Somme diagonale secondaire\n    \n    // Lecture de la matrice\n    cout << \"Entrez les elements de la matrice 3x3 :\" << endl;\n    for(int i = 0; i < 3; i++) {\n        for(int j = 0; j < 3; j++) {\n            cout << \"M[\" << i << \"][\" << j << \"] = \";\n            cin >> M[i][j];\n        }\n    }\n    \n    // Calcul de la somme de la diagonale secondaire\n    for(int i = 0; i < 3; i++) {\n        S_d = S_d + M[i][2-i];\n    }\n    \n    // Affichage\n    cout << \"Somme de la diagonale secondaire : \" << S_d << endl;\n    \n    return 0;\n}

Explication détaillée :

Étape 1 : Définition de la diagonale secondaire
Pour une matrice $3 \\times 3$, la diagonale secondaire contient :
- $M[0][2]$ (coin supérieur droit)
- $M[1][1]$ (centre)
- $M[2][0]$ (coin inférieur gauche)

Formule générale : Élément $(i, j)$ avec $i + j = n - 1$
Pour $n = 3$ : $j = 2 - i$

Étape 2 : Algorithme de calcul
Boucle de $i = 0$ à $i = 2$
À chaque itération : accumuler $M[i][2-i]$

Étape 3 : Exemple numérique
Soit la matrice :
$M = \\begin{pmatrix} 1 & 2 & 3 \\\\ 4 & 5 & 6 \\\\ 7 & 8 & 9 \\end{pmatrix}$

Identification des éléments de la diagonale secondaire :
Pour $i = 0$ : $j = 2 - 0 = 2$ → $M[0][2] = 3$
Pour $i = 1$ : $j = 2 - 1 = 1$ → $M[1][1] = 5$
Pour $i = 2$ : $j = 2 - 2 = 0$ → $M[2][0] = 7$

Visualisation :
$\\begin{pmatrix} 1 & 2 & \\mathbf{3} \\\\ 4 & \\mathbf{5} & 6 \\\\ \\mathbf{7} & 8 & 9 \\end{pmatrix}$

Calcul de la somme :
$S_d = M[0][2] + M[1][1] + M[2][0]$
$S_d = 3 + 5 + 7 = 15$

Généralisation : Pour une matrice $n \\times n$, la formule devient :
$S_d = \\sum_{i=0}^{n-1} M_{i,(n-1-i)}$",
    "id_category": "2",
    "id_number": "16"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui lit un entier $n$ et génère les $n$ premiers termes de la suite de Fibonacci. Rappel : $F_0 = 0$, $F_1 = 1$, $F_k = F_{k-1} + F_{k-2}$ pour $k \\geq 2$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Programme C++ :
#include <iostream>\nusing namespace std;\n\nint main() {\n    int n;\n    long long F[50];  // Tableau pour stocker les termes\n    \n    // Lecture de n\n    cout << \"Entrez n (n <= 50) : \";\n    cin >> n;\n    \n    // Cas particuliers\n    if(n >= 1) F[0] = 0;\n    if(n >= 2) F[1] = 1;\n    \n    // Calcul des termes suivants\n    for(int k = 2; k < n; k++) {\n        F[k] = F[k-1] + F[k-2];\n    }\n    \n    // Affichage de la suite\n    cout << \"Les \" << n << \" premiers termes de Fibonacci :\" << endl;\n    for(int i = 0; i < n; i++) {\n        cout << \"F_\" << i << \" = \" << F[i] << endl;\n    }\n    \n    return 0;\n}

Explication détaillée :

Étape 1 : Définition de la suite de Fibonacci
Initialisation :
$F_0 = 0$
$F_1 = 1$
Relation de récurrence : $F_k = F_{k-1} + F_{k-2}$ pour $k \\geq 2$

Étape 2 : Stockage dans un tableau
Utilisation d'un tableau $F[50]$ de type $long\\ long$
Les termes de Fibonacci croissent rapidement

Étape 3 : Algorithme itératif
Initialisation des deux premiers termes
Boucle de $k = 2$ à $k = n-1$
Calcul : $F[k] = F[k-1] + F[k-2]$

Étape 4 : Exemple pour $n = 10$

Initialisation :
$F[0] = 0$
$F[1] = 1$

Itérations :
$k = 2$ : $F[2] = F[1] + F[0] = 1 + 0 = 1$
$k = 3$ : $F[3] = F[2] + F[1] = 1 + 1 = 2$
$k = 4$ : $F[4] = F[3] + F[2] = 2 + 1 = 3$
$k = 5$ : $F[5] = F[4] + F[3] = 3 + 2 = 5$
$k = 6$ : $F[6] = F[5] + F[4] = 5 + 3 = 8$
$k = 7$ : $F[7] = F[6] + F[5] = 8 + 5 = 13$
$k = 8$ : $F[8] = F[7] + F[6] = 13 + 8 = 21$
$k = 9$ : $F[9] = F[8] + F[7] = 21 + 13 = 34$

Suite des 10 premiers termes :
$\\{0, 1, 1, 2, 3, 5, 8, 13, 21, 34\\}$

Remarque : La formule de Binet permet un calcul direct : $F_n = \\frac{\\phi^n - \\psi^n}{\\sqrt{5}}$ où $\\phi = \\frac{1+\\sqrt{5}}{2}$ et $\\psi = \\frac{1-\\sqrt{5}}{2}$",
    "id_category": "2",
    "id_number": "17"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui lit un tableau de $n$ nombres réels (avec $n \\leq 10$) et calcule l'écart-type $\\sigma$. Formule : $\\sigma = \\sqrt{\\frac{1}{n}\\sum_{i=1}^{n}(x_i - \\mu)^2}$ où $\\mu$ est la moyenne.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Programme C++ :
#include <iostream>\n#include <cmath>  // Pour sqrt() et pow()\nusing namespace std;\n\nint main() {\n    int n;\n    float tab[10];\n    float somme = 0, moyenne, variance = 0, ecart_type;\n    \n    // Lecture de n\n    cout << \"Entrez n (n <= 10) : \";\n    cin >> n;\n    \n    // Lecture du tableau\n    cout << \"Entrez les elements :\" << endl;\n    for(int i = 0; i < n; i++) {\n        cout << \"Element \" << i << \" : \";\n        cin >> tab[i];\n        somme = somme + tab[i];\n    }\n    \n    // Calcul de la moyenne\n    moyenne = somme / n;\n    \n    // Calcul de la variance\n    for(int i = 0; i < n; i++) {\n        variance = variance + pow(tab[i] - moyenne, 2);\n    }\n    variance = variance / n;\n    \n    // Calcul de l'écart-type\n    ecart_type = sqrt(variance);\n    \n    // Affichage\n    cout << \"Moyenne = \" << moyenne << endl;\n    cout << \"Variance = \" << variance << endl;\n    cout << \"Ecart-type = \" << ecart_type << endl;\n    \n    return 0;\n}

Explication détaillée :

Étape 1 : Calcul de la moyenne
Somme de tous les éléments : $somme = \\sum_{i=0}^{n-1} tab[i]$
Moyenne : $\\mu = \\frac{somme}{n}$

Étape 2 : Calcul de la variance
Pour chaque élément, calculer $(x_i - \\mu)^2$
Somme des carrés des écarts
Variance : $\\sigma^2 = \\frac{1}{n}\\sum_{i=0}^{n-1}(tab[i] - \\mu)^2$

Étape 3 : Calcul de l'écart-type
Écart-type : $\\sigma = \\sqrt{\\sigma^2}$
Utilisation de la fonction $sqrt()$ de $cmath$

Étape 4 : Exemple pour $n = 5$
Tableau : $\\{10.0, 12.0, 23.0, 23.0, 16.0\\}$

Calcul de la moyenne :
$somme = 10 + 12 + 23 + 23 + 16 = 84$
$\\mu = \\frac{84}{5} = 16.8$

Calcul des écarts au carré :
$(10 - 16.8)^2 = (-6.8)^2 = 46.24$
$(12 - 16.8)^2 = (-4.8)^2 = 23.04$
$(23 - 16.8)^2 = (6.2)^2 = 38.44$
$(23 - 16.8)^2 = (6.2)^2 = 38.44$
$(16 - 16.8)^2 = (-0.8)^2 = 0.64$

Somme des écarts au carré :
$46.24 + 23.04 + 38.44 + 38.44 + 0.64 = 146.8$

Variance :
$\\sigma^2 = \\frac{146.8}{5} = 29.36$

Écart-type :
$\\sigma = \\sqrt{29.36} \\approx 5.418$

Interprétation : L'écart-type mesure la dispersion des données. Plus $\\sigma$ est grand, plus les données sont dispersées autour de la moyenne",
    "id_category": "2",
    "id_number": "18"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui lit un entier $n$ et calcule la somme $S = 1 + 2 + 3 + ... + n$. Afficher le résultat.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code C++ :
#include <iostream>\nusing namespace std;\n\nint main() {\n    int n;\n    int somme = 0;\n    \n    // Lecture de n\n    cout << \"Entrez un entier n : \";\n    cin >> n;\n    \n    // Calcul de la somme avec une boucle\n    for(int i = 1; i <= n; i++) {\n        somme = somme + i;  // Accumulation\n    }\n    \n    // Affichage du résultat\n    cout << \"La somme de 1 a \" << n << \" est : \" << somme << endl;\n    \n    return 0;\n}

Explication détaillée :

Variables :
- $n$ : entier saisi par l'utilisateur
- $somme$ : accumulateur initialisé à $0$
- $i$ : compteur de boucle

Algorithme :
1. Initialisation : $somme = 0$
2. Pour chaque $i$ de $1$ à $n$, on ajoute $i$ à $somme$
3. Formule appliquée : $somme_{k} = somme_{k-1} + k$

Exemple pour $n = 5$ :
Itération 1 : $somme = 0 + 1 = 1$
Itération 2 : $somme = 1 + 2 = 3$
Itération 3 : $somme = 3 + 3 = 6$
Itération 4 : $somme = 6 + 4 = 10$
Itération 5 : $somme = 10 + 5 = 15$

Résultat : $S = 15$

Vérification mathématique :
Formule directe : $S = \\frac{n(n+1)}{2} = \\frac{5 \\times 6}{2} = 15$",
    "id_category": "2",
    "id_number": "19"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui lit un entier $n$ et calcule la factorielle $n! = n \\times (n-1) \\times (n-2) \\times ... \\times 1$. Afficher le résultat.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code C++ :
#include <iostream>\nusing namespace std;\n\nint main() {\n    int n;\n    long long factorielle = 1;  // long long pour grands nombres\n    \n    // Lecture de n\n    cout << \"Entrez un entier n : \";\n    cin >> n;\n    \n    // Vérification\n    if(n < 0) {\n        cout << \"Erreur : n doit etre positif\" << endl;\n        return 1;\n    }\n    \n    // Calcul de la factorielle\n    for(int i = 1; i <= n; i++) {\n        factorielle = factorielle * i;  // Multiplication successive\n    }\n    \n    // Affichage\n    cout << n << \"! = \" << factorielle << endl;\n    \n    return 0;\n}

Explication détaillée :

Variables :
- $n$ : entier saisi
- $factorielle$ : produit accumulé, initialisé à $1$
- $i$ : compteur de $1$ à $n$

Algorithme :
1. Initialisation : $factorielle = 1$
2. Pour chaque $i$ de $1$ à $n$ : $factorielle = factorielle \\times i$

Exemple pour $n = 6$ :
Itération 1 : $factorielle = 1 \\times 1 = 1$
Itération 2 : $factorielle = 1 \\times 2 = 2$
Itération 3 : $factorielle = 2 \\times 3 = 6$
Itération 4 : $factorielle = 6 \\times 4 = 24$
Itération 5 : $factorielle = 24 \\times 5 = 120$
Itération 6 : $factorielle = 120 \\times 6 = 720$

Résultat : $6! = 720$",
    "id_category": "2",
    "id_number": "20"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui lit deux entiers $a$ et $b$, puis calcule et affiche leur PGCD (Plus Grand Commun Diviseur) en utilisant l'algorithme d'Euclide.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code C++ :
#include <iostream>\nusing namespace std;\n\nint main() {\n    int a, b;\n    int temp;\n    \n    // Lecture des deux entiers\n    cout << \"Entrez a : \";\n    cin >> a;\n    cout << \"Entrez b : \";\n    cin >> b;\n    \n    // Algorithme d'Euclide\n    int x = a;  // Copie pour ne pas modifier a\n    int y = b;  // Copie pour ne pas modifier b\n    \n    while(y != 0) {\n        temp = y;\n        y = x % y;  // Reste de la division\n        x = temp;\n    }\n    \n    // x contient le PGCD\n    cout << \"PGCD(\" << a << \", \" << b << \") = \" << x << endl;\n    \n    return 0;\n}

Explication détaillée :

Principe de l'algorithme d'Euclide :
Pour deux entiers $a$ et $b$ : $PGCD(a, b) = PGCD(b, a \\mod b)$
On répète jusqu'à ce que le reste soit $0$

Variables :
- $a, b$ : les deux entiers saisis
- $x, y$ : copies de travail
- $temp$ : variable temporaire pour l'échange

Exemple pour $a = 48$ et $b = 18$ :

Étape 1 : $x = 48$, $y = 18$
Calcul : $48 \\mod 18 = 12$
Mise à jour : $x = 18$, $y = 12$

Étape 2 : $x = 18$, $y = 12$
Calcul : $18 \\mod 12 = 6$
Mise à jour : $x = 12$, $y = 6$

Étape 3 : $x = 12$, $y = 6$
Calcul : $12 \\mod 6 = 0$
Mise à jour : $x = 6$, $y = 0$

Fin de boucle car $y = 0$

Résultat : $PGCD(48, 18) = 6$",
    "id_category": "2",
    "id_number": "21"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui lit un entier $n$ et calcule la somme des carrés $S = 1^2 + 2^2 + 3^2 + ... + n^2$. Afficher le résultat et vérifier avec la formule théorique.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code C++ :
#include <iostream>\nusing namespace std;\n\nint main() {\n    int n;\n    long long somme = 0;\n    \n    // Lecture de n\n    cout << \"Entrez n : \";\n    cin >> n;\n    \n    // Calcul de la somme des carrés\n    for(int i = 1; i <= n; i++) {\n        somme = somme + i * i;  // Ajouter i²\n    }\n    \n    cout << \"Somme des carres de 1 a \" << n << \" : \" << somme << endl;\n    \n    // Vérification avec formule théorique\n    long long formule = (n * (n + 1) * (2 * n + 1)) / 6;\n    cout << \"Verification par formule : \" << formule << endl;\n    \n    return 0;\n}

Explication détaillée :

Variables :
- $n$ : entier saisi
- $somme$ : accumulateur des carrés
- $i$ : compteur de boucle

Algorithme :
Pour chaque $i$ de $1$ à $n$ : $somme = somme + i^2$

Exemple pour $n = 4$ :

Itération 1 : $somme = 0 + 1^2 = 0 + 1 = 1$
Itération 2 : $somme = 1 + 2^2 = 1 + 4 = 5$
Itération 3 : $somme = 5 + 3^2 = 5 + 9 = 14$
Itération 4 : $somme = 14 + 4^2 = 14 + 16 = 30$

Résultat par boucle : $S = 30$

Vérification par formule théorique :
Formule : $S = \\frac{n(n+1)(2n+1)}{6}$

Application pour $n = 4$ :
$S = \\frac{4 \\times 5 \\times 9}{6} = \\frac{180}{6} = 30$

Confirmation : Les deux méthodes donnent $S = 30$",
    "id_category": "2",
    "id_number": "22"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui lit un entier $n$ et détermine s'il est premier. Un nombre est premier s'il n'est divisible que par $1$ et lui-même.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code C++ :
#include <iostream>\n#include <cmath>\nusing namespace std;\n\nint main() {\n    int n;\n    bool est_premier = true;\n    \n    // Lecture de n\n    cout << \"Entrez un entier n : \";\n    cin >> n;\n    \n    // Cas particuliers\n    if(n < 2) {\n        est_premier = false;\n    }\n    else {\n        // Test de divisibilité de 2 à sqrt(n)\n        int limite = sqrt(n);\n        for(int i = 2; i <= limite; i++) {\n            if(n % i == 0) {  // Si n est divisible par i\n                est_premier = false;\n                break;  // Inutile de continuer\n            }\n        }\n    }\n    \n    // Affichage du résultat\n    if(est_premier)\n        cout << n << \" est premier\" << endl;\n    else\n        cout << n << \" n'est pas premier\" << endl;\n    \n    return 0;\n}

Explication détaillée :

Principe :
Un nombre $n$ est premier si aucun entier $k$ tel que $2 \\leq k \\leq \\sqrt{n}$ ne divise $n$

Variables :
- $n$ : nombre à tester
- $est\\_premier$ : booléen initialisé à $true$
- $limite = \\sqrt{n}$ : borne supérieure des tests

Exemple pour $n = 29$ :

Calcul de la limite : $\\sqrt{29} \\approx 5.38$, donc $limite = 5$

Tests de divisibilité :
- $29 \\mod 2 = 1$ (non divisible)
- $29 \\mod 3 = 2$ (non divisible)
- $29 \\mod 4 = 1$ (non divisible)
- $29 \\mod 5 = 4$ (non divisible)

Aucun diviseur trouvé, donc $est\\_premier$ reste $true$

Résultat : $29$ est premier

Exemple pour $n = 24$ :
$\\sqrt{24} \\approx 4.89$, donc $limite = 4$
Test : $24 \\mod 2 = 0$
Diviseur trouvé immédiatement : $24$ n'est pas premier",
    "id_category": "2",
    "id_number": "23"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui lit $n$ nombres réels dans un tableau, puis calcule et affiche leur moyenne arithmétique $\\mu = \\frac{1}{n}\\sum_{i=1}^{n} x_i$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code C++ :
#include <iostream>\nusing namespace std;\n\nint main() {\n    int n;\n    \n    // Lecture de la taille\n    cout << \"Entrez le nombre d'elements : \";\n    cin >> n;\n    \n    // Déclaration du tableau\n    double tableau[n];\n    double somme = 0.0;\n    \n    // Lecture des éléments\n    cout << \"Entrez les \" << n << \" nombres :\" << endl;\n    for(int i = 0; i < n; i++) {\n        cout << \"Element [\" << i << \"] : \";\n        cin >> tableau[i];\n        somme = somme + tableau[i];  // Accumulation\n    }\n    \n    // Calcul de la moyenne\n    double moyenne = somme / n;\n    \n    // Affichage\n    cout << \"La moyenne est : \" << moyenne << endl;\n    \n    return 0;\n}

Explication détaillée :

Variables :
- $n$ : nombre d'éléments
- $tableau[n]$ : tableau de réels
- $somme$ : somme des éléments
- $moyenne$ : résultat final

Formule :
$\\mu = \\frac{1}{n}\\sum_{i=1}^{n} x_i = \\frac{x_1 + x_2 + ... + x_n}{n}$

Exemple avec $n = 5$ et les valeurs $[12.5, 15.0, 10.5, 18.0, 14.0]$ :

Étape 1 : Lecture et accumulation
- $i = 0$ : $tableau[0] = 12.5$, $somme = 0.0 + 12.5 = 12.5$
- $i = 1$ : $tableau[1] = 15.0$, $somme = 12.5 + 15.0 = 27.5$
- $i = 2$ : $tableau[2] = 10.5$, $somme = 27.5 + 10.5 = 38.0$
- $i = 3$ : $tableau[3] = 18.0$, $somme = 38.0 + 18.0 = 56.0$
- $i = 4$ : $tableau[4] = 14.0$, $somme = 56.0 + 14.0 = 70.0$

Étape 2 : Calcul de la moyenne
$\\mu = \\frac{somme}{n} = \\frac{70.0}{5} = 14.0$

Résultat : La moyenne est $\\mu = 14.0$",
    "id_category": "2",
    "id_number": "24"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui lit $n$ entiers dans un tableau, puis trouve et affiche le maximum et le minimum du tableau avec leurs positions.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code C++ :
#include <iostream>\nusing namespace std;\n\nint main() {\n    int n;\n    \n    cout << \"Entrez la taille du tableau : \";\n    cin >> n;\n    \n    int tableau[n];\n    \n    // Lecture des éléments\n    cout << \"Entrez les elements :\" << endl;\n    for(int i = 0; i < n; i++) {\n        cout << \"Element [\" << i << \"] : \";\n        cin >> tableau[i];\n    }\n    \n    // Initialisation avec le premier élément\n    int max = tableau[0];\n    int min = tableau[0];\n    int pos_max = 0;\n    int pos_min = 0;\n    \n    // Parcours du tableau\n    for(int i = 1; i < n; i++) {\n        if(tableau[i] > max) {\n            max = tableau[i];\n            pos_max = i;\n        }\n        if(tableau[i] < min) {\n            min = tableau[i];\n            pos_min = i;\n        }\n    }\n    \n    // Affichage des résultats\n    cout << \"Maximum : \" << max << \" a la position \" << pos_max << endl;\n    cout << \"Minimum : \" << min << \" a la position \" << pos_min << endl;\n    \n    return 0;\n}

Explication détaillée :

Variables :
- $tableau[n]$ : tableau d'entiers
- $max, min$ : valeurs extrêmes
- $pos\\_max, pos\\_min$ : indices des extrêmes

Algorithme :
1. Initialisation avec $tableau[0]$
2. Parcours de $i = 1$ à $n-1$
3. Mise à jour si élément plus grand ou plus petit

Exemple avec $n = 6$ et $tableau = [45, 12, 78, 23, 90, 34]$ :

Initialisation :
$max = 45$, $pos\\_max = 0$
$min = 45$, $pos\\_min = 0$

Parcours :

$i = 1$ : $tableau[1] = 12$
- $12 < 45$ donc $min = 12$, $pos\\_min = 1$

$i = 2$ : $tableau[2] = 78$
- $78 > 45$ donc $max = 78$, $pos\\_max = 2$

$i = 3$ : $tableau[3] = 23$
- Pas de changement

$i = 4$ : $tableau[4] = 90$
- $90 > 78$ donc $max = 90$, $pos\\_max = 4$

$i = 5$ : $tableau[5] = 34$
- Pas de changement

Résultat final :
Maximum : $90$ à la position $4$
Minimum : $12$ à la position $1$",
    "id_category": "2",
    "id_number": "25"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui lit $n$ nombres dans un tableau, puis inverse l'ordre des éléments (le premier devient le dernier, etc.). Afficher le tableau avant et après l'inversion.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code C++ :
#include <iostream>\nusing namespace std;\n\nint main() {\n    int n;\n    \n    cout << \"Entrez la taille : \";\n    cin >> n;\n    \n    int tableau[n];\n    \n    // Lecture\n    cout << \"Entrez les elements :\" << endl;\n    for(int i = 0; i < n; i++) {\n        cin >> tableau[i];\n    }\n    \n    // Affichage avant inversion\n    cout << \"Tableau original : \";\n    for(int i = 0; i < n; i++) {\n        cout << tableau[i] << \" \";\n    }\n    cout << endl;\n    \n    // Inversion : échanger les éléments symétriques\n    for(int i = 0; i < n/2; i++) {\n        int temp = tableau[i];\n        tableau[i] = tableau[n - 1 - i];\n        tableau[n - 1 - i] = temp;\n    }\n    \n    // Affichage après inversion\n    cout << \"Tableau inverse : \";\n    for(int i = 0; i < n; i++) {\n        cout << tableau[i] << \" \";\n    }\n    cout << endl;\n    \n    return 0;\n}

Explication détaillée :

Principe d'inversion :
Échanger $tableau[i]$ avec $tableau[n-1-i]$ pour $i$ de $0$ à $\\lfloor n/2 \\rfloor - 1$

Variables :
- $n$ : taille du tableau
- $tableau[n]$ : tableau à inverser
- $temp$ : variable temporaire pour l'échange

Exemple avec $n = 5$ et $tableau = [10, 20, 30, 40, 50]$ :

État initial :
Indices : $0, 1, 2, 3, 4$
Valeurs : $10, 20, 30, 40, 50$

Boucle d'inversion ($i$ de $0$ à $2$) :

Itération $i = 0$ :
Échanger $tableau[0]$ et $tableau[4]$
$temp = 10$
$tableau[0] = 50$
$tableau[4] = 10$
Tableau : $[50, 20, 30, 40, 10]$

Itération $i = 1$ :
Échanger $tableau[1]$ et $tableau[3]$
$temp = 20$
$tableau[1] = 40$
$tableau[3] = 20$
Tableau : $[50, 40, 30, 20, 10]$

Itération $i = 2$ :
Pas d'échange (élément central)

Résultat final :
Tableau inversé : $[50, 40, 30, 20, 10]$",
    "id_category": "2",
    "id_number": "26"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui lit $n$ entiers dans un tableau, puis compte et affiche le nombre d'éléments pairs et impairs. Afficher aussi leur pourcentage respectif.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code C++ :
#include <iostream>\nusing namespace std;\n\nint main() {\n    int n;\n    \n    cout << \"Entrez la taille : \";\n    cin >> n;\n    \n    int tableau[n];\n    int nb_pairs = 0;\n    int nb_impairs = 0;\n    \n    // Lecture et comptage\n    cout << \"Entrez les elements :\" << endl;\n    for(int i = 0; i < n; i++) {\n        cin >> tableau[i];\n        \n        // Test de parité\n        if(tableau[i] % 2 == 0) {\n            nb_pairs++;  // Pair\n        }\n        else {\n            nb_impairs++;  // Impair\n        }\n    }\n    \n    // Calcul des pourcentages\n    double pourcent_pairs = (nb_pairs * 100.0) / n;\n    double pourcent_impairs = (nb_impairs * 100.0) / n;\n    \n    // Affichage des résultats\n    cout << \"Nombre d'elements pairs : \" << nb_pairs;\n    cout << \" (\" << pourcent_pairs << \"%)\" << endl;\n    \n    cout << \"Nombre d'elements impairs : \" << nb_impairs;\n    cout << \" (\" << pourcent_impairs << \"%)\" << endl;\n    \n    return 0;\n}

Explication détaillée :

Test de parité :
Un nombre $x$ est pair si $x \\mod 2 = 0$, sinon il est impair

Variables :
- $tableau[n]$ : tableau d'entiers
- $nb\\_pairs$ : compteur des pairs
- $nb\\_impairs$ : compteur des impairs

Formules :
Pourcentage pairs : $P_{pairs} = \\frac{nb\\_pairs \\times 100}{n}$
Pourcentage impairs : $P_{impairs} = \\frac{nb\\_impairs \\times 100}{n}$

Exemple avec $n = 8$ et $tableau = [15, 22, 8, 33, 44, 17, 20, 9]$ :

Parcours et comptage :
- $15 \\mod 2 = 1$ (impair) → $nb\\_impairs = 1$
- $22 \\mod 2 = 0$ (pair) → $nb\\_pairs = 1$
- $8 \\mod 2 = 0$ (pair) → $nb\\_pairs = 2$
- $33 \\mod 2 = 1$ (impair) → $nb\\_impairs = 2$
- $44 \\mod 2 = 0$ (pair) → $nb\\_pairs = 3$
- $17 \\mod 2 = 1$ (impair) → $nb\\_impairs = 3$
- $20 \\mod 2 = 0$ (pair) → $nb\\_pairs = 4$
- $9 \\mod 2 = 1$ (impair) → $nb\\_impairs = 4$

Résultats :
Nombres pairs : $nb\\_pairs = 4$
Nombres impairs : $nb\\_impairs = 4$

Pourcentages :
$P_{pairs} = \\frac{4 \\times 100}{8} = 50\\%$
$P_{impairs} = \\frac{4 \\times 100}{8} = 50\\%$",
    "id_category": "2",
    "id_number": "27"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui lit $n$ nombres réels dans un tableau, puis calcule et affiche l'écart-type $\\sigma = \\sqrt{\\frac{1}{n}\\sum_{i=1}^{n}(x_i - \\mu)^2}$ où $\\mu$ est la moyenne.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code C++ :
#include <iostream>\n#include <cmath>\nusing namespace std;\n\nint main() {\n    int n;\n    \n    cout << \"Entrez le nombre d'elements : \";\n    cin >> n;\n    \n    double tableau[n];\n    double somme = 0.0;\n    \n    // Lecture des données\n    cout << \"Entrez les nombres :\" << endl;\n    for(int i = 0; i < n; i++) {\n        cin >> tableau[i];\n        somme = somme + tableau[i];\n    }\n    \n    // Calcul de la moyenne\n    double moyenne = somme / n;\n    cout << \"Moyenne : \" << moyenne << endl;\n    \n    // Calcul de la variance\n    double somme_carres_ecarts = 0.0;\n    for(int i = 0; i < n; i++) {\n        double ecart = tableau[i] - moyenne;\n        somme_carres_ecarts = somme_carres_ecarts + ecart * ecart;\n    }\n    \n    double variance = somme_carres_ecarts / n;\n    \n    // Calcul de l'écart-type\n    double ecart_type = sqrt(variance);\n    \n    cout << \"Variance : \" << variance << endl;\n    cout << \"Ecart-type : \" << ecart_type << endl;\n    \n    return 0;\n}

Explication détaillée :

Formules statistiques :
Moyenne : $\\mu = \\frac{1}{n}\\sum_{i=1}^{n} x_i$
Variance : $\\sigma^2 = \\frac{1}{n}\\sum_{i=1}^{n}(x_i - \\mu)^2$
Écart-type : $\\sigma = \\sqrt{\\sigma^2}$

Exemple avec $n = 5$ et $tableau = [10, 12, 15, 18, 20]$ :

Étape 1 : Calcul de la moyenne
$somme = 10 + 12 + 15 + 18 + 20 = 75$
$\\mu = \\frac{75}{5} = 15$

Étape 2 : Calcul des écarts au carré
Pour $i = 0$ : $ecart = 10 - 15 = -5$, $ecart^2 = 25$
Pour $i = 1$ : $ecart = 12 - 15 = -3$, $ecart^2 = 9$
Pour $i = 2$ : $ecart = 15 - 15 = 0$, $ecart^2 = 0$
Pour $i = 3$ : $ecart = 18 - 15 = 3$, $ecart^2 = 9$
Pour $i = 4$ : $ecart = 20 - 15 = 5$, $ecart^2 = 25$

Étape 3 : Calcul de la variance
$somme\\_carres\\_ecarts = 25 + 9 + 0 + 9 + 25 = 68$
$\\sigma^2 = \\frac{68}{5} = 13.6$

Étape 4 : Calcul de l'écart-type
$\\sigma = \\sqrt{13.6} \\approx 3.688$

Résultats :
Moyenne : $\\mu = 15$
Variance : $\\sigma^2 = 13.6$
Écart-type : $\\sigma \\approx 3.688$",
    "id_category": "2",
    "id_number": "28"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui lit deux matrices $A$ et $B$ de dimensions $m \\times n$, puis calcule et affiche leur somme $C = A + B$ où $C_{ij} = A_{ij} + B_{ij}$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code C++ :
#include <iostream>\nusing namespace std;\n\nint main() {\n    int m, n;\n    \n    // Lecture des dimensions\n    cout << \"Entrez le nombre de lignes m : \";\n    cin >> m;\n    cout << \"Entrez le nombre de colonnes n : \";\n    cin >> n;\n    \n    // Déclaration des matrices\n    double A[m][n], B[m][n], C[m][n];\n    \n    // Lecture de la matrice A\n    cout << \"Entrez les elements de la matrice A :\" << endl;\n    for(int i = 0; i < m; i++) {\n        for(int j = 0; j < n; j++) {\n            cout << \"A[\" << i << \"][\" << j << \"] : \";\n            cin >> A[i][j];\n        }\n    }\n    \n    // Lecture de la matrice B\n    cout << \"Entrez les elements de la matrice B :\" << endl;\n    for(int i = 0; i < m; i++) {\n        for(int j = 0; j < n; j++) {\n            cout << \"B[\" << i << \"][\" << j << \"] : \";\n            cin >> B[i][j];\n        }\n    }\n    \n    // Calcul de C = A + B\n    for(int i = 0; i < m; i++) {\n        for(int j = 0; j < n; j++) {\n            C[i][j] = A[i][j] + B[i][j];\n        }\n    }\n    \n    // Affichage de la matrice C\n    cout << \"Matrice C = A + B :\" << endl;\n    for(int i = 0; i < m; i++) {\n        for(int j = 0; j < n; j++) {\n            cout << C[i][j] << \" \";\n        }\n        cout << endl;\n    }\n    \n    return 0;\n}

Explication détaillée :

Opération d'addition matricielle :
Pour deux matrices de mêmes dimensions, la somme est :
$C_{ij} = A_{ij} + B_{ij}$ pour tout $i$ et $j$

Variables :
- $m, n$ : dimensions des matrices
- $A[m][n], B[m][n]$ : matrices d'entrée
- $C[m][n]$ : matrice résultat

Exemple avec $m = 2$, $n = 3$ :

Matrice A :
$A = \\begin{pmatrix} 1 & 2 & 3 \\\\ 4 & 5 & 6 \\end{pmatrix}$

Matrice B :
$B = \\begin{pmatrix} 7 & 8 & 9 \\\\ 10 & 11 & 12 \\end{pmatrix}$

Calcul élément par élément :

Ligne $i = 0$ :
- $C[0][0] = A[0][0] + B[0][0] = 1 + 7 = 8$
- $C[0][1] = A[0][1] + B[0][1] = 2 + 8 = 10$
- $C[0][2] = A[0][2] + B[0][2] = 3 + 9 = 12$

Ligne $i = 1$ :
- $C[1][0] = A[1][0] + B[1][0] = 4 + 10 = 14$
- $C[1][1] = A[1][1] + B[1][1] = 5 + 11 = 16$
- $C[1][2] = A[1][2] + B[1][2] = 6 + 12 = 18$

Matrice C résultat :
$C = \\begin{pmatrix} 8 & 10 & 12 \\\\ 14 & 16 & 18 \\end{pmatrix}$",
    "id_category": "2",
    "id_number": "29"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui lit une matrice carrée $A$ de dimension $n \\times n$, puis calcule et affiche la trace $tr(A) = \\sum_{i=1}^{n} A_{ii}$ (somme des éléments diagonaux).",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code C++ :
#include <iostream>\nusing namespace std;\n\nint main() {\n    int n;\n    \n    // Lecture de la dimension\n    cout << \"Entrez la dimension n : \";\n    cin >> n;\n    \n    // Déclaration de la matrice\n    double A[n][n];\n    \n    // Lecture de la matrice\n    cout << \"Entrez les elements de la matrice A :\" << endl;\n    for(int i = 0; i < n; i++) {\n        for(int j = 0; j < n; j++) {\n            cout << \"A[\" << i << \"][\" << j << \"] : \";\n            cin >> A[i][j];\n        }\n    }\n    \n    // Calcul de la trace\n    double trace = 0.0;\n    for(int i = 0; i < n; i++) {\n        trace = trace + A[i][i];  // Somme des éléments diagonaux\n    }\n    \n    // Affichage de la matrice\n    cout << \"Matrice A :\" << endl;\n    for(int i = 0; i < n; i++) {\n        for(int j = 0; j < n; j++) {\n            cout << A[i][j] << \" \";\n        }\n        cout << endl;\n    }\n    \n    // Affichage de la trace\n    cout << \"Trace de A : \" << trace << endl;\n    \n    return 0;\n}

Explication détaillée :

Définition de la trace :
La trace d'une matrice carrée est la somme de ses éléments diagonaux :
$tr(A) = \\sum_{i=1}^{n} A_{ii} = A_{11} + A_{22} + ... + A_{nn}$

Variables :
- $n$ : dimension de la matrice carrée
- $A[n][n]$ : matrice carrée
- $trace$ : somme des éléments diagonaux

Algorithme :
Parcourir les indices $i$ de $0$ à $n-1$ et accumuler $A[i][i]$

Exemple avec $n = 3$ :

Matrice A :
$A = \\begin{pmatrix} 5 & 2 & 1 \\\\ 3 & 8 & 4 \\\\ 7 & 6 & 9 \\end{pmatrix}$

Calcul de la trace :

Initialisation : $trace = 0$

Itération $i = 0$ :
$A[0][0] = 5$
$trace = 0 + 5 = 5$

Itération $i = 1$ :
$A[1][1] = 8$
$trace = 5 + 8 = 13$

Itération $i = 2$ :
$A[2][2] = 9$
$trace = 13 + 9 = 22$

Résultat :
$tr(A) = 5 + 8 + 9 = 22$

Éléments diagonaux : Les éléments avec indices $(i, i)$ forment la diagonale principale",
    "id_category": "2",
    "id_number": "30"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui lit une matrice $A$ de dimensions $m \\times n$, puis calcule et affiche sa transposée $A^T$ de dimensions $n \\times m$ où $(A^T)_{ij} = A_{ji}$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code C++ :
#include <iostream>\nusing namespace std;\n\nint main() {\n    int m, n;\n    \n    // Lecture des dimensions\n    cout << \"Entrez le nombre de lignes m : \";\n    cin >> m;\n    cout << \"Entrez le nombre de colonnes n : \";\n    cin >> n;\n    \n    // Déclaration des matrices\n    double A[m][n];       // Matrice originale\n    double AT[n][m];      // Matrice transposée\n    \n    // Lecture de la matrice A\n    cout << \"Entrez les elements de A :\" << endl;\n    for(int i = 0; i < m; i++) {\n        for(int j = 0; j < n; j++) {\n            cout << \"A[\" << i << \"][\" << j << \"] : \";\n            cin >> A[i][j];\n        }\n    }\n    \n    // Calcul de la transposée\n    for(int i = 0; i < m; i++) {\n        for(int j = 0; j < n; j++) {\n            AT[j][i] = A[i][j];  // Inversion des indices\n        }\n    }\n    \n    // Affichage de A\n    cout << \"Matrice A (\" << m << \"x\" << n << \") :\" << endl;\n    for(int i = 0; i < m; i++) {\n        for(int j = 0; j < n; j++) {\n            cout << A[i][j] << \" \";\n        }\n        cout << endl;\n    }\n    \n    // Affichage de AT\n    cout << \"Matrice transposee A^T (\" << n << \"x\" << m << \") :\" << endl;\n    for(int i = 0; i < n; i++) {\n        for(int j = 0; j < m; j++) {\n            cout << AT[i][j] << \" \";\n        }\n        cout << endl;\n    }\n    \n    return 0;\n}

Explication détaillée :

Définition de la transposition :
La transposée $A^T$ d'une matrice $A$ s'obtient en échangeant lignes et colonnes :
$(A^T)_{ij} = A_{ji}$

Dimensions : Si $A$ est $m \\times n$, alors $A^T$ est $n \\times m$

Variables :
- $A[m][n]$ : matrice originale
- $AT[n][m]$ : matrice transposée

Exemple avec $m = 3$, $n = 2$ :

Matrice A :
$A = \\begin{pmatrix} 1 & 2 \\\\ 3 & 4 \\\\ 5 & 6 \\end{pmatrix}_{3 \\times 2}$

Calcul de la transposée :

Pour $i = 0, j = 0$ : $AT[0][0] = A[0][0] = 1$
Pour $i = 0, j = 1$ : $AT[1][0] = A[0][1] = 2$
Pour $i = 1, j = 0$ : $AT[0][1] = A[1][0] = 3$
Pour $i = 1, j = 1$ : $AT[1][1] = A[1][1] = 4$
Pour $i = 2, j = 0$ : $AT[0][2] = A[2][0] = 5$
Pour $i = 2, j = 1$ : $AT[1][2] = A[2][1] = 6$

Matrice transposée :
$A^T = \\begin{pmatrix} 1 & 3 & 5 \\\\ 2 & 4 & 6 \\end{pmatrix}_{2 \\times 3}$

Vérification :
Les lignes de $A$ deviennent les colonnes de $A^T$
Ligne 1 de $A$ : $[1, 2]$ → Colonne 1 de $A^T$ : $\\begin{pmatrix} 1 \\\\ 2 \\end{pmatrix}$",
    "id_category": "2",
    "id_number": "31"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui lit deux matrices $A$ de dimensions $m \\times p$ et $B$ de dimensions $p \\times n$, puis calcule leur produit $C = A \\times B$ où $C_{ij} = \\sum_{k=1}^{p} A_{ik} \\times B_{kj}$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code C++ :
#include <iostream>\nusing namespace std;\n\nint main() {\n    int m, p, n;\n    \n    // Lecture des dimensions\n    cout << \"Entrez m (lignes de A) : \";\n    cin >> m;\n    cout << \"Entrez p (colonnes de A = lignes de B) : \";\n    cin >> p;\n    cout << \"Entrez n (colonnes de B) : \";\n    cin >> n;\n    \n    // Déclaration des matrices\n    double A[m][p], B[p][n], C[m][n];\n    \n    // Lecture de A\n    cout << \"Entrez les elements de A (\" << m << \"x\" << p << \") :\" << endl;\n    for(int i = 0; i < m; i++) {\n        for(int j = 0; j < p; j++) {\n            cin >> A[i][j];\n        }\n    }\n    \n    // Lecture de B\n    cout << \"Entrez les elements de B (\" << p << \"x\" << n << \") :\" << endl;\n    for(int i = 0; i < p; i++) {\n        for(int j = 0; j < n; j++) {\n            cin >> B[i][j];\n        }\n    }\n    \n    // Calcul du produit C = A * B\n    for(int i = 0; i < m; i++) {\n        for(int j = 0; j < n; j++) {\n            C[i][j] = 0;  // Initialisation\n            for(int k = 0; k < p; k++) {\n                C[i][j] = C[i][j] + A[i][k] * B[k][j];\n            }\n        }\n    }\n    \n    // Affichage de C\n    cout << \"Matrice produit C = A*B (\" << m << \"x\" << n << \") :\" << endl;\n    for(int i = 0; i < m; i++) {\n        for(int j = 0; j < n; j++) {\n            cout << C[i][j] << \" \";\n        }\n        cout << endl;\n    }\n    \n    return 0;\n}

Explication détaillée :

Formule du produit matriciel :
$C_{ij} = \\sum_{k=1}^{p} A_{ik} \\times B_{kj}$

L'élément $C_{ij}$ est le produit scalaire de la ligne $i$ de $A$ avec la colonne $j$ de $B$

Conditions :
Le nombre de colonnes de $A$ doit égaler le nombre de lignes de $B$

Exemple avec $m = 2$, $p = 3$, $n = 2$ :

Matrice A ($2 \\times 3$) :
$A = \\begin{pmatrix} 1 & 2 & 3 \\\\ 4 & 5 & 6 \\end{pmatrix}$

Matrice B ($3 \\times 2$) :
$B = \\begin{pmatrix} 7 & 8 \\\\ 9 & 10 \\\\ 11 & 12 \\end{pmatrix}$

Calcul de C ($2 \\times 2$) :

Élément $C[0][0]$ :
$C[0][0] = A[0][0] \\times B[0][0] + A[0][1] \\times B[1][0] + A[0][2] \\times B[2][0]$
$C[0][0] = 1 \\times 7 + 2 \\times 9 + 3 \\times 11 = 7 + 18 + 33 = 58$

Élément $C[0][1]$ :
$C[0][1] = A[0][0] \\times B[0][1] + A[0][1] \\times B[1][1] + A[0][2] \\times B[2][1]$
$C[0][1] = 1 \\times 8 + 2 \\times 10 + 3 \\times 12 = 8 + 20 + 36 = 64$

Élément $C[1][0]$ :
$C[1][0] = A[1][0] \\times B[0][0] + A[1][1] \\times B[1][0] + A[1][2] \\times B[2][0]$
$C[1][0] = 4 \\times 7 + 5 \\times 9 + 6 \\times 11 = 28 + 45 + 66 = 139$

Élément $C[1][1]$ :
$C[1][1] = A[1][0] \\times B[0][1] + A[1][1] \\times B[1][1] + A[1][2] \\times B[2][1]$
$C[1][1] = 4 \\times 8 + 5 \\times 10 + 6 \\times 12 = 32 + 50 + 72 = 154$

Matrice résultat :
$C = \\begin{pmatrix} 58 & 64 \\\\ 139 & 154 \\end{pmatrix}$",
    "id_category": "2",
    "id_number": "32"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui lit une matrice carrée $A$ de dimension $n \\times n$, puis vérifie si elle est symétrique ($A_{ij} = A_{ji}$ pour tout $i, j$).",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code C++ :
#include <iostream>\nusing namespace std;\n\nint main() {\n    int n;\n    \n    cout << \"Entrez la dimension n : \";\n    cin >> n;\n    \n    double A[n][n];\n    bool est_symetrique = true;\n    \n    // Lecture de la matrice\n    cout << \"Entrez les elements de la matrice :\" << endl;\n    for(int i = 0; i < n; i++) {\n        for(int j = 0; j < n; j++) {\n            cin >> A[i][j];\n        }\n    }\n    \n    // Vérification de la symétrie\n    for(int i = 0; i < n; i++) {\n        for(int j = 0; j < i; j++) {  // Triangle inférieur seulement\n            if(A[i][j] != A[j][i]) {\n                est_symetrique = false;\n                break;\n            }\n        }\n        if(!est_symetrique) break;\n    }\n    \n    // Affichage de la matrice\n    cout << \"Matrice A :\" << endl;\n    for(int i = 0; i < n; i++) {\n        for(int j = 0; j < n; j++) {\n            cout << A[i][j] << \" \";\n        }\n        cout << endl;\n    }\n    \n    // Résultat\n    if(est_symetrique)\n        cout << \"La matrice est symetrique\" << endl;\n    else\n        cout << \"La matrice n'est pas symetrique\" << endl;\n    \n    return 0;\n}

Explication détaillée :

Définition de symétrie :
Une matrice $A$ est symétrique si $A = A^T$, c'est-à-dire :
$A_{ij} = A_{ji}$ pour tout $i, j \\in [1, n]$

Algorithme d'optimisation :
Il suffit de vérifier le triangle inférieur ($i > j$), car si $A_{ij} \\neq A_{ji}$, la matrice n'est pas symétrique

Exemple 1 : Matrice symétrique avec $n = 3$ :

$A = \\begin{pmatrix} 4 & 1 & 2 \\\\ 1 & 5 & 3 \\\\ 2 & 3 & 6 \\end{pmatrix}$

Vérifications :
Position $(1,0)$ : $A[1][0] = 1$, $A[0][1] = 1$ → égaux ✓
Position $(2,0)$ : $A[2][0] = 2$, $A[0][2] = 2$ → égaux ✓
Position $(2,1)$ : $A[2][1] = 3$, $A[1][2] = 3$ → égaux ✓

Toutes les conditions satisfaites → Matrice symétrique

Exemple 2 : Matrice non symétrique avec $n = 3$ :

$B = \\begin{pmatrix} 1 & 2 & 3 \\\\ 4 & 5 & 6 \\\\ 7 & 8 & 9 \\end{pmatrix}$

Vérifications :
Position $(1,0)$ : $B[1][0] = 4$, $B[0][1] = 2$
$4 \\neq 2$ → Non symétrique

Arrêt immédiat, pas besoin de vérifier les autres éléments",
    "id_category": "2",
    "id_number": "33"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui lit une matrice carrée $A$ de dimension $n \\times n$, puis calcule et affiche la somme des éléments de chaque ligne et de chaque colonne.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code C++ :
#include <iostream>\nusing namespace std;\n\nint main() {\n    int n;\n    \n    cout << \"Entrez la dimension n : \";\n    cin >> n;\n    \n    double A[n][n];\n    double somme_lignes[n];     // Somme de chaque ligne\n    double somme_colonnes[n];   // Somme de chaque colonne\n    \n    // Lecture de la matrice\n    cout << \"Entrez les elements de la matrice :\" << endl;\n    for(int i = 0; i < n; i++) {\n        for(int j = 0; j < n; j++) {\n            cin >> A[i][j];\n        }\n    }\n    \n    // Initialisation des sommes\n    for(int i = 0; i < n; i++) {\n        somme_lignes[i] = 0;\n        somme_colonnes[i] = 0;\n    }\n    \n    // Calcul des sommes\n    for(int i = 0; i < n; i++) {\n        for(int j = 0; j < n; j++) {\n            somme_lignes[i] = somme_lignes[i] + A[i][j];\n            somme_colonnes[j] = somme_colonnes[j] + A[i][j];\n        }\n    }\n    \n    // Affichage de la matrice\n    cout << \"Matrice A :\" << endl;\n    for(int i = 0; i < n; i++) {\n        for(int j = 0; j < n; j++) {\n            cout << A[i][j] << \" \";\n        }\n        cout << endl;\n    }\n    \n    // Affichage des sommes par ligne\n    cout << \"Somme par ligne :\" << endl;\n    for(int i = 0; i < n; i++) {\n        cout << \"Ligne \" << i << \" : \" << somme_lignes[i] << endl;\n    }\n    \n    // Affichage des sommes par colonne\n    cout << \"Somme par colonne :\" << endl;\n    for(int j = 0; j < n; j++) {\n        cout << \"Colonne \" << j << \" : \" << somme_colonnes[j] << endl;\n    }\n    \n    return 0;\n}

Explication détaillée :

Formules :
Somme de la ligne $i$ : $S_{ligne_i} = \\sum_{j=0}^{n-1} A_{ij}$
Somme de la colonne $j$ : $S_{colonne_j} = \\sum_{i=0}^{n-1} A_{ij}$

Variables :
- $A[n][n]$ : matrice carrée
- $somme\\_lignes[n]$ : tableau des sommes par ligne
- $somme\\_colonnes[n]$ : tableau des sommes par colonne

Exemple avec $n = 3$ :

$A = \\begin{pmatrix} 1 & 2 & 3 \\\\ 4 & 5 & 6 \\\\ 7 & 8 & 9 \\end{pmatrix}$

Calcul des sommes par ligne :

Ligne $0$ : $S_{ligne_0} = A[0][0] + A[0][1] + A[0][2] = 1 + 2 + 3 = 6$
Ligne $1$ : $S_{ligne_1} = A[1][0] + A[1][1] + A[1][2] = 4 + 5 + 6 = 15$
Ligne $2$ : $S_{ligne_2} = A[2][0] + A[2][1] + A[2][2] = 7 + 8 + 9 = 24$

Calcul des sommes par colonne :

Colonne $0$ : $S_{col_0} = A[0][0] + A[1][0] + A[2][0] = 1 + 4 + 7 = 12$
Colonne $1$ : $S_{col_1} = A[0][1] + A[1][1] + A[2][1] = 2 + 5 + 8 = 15$
Colonne $2$ : $S_{col_2} = A[0][2] + A[1][2] + A[2][2] = 3 + 6 + 9 = 18$

Résultats :
Sommes lignes : $[6, 15, 24]$
Sommes colonnes : $[12, 15, 18]$

Vérification :
Somme totale = $6 + 15 + 24 = 45$
Somme totale = $12 + 15 + 18 = 45$ ✓",
    "id_category": "2",
    "id_number": "34"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui lit une matrice $A$ de dimensions $m \\times n$, puis multiplie tous ses éléments par un scalaire $\\alpha$ pour obtenir $B = \\alpha A$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code C++ :
#include <iostream>\nusing namespace std;\n\nint main() {\n    int m, n;\n    double alpha;\n    \n    // Lecture des dimensions\n    cout << \"Entrez le nombre de lignes m : \";\n    cin >> m;\n    cout << \"Entrez le nombre de colonnes n : \";\n    cin >> n;\n    \n    double A[m][n], B[m][n];\n    \n    // Lecture de la matrice A\n    cout << \"Entrez les elements de A :\" << endl;\n    for(int i = 0; i < m; i++) {\n        for(int j = 0; j < n; j++) {\n            cin >> A[i][j];\n        }\n    }\n    \n    // Lecture du scalaire\n    cout << \"Entrez le scalaire alpha : \";\n    cin >> alpha;\n    \n    // Multiplication par le scalaire\n    for(int i = 0; i < m; i++) {\n        for(int j = 0; j < n; j++) {\n            B[i][j] = alpha * A[i][j];\n        }\n    }\n    \n    // Affichage de A\n    cout << \"Matrice originale A :\" << endl;\n    for(int i = 0; i < m; i++) {\n        for(int j = 0; j < n; j++) {\n            cout << A[i][j] << \" \";\n        }\n        cout << endl;\n    }\n    \n    // Affichage de B\n    cout << \"Matrice B = \" << alpha << \" * A :\" << endl;\n    for(int i = 0; i < m; i++) {\n        for(int j = 0; j < n; j++) {\n            cout << B[i][j] << \" \";\n        }\n        cout << endl;\n    }\n    \n    return 0;\n}

Explication détaillée :

Multiplication d'une matrice par un scalaire :
Chaque élément de la matrice est multiplié par le scalaire :
$B_{ij} = \\alpha \\times A_{ij}$ pour tout $i \\in [0, m-1]$ et $j \\in [0, n-1]$

Variables :
- $m, n$ : dimensions de la matrice
- $\\alpha$ : scalaire multiplicateur
- $A[m][n]$ : matrice originale
- $B[m][n]$ : matrice résultat

Exemple avec $m = 2$, $n = 3$, $\\alpha = 3$ :

Matrice A :
$A = \\begin{pmatrix} 2 & 4 & 6 \\\\ 1 & 3 & 5 \\end{pmatrix}$

Calcul de B avec $\\alpha = 3$ :

Ligne $i = 0$ :
- $B[0][0] = 3 \\times A[0][0] = 3 \\times 2 = 6$
- $B[0][1] = 3 \\times A[0][1] = 3 \\times 4 = 12$
- $B[0][2] = 3 \\times A[0][2] = 3 \\times 6 = 18$

Ligne $i = 1$ :
- $B[1][0] = 3 \\times A[1][0] = 3 \\times 1 = 3$
- $B[1][1] = 3 \\times A[1][1] = 3 \\times 3 = 9$
- $B[1][2] = 3 \\times A[1][2] = 3 \\times 5 = 15$

Matrice résultat :
$B = 3A = \\begin{pmatrix} 6 & 12 & 18 \\\\ 3 & 9 & 15 \\end{pmatrix}$

Propriété :
La multiplication par un scalaire distribue sur tous les éléments : $\\alpha(A_{ij}) = (\\alpha A)_{ij}$",
    "id_category": "2",
    "id_number": "35"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui lit une matrice carrée $A$ de dimension $n \\times n$, puis calcule et affiche le déterminant pour $n = 2$ en utilisant la formule $\\det(A) = A_{00}A_{11} - A_{01}A_{10}$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code C++ :
#include <iostream>\nusing namespace std;\n\nint main() {\n    const int n = 2;  // Matrice 2x2\n    double A[n][n];\n    \n    // Lecture de la matrice 2x2\n    cout << \"Entrez les elements de la matrice 2x2 :\" << endl;\n    for(int i = 0; i < n; i++) {\n        for(int j = 0; j < n; j++) {\n            cout << \"A[\" << i << \"][\" << j << \"] : \";\n            cin >> A[i][j];\n        }\n    }\n    \n    // Affichage de la matrice\n    cout << \"Matrice A :\" << endl;\n    for(int i = 0; i < n; i++) {\n        for(int j = 0; j < n; j++) {\n            cout << A[i][j] << \" \";\n        }\n        cout << endl;\n    }\n    \n    // Calcul du déterminant\n    double det = A[0][0] * A[1][1] - A[0][1] * A[1][0];\n    \n    // Affichage du résultat\n    cout << \"Determinant de A : \" << det << endl;\n    \n    return 0;\n}

Explication détaillée :

Formule du déterminant $2 \\times 2$ :
Pour une matrice $A = \\begin{pmatrix} a & b \\\\ c & d \\end{pmatrix}$

Le déterminant est :
$\\det(A) = ad - bc = A_{00}A_{11} - A_{01}A_{10}$

Interprétation géométrique :
Le déterminant représente l'aire du parallélogramme formé par les vecteurs colonnes

Exemple 1 avec matrice :
$A = \\begin{pmatrix} 3 & 5 \\\\ 2 & 7 \\end{pmatrix}$

Calcul du déterminant :
$\\det(A) = A[0][0] \\times A[1][1] - A[0][1] \\times A[1][0]$
$\\det(A) = 3 \\times 7 - 5 \\times 2$
$\\det(A) = 21 - 10$
$\\det(A) = 11$

Résultat : $\\det(A) = 11$

Exemple 2 avec matrice singulière :
$B = \\begin{pmatrix} 2 & 4 \\\\ 3 & 6 \\end{pmatrix}$

Calcul :
$\\det(B) = 2 \\times 6 - 4 \\times 3 = 12 - 12 = 0$

Interprétation : $\\det(B) = 0$ signifie que la matrice est singulière (non inversible)
Les vecteurs lignes (ou colonnes) sont colinéaires : $\\begin{pmatrix} 3 \\\\ 6 \\end{pmatrix} = 1.5 \\times \\begin{pmatrix} 2 \\\\ 4 \\end{pmatrix}$",
    "id_category": "2",
    "id_number": "36"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui lit $n$ nombres entiers dans un tableau, puis les trie par ordre croissant en utilisant l'algorithme de tri à bulles (Bubble Sort).",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code C++ :
#include <iostream>\nusing namespace std;\n\nint main() {\n    int n;\n    \n    cout << \"Entrez la taille du tableau : \";\n    cin >> n;\n    \n    int tableau[n];\n    \n    // Lecture du tableau\n    cout << \"Entrez les elements :\" << endl;\n    for(int i = 0; i < n; i++) {\n        cin >> tableau[i];\n    }\n    \n    // Affichage avant tri\n    cout << \"Tableau avant tri : \";\n    for(int i = 0; i < n; i++) {\n        cout << tableau[i] << \" \";\n    }\n    cout << endl;\n    \n    // Tri à bulles\n    for(int i = 0; i < n - 1; i++) {\n        for(int j = 0; j < n - 1 - i; j++) {\n            if(tableau[j] > tableau[j + 1]) {\n                // Échange\n                int temp = tableau[j];\n                tableau[j] = tableau[j + 1];\n                tableau[j + 1] = temp;\n            }\n        }\n    }\n    \n    // Affichage après tri\n    cout << \"Tableau apres tri : \";\n    for(int i = 0; i < n; i++) {\n        cout << tableau[i] << \" \";\n    }\n    cout << endl;\n    \n    return 0;\n}

Explication détaillée :

Principe du tri à bulles :
Comparer les éléments adjacents et les échanger si nécessaire
Les grands éléments \"remontent\" comme des bulles

Complexité :
Nombre de comparaisons : $\\frac{n(n-1)}{2}$
Complexité temporelle : $O(n^2)$

Algorithme :
1. Boucle externe : $i$ de $0$ à $n-2$
2. Boucle interne : $j$ de $0$ à $n-2-i$
3. Si $tableau[j] > tableau[j+1]$, échanger

Exemple avec $n = 5$ et $tableau = [64, 34, 25, 12, 22]$ :

Passe $i = 0$ :
$j = 0$ : $64 > 34$ → échanger → $[34, 64, 25, 12, 22]$
$j = 1$ : $64 > 25$ → échanger → $[34, 25, 64, 12, 22]$
$j = 2$ : $64 > 12$ → échanger → $[34, 25, 12, 64, 22]$
$j = 3$ : $64 > 22$ → échanger → $[34, 25, 12, 22, 64]$

Passe $i = 1$ :
$j = 0$ : $34 > 25$ → échanger → $[25, 34, 12, 22, 64]$
$j = 1$ : $34 > 12$ → échanger → $[25, 12, 34, 22, 64]$
$j = 2$ : $34 > 22$ → échanger → $[25, 12, 22, 34, 64]$

Passe $i = 2$ :
$j = 0$ : $25 > 12$ → échanger → $[12, 25, 22, 34, 64]$
$j = 1$ : $25 > 22$ → échanger → $[12, 22, 25, 34, 64]$

Passe $i = 3$ :
$j = 0$ : $12 < 22$ → pas d'échange → $[12, 22, 25, 34, 64]$

Résultat final : $[12, 22, 25, 34, 64]$",
    "id_category": "2",
    "id_number": "37"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui lit deux tableaux $A$ et $B$ de tailles $m$ et $n$ respectivement, puis les fusionne dans un tableau $C$ de taille $m + n$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code C++ :
#include <iostream>\nusing namespace std;\n\nint main() {\n    int m, n;\n    \n    // Lecture des tailles\n    cout << \"Entrez la taille de A : \";\n    cin >> m;\n    cout << \"Entrez la taille de B : \";\n    cin >> n;\n    \n    int A[m], B[n], C[m + n];\n    \n    // Lecture du tableau A\n    cout << \"Entrez les elements de A :\" << endl;\n    for(int i = 0; i < m; i++) {\n        cin >> A[i];\n    }\n    \n    // Lecture du tableau B\n    cout << \"Entrez les elements de B :\" << endl;\n    for(int i = 0; i < n; i++) {\n        cin >> B[i];\n    }\n    \n    // Fusion : copie de A dans C\n    for(int i = 0; i < m; i++) {\n        C[i] = A[i];\n    }\n    \n    // Fusion : copie de B dans C\n    for(int i = 0; i < n; i++) {\n        C[m + i] = B[i];\n    }\n    \n    // Affichage de A\n    cout << \"Tableau A : \";\n    for(int i = 0; i < m; i++) {\n        cout << A[i] << \" \";\n    }\n    cout << endl;\n    \n    // Affichage de B\n    cout << \"Tableau B : \";\n    for(int i = 0; i < n; i++) {\n        cout << B[i] << \" \";\n    }\n    cout << endl;\n    \n    // Affichage de C\n    cout << \"Tableau fusione C : \";\n    for(int i = 0; i < m + n; i++) {\n        cout << C[i] << \" \";\n    }\n    cout << endl;\n    \n    return 0;\n}

Explication détaillée :

Principe de la fusion :
Concaténer les deux tableaux en plaçant tous les éléments de $A$ puis tous les éléments de $B$ dans $C$

Indices dans C :
- Éléments de $A$ : positions $0$ à $m-1$
- Éléments de $B$ : positions $m$ à $m+n-1$

Variables :
- $m, n$ : tailles respectives de $A$ et $B$
- $A[m], B[n]$ : tableaux d'entrée
- $C[m+n]$ : tableau fusionné

Exemple avec $m = 4$, $n = 3$ :

Tableau A :
$A = [10, 20, 30, 40]$

Tableau B :
$B = [50, 60, 70]$

Étape 1 : Copie de A dans C
Boucle pour $i$ de $0$ à $3$ :
- $C[0] = A[0] = 10$
- $C[1] = A[1] = 20$
- $C[2] = A[2] = 30$
- $C[3] = A[3] = 40$

État de $C$ : $[10, 20, 30, 40, ?, ?, ?]$

Étape 2 : Copie de B dans C
Boucle pour $i$ de $0$ à $2$ :
- $C[4] = B[0] = 50$ (position $m + 0 = 4$)
- $C[5] = B[1] = 60$ (position $m + 1 = 5$)
- $C[6] = B[2] = 70$ (position $m + 2 = 6$)

Résultat final :
$C = [10, 20, 30, 40, 50, 60, 70]$

Taille de $C$ : $m + n = 4 + 3 = 7$",
    "id_category": "2",
    "id_number": "38"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui lit $n$ nombres dans un tableau, puis recherche un élément $x$ donné en utilisant la recherche linéaire. Afficher la position si trouvé, sinon afficher un message.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code C++ :
#include <iostream>\nusing namespace std;\n\nint main() {\n    int n, x;\n    int position = -1;  // -1 signifie non trouvé\n    \n    // Lecture de la taille\n    cout << \"Entrez la taille du tableau : \";\n    cin >> n;\n    \n    int tableau[n];\n    \n    // Lecture du tableau\n    cout << \"Entrez les elements :\" << endl;\n    for(int i = 0; i < n; i++) {\n        cin >> tableau[i];\n    }\n    \n    // Lecture de l'élément à rechercher\n    cout << \"Entrez l'element a rechercher : \";\n    cin >> x;\n    \n    // Recherche linéaire\n    for(int i = 0; i < n; i++) {\n        if(tableau[i] == x) {\n            position = i;\n            break;  // Arrêt dès qu'on trouve\n        }\n    }\n    \n    // Affichage du résultat\n    if(position != -1) {\n        cout << \"Element \" << x << \" trouve a la position \" << position << endl;\n    }\n    else {\n        cout << \"Element \" << x << \" non trouve dans le tableau\" << endl;\n    }\n    \n    return 0;\n}

Explication détaillée :

Principe de la recherche linéaire :
Parcourir séquentiellement le tableau jusqu'à trouver l'élément ou atteindre la fin

Complexité temporelle :
Meilleur cas : $O(1)$ (élément en première position)
Pire cas : $O(n)$ (élément en dernière position ou absent)
Cas moyen : $O(\\frac{n}{2})$

Variables :
- $n$ : taille du tableau
- $x$ : élément recherché
- $position$ : indice de l'élément ($-1$ si non trouvé)

Exemple 1 : Élément trouvé
$n = 7$, $tableau = [15, 8, 23, 42, 16, 31, 9]$, $x = 42$

Recherche :
$i = 0$ : $tableau[0] = 15 \\neq 42$
$i = 1$ : $tableau[1] = 8 \\neq 42$
$i = 2$ : $tableau[2] = 23 \\neq 42$
$i = 3$ : $tableau[3] = 42 = 42$ ✓

Élément trouvé : $position = 3$

Résultat : \"Élément $42$ trouvé à la position $3$\"

Nombre de comparaisons : $4$

Exemple 2 : Élément non trouvé
$n = 5$, $tableau = [10, 20, 30, 40, 50]$, $x = 25$

Recherche :
$i = 0$ : $10 \\neq 25$
$i = 1$ : $20 \\neq 25$
$i = 2$ : $30 \\neq 25$
$i = 3$ : $40 \\neq 25$
$i = 4$ : $50 \\neq 25$

Fin du tableau : $position = -1$

Résultat : \"Élément $25$ non trouvé dans le tableau\"

Nombre de comparaisons : $5 = n$ (toutes les cases vérifiées)",
    "id_category": "2",
    "id_number": "39"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui lit un entier $n$ et calcule la somme $S = 1 + 2 + 3 + ... + n$. Afficher le résultat à l'écran.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code C++ :
#include <iostream>\nusing namespace std;\n\nint main() {\n    int n;\n    int somme = 0;\n    \n    // Lecture de l'entier n\n    cout << \"Entrez un entier n : \";\n    cin >> n;\n    \n    // Calcul de la somme de 1 à n\n    for(int i = 1; i <= n; i++) {\n        somme = somme + i;  // Accumulation\n    }\n    \n    // Affichage du résultat\n    cout << \"La somme de 1 a \" << n << \" est : \" << somme << endl;\n    \n    return 0;\n}

Explication détaillée :

Variables :
- $n$ : l'entier saisi par l'utilisateur
- $somme$ : accumulateur initialisé à $0$
- $i$ : compteur de boucle

Algorithme :
1. Initialiser $somme = 0$
2. Pour $i$ allant de $1$ à $n$ :
   $somme = somme + i$
3. Afficher $somme$

Formule mathématique :
$S = \\sum_{i=1}^{n} i = \\frac{n(n+1)}{2}$

Exemple pour $n = 5$ :
Itération 1 : $somme = 0 + 1 = 1$
Itération 2 : $somme = 1 + 2 = 3$
Itération 3 : $somme = 3 + 3 = 6$
Itération 4 : $somme = 6 + 4 = 10$
Itération 5 : $somme = 10 + 5 = 15$

Résultat : $S = 15$",
    "id_category": "2",
    "id_number": "40"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui remplit un tableau de $10$ éléments avec des valeurs entrées par l'utilisateur, puis calcule et affiche la moyenne de ces valeurs.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code C++ :
#include <iostream>\nusing namespace std;\n\nint main() {\n    const int TAILLE = 10;\n    double tab[TAILLE];\n    double somme = 0.0;\n    double moyenne;\n    \n    // Remplissage du tableau\n    cout << \"Entrez 10 valeurs :\" << endl;\n    for(int i = 0; i < TAILLE; i++) {\n        cout << \"Valeur \" << (i+1) << \" : \";\n        cin >> tab[i];\n    }\n    \n    // Calcul de la somme\n    for(int i = 0; i < TAILLE; i++) {\n        somme = somme + tab[i];\n    }\n    \n    // Calcul de la moyenne\n    moyenne = somme / TAILLE;\n    \n    // Affichage\n    cout << \"La moyenne est : \" << moyenne << endl;\n    \n    return 0;\n}

Explication détaillée :

Variables :
- $TAILLE = 10$ : constante définissant la taille du tableau
- $tab[10]$ : tableau de $10$ éléments de type $double$
- $somme$ : accumulateur pour la somme
- $moyenne$ : résultat final

Formule de la moyenne :
$\\bar{x} = \\frac{1}{n} \\sum_{i=0}^{n-1} x_i$

Étapes :
1. Lecture des $10$ valeurs dans le tableau
2. Calcul de $somme = x_0 + x_1 + ... + x_9$
3. Calcul de $moyenne = \\frac{somme}{10}$

Exemple avec les valeurs $2, 4, 6, 8, 10, 12, 14, 16, 18, 20$ :
$somme = 2 + 4 + 6 + 8 + 10 + 12 + 14 + 16 + 18 + 20 = 110$
$moyenne = \\frac{110}{10} = 11.0$",
    "id_category": "2",
    "id_number": "41"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui calcule le factoriel d'un entier $n$ saisi par l'utilisateur. Le factoriel est défini par $n! = 1 \\times 2 \\times 3 \\times ... \\times n$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code C++ :
#include <iostream>\nusing namespace std;\n\nint main() {\n    int n;\n    long long factoriel = 1;  // long long pour éviter dépassement\n    \n    // Lecture de n\n    cout << \"Entrez un entier n : \";\n    cin >> n;\n    \n    // Vérification\n    if(n < 0) {\n        cout << \"Erreur : n doit etre >= 0\" << endl;\n        return 1;\n    }\n    \n    // Calcul du factoriel\n    for(int i = 1; i <= n; i++) {\n        factoriel = factoriel * i;\n    }\n    \n    // Affichage\n    cout << n << \"! = \" << factoriel << endl;\n    \n    return 0;\n}

Explication détaillée :

Variables :
- $n$ : entier dont on calcule le factoriel
- $factoriel$ : accumulateur initialisé à $1$
- $i$ : compteur de boucle

Définition mathématique :
$n! = \\prod_{i=1}^{n} i = 1 \\times 2 \\times 3 \\times ... \\times n$
$0! = 1$ (par convention)

Algorithme :
1. Initialiser $factoriel = 1$
2. Pour $i$ de $1$ à $n$ :
   $factoriel = factoriel \\times i$
3. Retourner $factoriel$

Exemple pour $n = 5$ :
Itération 1 : $factoriel = 1 \\times 1 = 1$
Itération 2 : $factoriel = 1 \\times 2 = 2$
Itération 3 : $factoriel = 2 \\times 3 = 6$
Itération 4 : $factoriel = 6 \\times 4 = 24$
Itération 5 : $factoriel = 24 \\times 5 = 120$

Résultat : $5! = 120$",
    "id_category": "2",
    "id_number": "42"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui trouve le maximum et le minimum dans un tableau de $8$ entiers saisis par l'utilisateur. Afficher les deux valeurs ainsi que leurs positions dans le tableau.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code C++ :
#include <iostream>\nusing namespace std;\n\nint main() {\n    const int N = 8;\n    int tab[N];\n    int max, min;\n    int posMax = 0, posMin = 0;\n    \n    // Remplissage du tableau\n    cout << \"Entrez 8 entiers :\" << endl;\n    for(int i = 0; i < N; i++) {\n        cout << \"Element \" << i << \" : \";\n        cin >> tab[i];\n    }\n    \n    // Initialisation avec le premier élément\n    max = tab[0];\n    min = tab[0];\n    \n    // Recherche du max et min\n    for(int i = 1; i < N; i++) {\n        if(tab[i] > max) {\n            max = tab[i];\n            posMax = i;\n        }\n        if(tab[i] < min) {\n            min = tab[i];\n            posMin = i;\n        }\n    }\n    \n    // Affichage des résultats\n    cout << \"Maximum : \" << max << \" a la position \" << posMax << endl;\n    cout << \"Minimum : \" << min << \" a la position \" << posMin << endl;\n    \n    return 0;\n}

Explication détaillée :

Variables :
- $N = 8$ : taille du tableau
- $tab[8]$ : tableau d'entiers
- $max, min$ : valeurs maximale et minimale
- $posMax, posMin$ : indices correspondants

Algorithme de recherche :
1. Initialiser $max = tab[0]$ et $min = tab[0]$
2. Pour chaque élément $tab[i]$ avec $i = 1$ à $N-1$ :
   Si $tab[i] > max$ alors $max = tab[i]$ et $posMax = i$
   Si $tab[i] < min$ alors $min = tab[i]$ et $posMin = i$

Exemple avec le tableau $[12, 5, 23, 8, 15, 3, 19, 11]$ :

État initial : $max = 12$, $min = 12$, $posMax = 0$, $posMin = 0$

Itération $i = 1$ : $tab[1] = 5$
  - $5 < 12$ donc $min = 5$, $posMin = 1$

Itération $i = 2$ : $tab[2] = 23$
  - $23 > 12$ donc $max = 23$, $posMax = 2$

Itération $i = 5$ : $tab[5] = 3$
  - $3 < 5$ donc $min = 3$, $posMin = 5$

Résultat final :
$max = 23$ à la position $2$
$min = 3$ à la position $5$",
    "id_category": "2",
    "id_number": "43"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui lit une matrice $3 \\times 3$ d'entiers et calcule la somme des éléments de sa diagonale principale. La diagonale principale contient les éléments $a_{ii}$ pour $i = 0, 1, 2$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code C++ :
#include <iostream>\nusing namespace std;\n\nint main() {\n    const int N = 3;\n    int matrice[N][N];\n    int sommeDiag = 0;\n    \n    // Lecture de la matrice\n    cout << \"Entrez les elements de la matrice 3x3 :\" << endl;\n    for(int i = 0; i < N; i++) {\n        for(int j = 0; j < N; j++) {\n            cout << \"Element [\" << i << \"][\" << j << \"] : \";\n            cin >> matrice[i][j];\n        }\n    }\n    \n    // Calcul de la somme de la diagonale principale\n    for(int i = 0; i < N; i++) {\n        sommeDiag = sommeDiag + matrice[i][i];\n    }\n    \n    // Affichage de la matrice\n    cout << \"\\nMatrice saisie :\" << endl;\n    for(int i = 0; i < N; i++) {\n        for(int j = 0; j < N; j++) {\n            cout << matrice[i][j] << \"\\t\";\n        }\n        cout << endl;\n    }\n    \n    // Affichage du résultat\n    cout << \"\\nSomme de la diagonale principale : \" << sommeDiag << endl;\n    \n    return 0;\n}

Explication détaillée :

Variables :
- $N = 3$ : dimension de la matrice
- $matrice[3][3]$ : tableau 2D représentant la matrice
- $sommeDiag$ : somme de la diagonale principale

Représentation de la matrice :
$A = \\begin{pmatrix} a_{00} & a_{01} & a_{02} \\\\ a_{10} & a_{11} & a_{12} \\\\ a_{20} & a_{21} & a_{22} \\end{pmatrix}$

Diagonale principale :
Les éléments sont $a_{00}, a_{11}, a_{22}$

Formule de la somme :
$S = \\sum_{i=0}^{2} a_{ii} = a_{00} + a_{11} + a_{22}$

Exemple avec la matrice :
$A = \\begin{pmatrix} 4 & 7 & 2 \\\\ 3 & 5 & 8 \\\\ 1 & 6 & 9 \\end{pmatrix}$

Calcul :
Diagonale principale : $a_{00} = 4$, $a_{11} = 5$, $a_{22} = 9$
$S = 4 + 5 + 9 = 18$

Résultat : La somme de la diagonale principale est $18$",
    "id_category": "2",
    "id_number": "44"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui inverse l'ordre des éléments d'un tableau de $6$ entiers. Par exemple, si le tableau contient $[10, 20, 30, 40, 50, 60]$, il doit devenir $[60, 50, 40, 30, 20, 10]$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code C++ :
#include <iostream>\nusing namespace std;\n\nint main() {\n    const int N = 6;\n    int tab[N];\n    int temp;\n    \n    // Lecture du tableau\n    cout << \"Entrez 6 entiers :\" << endl;\n    for(int i = 0; i < N; i++) {\n        cout << \"Element \" << i << \" : \";\n        cin >> tab[i];\n    }\n    \n    // Affichage du tableau original\n    cout << \"\\nTableau original : \";\n    for(int i = 0; i < N; i++) {\n        cout << tab[i] << \" \";\n    }\n    cout << endl;\n    \n    // Inversion du tableau\n    for(int i = 0; i < N/2; i++) {\n        // Échange de tab[i] et tab[N-1-i]\n        temp = tab[i];\n        tab[i] = tab[N-1-i];\n        tab[N-1-i] = temp;\n    }\n    \n    // Affichage du tableau inversé\n    cout << \"Tableau inverse : \";\n    for(int i = 0; i < N; i++) {\n        cout << tab[i] << \" \";\n    }\n    cout << endl;\n    \n    return 0;\n}

Explication détaillée :

Variables :
- $N = 6$ : taille du tableau
- $tab[6]$ : tableau à inverser
- $temp$ : variable temporaire pour l'échange
- $i$ : indice de boucle allant de $0$ à $N/2 - 1$

Algorithme d'inversion :
Pour $i = 0$ à $\\lfloor N/2 \\rfloor - 1$ :
1. Sauvegarder $temp = tab[i]$
2. Copier $tab[i] = tab[N-1-i]$
3. Restaurer $tab[N-1-i] = temp$

Principe : On échange les éléments symétriques par rapport au centre.

Exemple avec $[10, 20, 30, 40, 50, 60]$ :

État initial : $[10, 20, 30, 40, 50, 60]$

Itération $i = 0$ :
  Échange $tab[0]$ et $tab[5]$
  Résultat : $[60, 20, 30, 40, 50, 10]$

Itération $i = 1$ :
  Échange $tab[1]$ et $tab[4]$
  Résultat : $[60, 50, 30, 40, 20, 10]$

Itération $i = 2$ :
  Échange $tab[2]$ et $tab[3]$
  Résultat : $[60, 50, 40, 30, 20, 10]$

Résultat final : $[60, 50, 40, 30, 20, 10]$",
    "id_category": "2",
    "id_number": "45"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui calcule le produit scalaire de deux vecteurs $\\vec{u}$ et $\\vec{v}$ de dimension $4$. Le produit scalaire est défini par $\\vec{u} \\cdot \\vec{v} = \\sum_{i=0}^{3} u_i \\times v_i$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code C++ :
#include <iostream>\nusing namespace std;\n\nint main() {\n    const int DIM = 4;\n    double u[DIM], v[DIM];\n    double produitScalaire = 0.0;\n    \n    // Lecture du vecteur u\n    cout << \"Entrez les composantes du vecteur u :\" << endl;\n    for(int i = 0; i < DIM; i++) {\n        cout << \"u[\" << i << \"] : \";\n        cin >> u[i];\n    }\n    \n    // Lecture du vecteur v\n    cout << \"\\nEntrez les composantes du vecteur v :\" << endl;\n    for(int i = 0; i < DIM; i++) {\n        cout << \"v[\" << i << \"] : \";\n        cin >> v[i];\n    }\n    \n    // Calcul du produit scalaire\n    for(int i = 0; i < DIM; i++) {\n        produitScalaire = produitScalaire + (u[i] * v[i]);\n    }\n    \n    // Affichage du résultat\n    cout << \"\\nProduit scalaire u.v = \" << produitScalaire << endl;\n    \n    return 0;\n}

Explication détaillée :

Variables :
- $DIM = 4$ : dimension des vecteurs
- $u[4], v[4]$ : tableaux représentant les vecteurs
- $produitScalaire$ : résultat du calcul

Définition mathématique :
$\\vec{u} = (u_0, u_1, u_2, u_3)$
$\\vec{v} = (v_0, v_1, v_2, v_3)$

Formule du produit scalaire :
$\\vec{u} \\cdot \\vec{v} = \\sum_{i=0}^{3} u_i v_i = u_0 v_0 + u_1 v_1 + u_2 v_2 + u_3 v_3$

Algorithme :
1. Initialiser $produitScalaire = 0$
2. Pour $i = 0$ à $3$ :
   $produitScalaire = produitScalaire + u[i] \\times v[i]$
3. Retourner $produitScalaire$

Exemple avec :
$\\vec{u} = (1, 2, 3, 4)$
$\\vec{v} = (5, 6, 7, 8)$

Calcul détaillé :
$produitScalaire = 0$ (initial)
$i = 0 : produitScalaire = 0 + (1 \\times 5) = 5$
$i = 1 : produitScalaire = 5 + (2 \\times 6) = 5 + 12 = 17$
$i = 2 : produitScalaire = 17 + (3 \\times 7) = 17 + 21 = 38$
$i = 3 : produitScalaire = 38 + (4 \\times 8) = 38 + 32 = 70$

Résultat : $\\vec{u} \\cdot \\vec{v} = 70$",
    "id_category": "2",
    "id_number": "46"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui vérifie si un nombre entier $n$ saisi par l'utilisateur est premier. Un nombre premier est un entier $n > 1$ qui n'est divisible que par $1$ et par lui-même.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code C++ :
#include <iostream>\n#include <cmath>\nusing namespace std;\n\nint main() {\n    int n;\n    bool estPremier = true;\n    \n    // Lecture de n\n    cout << \"Entrez un entier n : \";\n    cin >> n;\n    \n    // Vérification si n <= 1\n    if(n <= 1) {\n        estPremier = false;\n    }\n    else {\n        // Test de divisibilité de 2 à sqrt(n)\n        for(int i = 2; i <= sqrt(n); i++) {\n            if(n % i == 0) {\n                estPremier = false;\n                break;  // On peut arrêter dès qu'on trouve un diviseur\n            }\n        }\n    }\n    \n    // Affichage du résultat\n    if(estPremier) {\n        cout << n << \" est un nombre premier\" << endl;\n    }\n    else {\n        cout << n << \" n'est pas un nombre premier\" << endl;\n    }\n    \n    return 0;\n}

Explication détaillée :

Variables :
- $n$ : le nombre à tester
- $estPremier$ : booléen initialisé à $true$
- $i$ : diviseur potentiel

Définition mathématique :
Un nombre $n$ est premier si et seulement si :
$n > 1$ et $\\forall d \\in \\{2, 3, ..., n-1\\}, n \\bmod d \\neq 0$

Optimisation :
Il suffit de tester les diviseurs jusqu'à $\\sqrt{n}$ car si $n = a \\times b$ avec $a \\leq b$, alors $a \\leq \\sqrt{n}$.

Algorithme :
1. Si $n \\leq 1$, alors $n$ n'est pas premier
2. Pour $i = 2$ à $\\lfloor \\sqrt{n} \\rfloor$ :
   Si $n \\bmod i = 0$, alors $n$ n'est pas premier
3. Sinon, $n$ est premier

Exemple pour $n = 17$ :
$\\sqrt{17} \\approx 4.12$
Test des diviseurs $2, 3, 4$ :
  - $17 \\bmod 2 = 1 \\neq 0$
  - $17 \\bmod 3 = 2 \\neq 0$
  - $17 \\bmod 4 = 1 \\neq 0$
Aucun diviseur trouvé, donc $17$ est premier.

Exemple pour $n = 15$ :
$\\sqrt{15} \\approx 3.87$
Test des diviseurs $2, 3$ :
  - $15 \\bmod 2 = 1 \\neq 0$
  - $15 \\bmod 3 = 0$
Diviseur trouvé, donc $15$ n'est pas premier.",
    "id_category": "2",
    "id_number": "47"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui transpose une matrice $2 \\times 3$. La transposée d'une matrice $A$ de dimension $m \\times n$ est une matrice $A^T$ de dimension $n \\times m$ telle que $A^T_{ji} = A_{ij}$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code C++ :
#include <iostream>\nusing namespace std;\n\nint main() {\n    const int LIGNES = 2;\n    const int COLONNES = 3;\n    int matrice[LIGNES][COLONNES];\n    int transposee[COLONNES][LIGNES];\n    \n    // Lecture de la matrice 2x3\n    cout << \"Entrez les elements de la matrice 2x3 :\" << endl;\n    for(int i = 0; i < LIGNES; i++) {\n        for(int j = 0; j < COLONNES; j++) {\n            cout << \"Element [\" << i << \"][\" << j << \"] : \";\n            cin >> matrice[i][j];\n        }\n    }\n    \n    // Calcul de la transposée\n    for(int i = 0; i < LIGNES; i++) {\n        for(int j = 0; j < COLONNES; j++) {\n            transposee[j][i] = matrice[i][j];\n        }\n    }\n    \n    // Affichage de la matrice originale\n    cout << \"\\nMatrice originale (2x3) :\" << endl;\n    for(int i = 0; i < LIGNES; i++) {\n        for(int j = 0; j < COLONNES; j++) {\n            cout << matrice[i][j] << \"\\t\";\n        }\n        cout << endl;\n    }\n    \n    // Affichage de la transposée\n    cout << \"\\nMatrice transposee (3x2) :\" << endl;\n    for(int i = 0; i < COLONNES; i++) {\n        for(int j = 0; j < LIGNES; j++) {\n            cout << transposee[i][j] << \"\\t\";\n        }\n        cout << endl;\n    }\n    \n    return 0;\n}

Explication détaillée :

Variables :
- $LIGNES = 2, COLONNES = 3$
- $matrice[2][3]$ : matrice originale
- $transposee[3][2]$ : matrice transposée

Définition de la transposition :
Si $A$ est une matrice $m \\times n$, alors $A^T$ est une matrice $n \\times m$ telle que :
$(A^T)_{ji} = A_{ij}$

Représentation mathématique :
Matrice originale $A$ ($2 \\times 3$) :
$A = \\begin{pmatrix} a_{00} & a_{01} & a_{02} \\\\ a_{10} & a_{11} & a_{12} \\end{pmatrix}$

Matrice transposée $A^T$ ($3 \\times 2$) :
$A^T = \\begin{pmatrix} a_{00} & a_{10} \\\\ a_{01} & a_{11} \\\\ a_{02} & a_{12} \\end{pmatrix}$

Algorithme :
Pour $i = 0$ à $LIGNES-1$ :
  Pour $j = 0$ à $COLONNES-1$ :
    $transposee[j][i] = matrice[i][j]$

Exemple numérique avec :
$A = \\begin{pmatrix} 1 & 2 & 3 \\\\ 4 & 5 & 6 \\end{pmatrix}$

Application :
$transposee[0][0] = matrice[0][0] = 1$
$transposee[0][1] = matrice[1][0] = 4$
$transposee[1][0] = matrice[0][1] = 2$
$transposee[1][1] = matrice[1][1] = 5$
$transposee[2][0] = matrice[0][2] = 3$
$transposee[2][1] = matrice[1][2] = 6$

Résultat :
$A^T = \\begin{pmatrix} 1 & 4 \\\\ 2 & 5 \\\\ 3 & 6 \\end{pmatrix}$",
    "id_category": "2",
    "id_number": "48"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui compte le nombre d'occurrences d'un élément $x$ donné dans un tableau de $12$ entiers. Afficher le nombre total d'occurrences trouvées.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code C++ :
#include <iostream>\nusing namespace std;\n\nint main() {\n    const int N = 12;\n    int tab[N];\n    int x;\n    int compteur = 0;\n    \n    // Remplissage du tableau\n    cout << \"Entrez 12 entiers :\" << endl;\n    for(int i = 0; i < N; i++) {\n        cout << \"Element \" << i << \" : \";\n        cin >> tab[i];\n    }\n    \n    // Lecture de l'élément à chercher\n    cout << \"\\nEntrez l'element a chercher : \";\n    cin >> x;\n    \n    // Comptage des occurrences\n    for(int i = 0; i < N; i++) {\n        if(tab[i] == x) {\n            compteur++;  // Incrémenter si égalité\n        }\n    }\n    \n    // Affichage du résultat\n    cout << \"\\nL'element \" << x << \" apparait \" << compteur << \" fois dans le tableau\" << endl;\n    \n    return 0;\n}

Explication détaillée :

Variables :
- $N = 12$ : taille du tableau
- $tab[12]$ : tableau d'entiers
- $x$ : élément à chercher
- $compteur$ : nombre d'occurrences, initialisé à $0$

Algorithme de comptage :
1. Initialiser $compteur = 0$
2. Pour chaque élément $tab[i]$ avec $i = 0$ à $N-1$ :
   Si $tab[i] = x$ alors $compteur = compteur + 1$
3. Retourner $compteur$

Formule mathématique :
Le nombre d'occurrences est :
$C = \\sum_{i=0}^{N-1} \\delta_{tab[i], x}$
où $\\delta_{a,b} = \\begin{cases} 1 & \\text{si } a = b \\\\ 0 & \\text{sinon} \\end{cases}$

Exemple avec le tableau :
$[5, 3, 8, 5, 2, 5, 7, 1, 5, 9, 4, 6]$
et $x = 5$

Parcours du tableau :
$i = 0 : tab[0] = 5 = x \\Rightarrow compteur = 1$
$i = 1 : tab[1] = 3 \\neq x$
$i = 2 : tab[2] = 8 \\neq x$
$i = 3 : tab[3] = 5 = x \\Rightarrow compteur = 2$
$i = 4 : tab[4] = 2 \\neq x$
$i = 5 : tab[5] = 5 = x \\Rightarrow compteur = 3$
$i = 6 : tab[6] = 7 \\neq x$
$i = 7 : tab[7] = 1 \\neq x$
$i = 8 : tab[8] = 5 = x \\Rightarrow compteur = 4$
$i = 9 : tab[9] = 9 \\neq x$
$i = 10 : tab[10] = 4 \\neq x$
$i = 11 : tab[11] = 6 \\neq x$

Résultat : L'élément $5$ apparaît $4$ fois dans le tableau.",
    "id_category": "2",
    "id_number": "49"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui calcule la somme de deux matrices $A$ et $B$ de dimension $2 \\times 2$. La somme de deux matrices est définie par $C_{ij} = A_{ij} + B_{ij}$ pour tous les indices $i, j$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code C++ :
#include <iostream>\nusing namespace std;\n\nint main() {\n    const int N = 2;\n    int A[N][N], B[N][N], C[N][N];\n    \n    // Lecture de la matrice A\n    cout << \"Entrez les elements de la matrice A (2x2) :\" << endl;\n    for(int i = 0; i < N; i++) {\n        for(int j = 0; j < N; j++) {\n            cout << \"A[\" << i << \"][\" << j << \"] : \";\n            cin >> A[i][j];\n        }\n    }\n    \n    // Lecture de la matrice B\n    cout << \"\\nEntrez les elements de la matrice B (2x2) :\" << endl;\n    for(int i = 0; i < N; i++) {\n        for(int j = 0; j < N; j++) {\n            cout << \"B[\" << i << \"][\" << j << \"] : \";\n            cin >> B[i][j];\n        }\n    }\n    \n    // Calcul de la somme C = A + B\n    for(int i = 0; i < N; i++) {\n        for(int j = 0; j < N; j++) {\n            C[i][j] = A[i][j] + B[i][j];\n        }\n    }\n    \n    // Affichage de la matrice A\n    cout << \"\\nMatrice A :\" << endl;\n    for(int i = 0; i < N; i++) {\n        for(int j = 0; j < N; j++) {\n            cout << A[i][j] << \"\\t\";\n        }\n        cout << endl;\n    }\n    \n    // Affichage de la matrice B\n    cout << \"\\nMatrice B :\" << endl;\n    for(int i = 0; i < N; i++) {\n        for(int j = 0; j < N; j++) {\n            cout << B[i][j] << \"\\t\";\n        }\n        cout << endl;\n    }\n    \n    // Affichage de la somme C\n    cout << \"\\nMatrice C = A + B :\" << endl;\n    for(int i = 0; i < N; i++) {\n        for(int j = 0; j < N; j++) {\n            cout << C[i][j] << \"\\t\";\n        }\n        cout << endl;\n    }\n    \n    return 0;\n}

Explication détaillée :

Variables :
- $N = 2$ : dimension des matrices
- $A[2][2], B[2][2]$ : matrices d'entrée
- $C[2][2]$ : matrice résultat de la somme

Définition de l'addition matricielle :
Soit $A$ et $B$ deux matrices de même dimension $m \\times n$. Leur somme $C = A + B$ est définie par :
$C_{ij} = A_{ij} + B_{ij}, \\quad \\forall i \\in \\{0, ..., m-1\\}, \\forall j \\in \\{0, ..., n-1\\}$

Algorithme :
Pour $i = 0$ à $N-1$ :
  Pour $j = 0$ à $N-1$ :
    $C[i][j] = A[i][j] + B[i][j]$

Exemple numérique avec :
$A = \\begin{pmatrix} 1 & 2 \\\\ 3 & 4 \\end{pmatrix}, \\quad B = \\begin{pmatrix} 5 & 6 \\\\ 7 & 8 \\end{pmatrix}$

Calcul élément par élément :
$C_{00} = A_{00} + B_{00} = 1 + 5 = 6$
$C_{01} = A_{01} + B_{01} = 2 + 6 = 8$
$C_{10} = A_{10} + B_{10} = 3 + 7 = 10$
$C_{11} = A_{11} + B_{11} = 4 + 8 = 12$

Résultat :
$C = A + B = \\begin{pmatrix} 6 & 8 \\\\ 10 & 12 \\end{pmatrix}$

Propriétés de l'addition matricielle :
- Commutativité : $A + B = B + A$
- Associativité : $(A + B) + C = A + (B + C)$",
    "id_category": "2",
    "id_number": "50"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui trie un tableau de $7$ entiers dans l'ordre croissant en utilisant l'algorithme du tri par sélection. L'algorithme consiste à trouver le minimum du tableau et à l'échanger avec le premier élément, puis à répéter pour le reste du tableau.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code C++ :
#include <iostream>\nusing namespace std;\n\nint main() {\n    const int N = 7;\n    int tab[N];\n    int minIndex, temp;\n    \n    // Remplissage du tableau\n    cout << \"Entrez 7 entiers :\" << endl;\n    for(int i = 0; i < N; i++) {\n        cout << \"Element \" << i << \" : \";\n        cin >> tab[i];\n    }\n    \n    // Affichage du tableau original\n    cout << \"\\nTableau original : \";\n    for(int i = 0; i < N; i++) {\n        cout << tab[i] << \" \";\n    }\n    cout << endl;\n    \n    // Tri par sélection\n    for(int i = 0; i < N-1; i++) {\n        // Trouver l'indice du minimum dans tab[i..N-1]\n        minIndex = i;\n        for(int j = i+1; j < N; j++) {\n            if(tab[j] < tab[minIndex]) {\n                minIndex = j;\n            }\n        }\n        \n        // Échanger tab[i] et tab[minIndex]\n        if(minIndex != i) {\n            temp = tab[i];\n            tab[i] = tab[minIndex];\n            tab[minIndex] = temp;\n        }\n    }\n    \n    // Affichage du tableau trié\n    cout << \"Tableau trie : \";\n    for(int i = 0; i < N; i++) {\n        cout << tab[i] << \" \";\n    }\n    cout << endl;\n    \n    return 0;\n}

Explication détaillée :

Variables :
- $N = 7$ : taille du tableau
- $tab[7]$ : tableau à trier
- $minIndex$ : indice du minimum dans la partie non triée
- $temp$ : variable pour l'échange

Principe du tri par sélection :
Pour $i = 0$ à $N-2$ :
1. Trouver l'indice $minIndex$ du minimum dans $tab[i..N-1]$
2. Échanger $tab[i]$ avec $tab[minIndex]$

Complexité temporelle :
Nombre de comparaisons : $\\sum_{i=0}^{N-2} (N-1-i) = \\frac{N(N-1)}{2} = O(N^2)$

Exemple avec le tableau $[64, 25, 12, 22, 11, 90, 15]$ :

Itération $i = 0$ :
Chercher min dans $[64, 25, 12, 22, 11, 90, 15]$
Minimum : $11$ à l'indice $4$
Échanger $tab[0]$ et $tab[4]$ : $[11, 25, 12, 22, 64, 90, 15]$

Itération $i = 1$ :
Chercher min dans $[25, 12, 22, 64, 90, 15]$
Minimum : $12$ à l'indice $2$
Échanger $tab[1]$ et $tab[2]$ : $[11, 12, 25, 22, 64, 90, 15]$

Itération $i = 2$ :
Chercher min dans $[25, 22, 64, 90, 15]$
Minimum : $15$ à l'indice $6$
Échanger $tab[2]$ et $tab[6]$ : $[11, 12, 15, 22, 64, 90, 25]$

Itération $i = 3$ :
Minimum : $22$ (déjà en place)

Itération $i = 4$ :
Chercher min dans $[64, 90, 25]$
Minimum : $25$ à l'indice $6$
Échanger : $[11, 12, 15, 22, 25, 90, 64]$

Itération $i = 5$ :
Chercher min dans $[90, 64]$
Minimum : $64$
Échanger : $[11, 12, 15, 22, 25, 64, 90]$

Résultat final : $[11, 12, 15, 22, 25, 64, 90]$",
    "id_category": "2",
    "id_number": "51"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui calcule la puissance $x^n$ d'un nombre réel $x$ élevé à un entier positif $n$ en utilisant une boucle. Ne pas utiliser la fonction $pow()$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code C++ :
#include <iostream>\nusing namespace std;\n\nint main() {\n    double x;\n    int n;\n    double resultat = 1.0;\n    \n    // Lecture des valeurs\n    cout << \"Entrez la base x : \";\n    cin >> x;\n    cout << \"Entrez l'exposant n (entier positif) : \";\n    cin >> n;\n    \n    // Vérification\n    if(n < 0) {\n        cout << \"Erreur : n doit etre >= 0\" << endl;\n        return 1;\n    }\n    \n    // Calcul de x^n\n    for(int i = 0; i < n; i++) {\n        resultat = resultat * x;\n    }\n    \n    // Affichage du résultat\n    cout << x << \" ^ \" << n << \" = \" << resultat << endl;\n    \n    return 0;\n}

Explication détaillée :

Variables :
- $x$ : la base (nombre réel)
- $n$ : l'exposant (entier positif)
- $resultat$ : accumulateur initialisé à $1.0$
- $i$ : compteur de boucle

Définition mathématique de la puissance :
$x^n = \\underbrace{x \\times x \\times ... \\times x}_{n \\text{ fois}}$
Avec la convention : $x^0 = 1$ pour tout $x \\neq 0$

Algorithme :
1. Initialiser $resultat = 1$
2. Répéter $n$ fois :
   $resultat = resultat \\times x$
3. Retourner $resultat$

Formule récursive équivalente :
$x^n = \\begin{cases} 1 & \\text{si } n = 0 \\\\ x \\times x^{n-1} & \\text{si } n > 0 \\end{cases}$

Exemple pour $x = 2$ et $n = 5$ :

État initial : $resultat = 1$

Itération $i = 0$ : $resultat = 1 \\times 2 = 2$
Itération $i = 1$ : $resultat = 2 \\times 2 = 4$
Itération $i = 2$ : $resultat = 4 \\times 2 = 8$
Itération $i = 3$ : $resultat = 8 \\times 2 = 16$
Itération $i = 4$ : $resultat = 16 \\times 2 = 32$

Résultat : $2^5 = 32$

Cas particuliers :
- $x^0 = 1$ pour tout $x \\neq 0$
- $x^1 = x$
- $0^n = 0$ pour tout $n > 0$

Exemple pour $x = 3.5$ et $n = 3$ :
$resultat = 1 \\times 3.5 \\times 3.5 \\times 3.5 = 42.875$",
    "id_category": "2",
    "id_number": "52"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui calcule la norme euclidienne (longueur) d'un vecteur de dimension $5$. La norme euclidienne d'un vecteur $\\vec{v} = (v_0, v_1, ..., v_4)$ est définie par $\\|\\vec{v}\\| = \\sqrt{v_0^2 + v_1^2 + ... + v_4^2}$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code C++ :
#include <iostream>\n#include <cmath>\nusing namespace std;\n\nint main() {\n    const int DIM = 5;\n    double v[DIM];\n    double sommeCarre = 0.0;\n    double norme;\n    \n    // Lecture du vecteur\n    cout << \"Entrez les composantes du vecteur (5 valeurs) :\" << endl;\n    for(int i = 0; i < DIM; i++) {\n        cout << \"v[\" << i << \"] : \";\n        cin >> v[i];\n    }\n    \n    // Calcul de la somme des carrés\n    for(int i = 0; i < DIM; i++) {\n        sommeCarre = sommeCarre + (v[i] * v[i]);\n    }\n    \n    // Calcul de la norme (racine carrée)\n    norme = sqrt(sommeCarre);\n    \n    // Affichage du résultat\n    cout << \"\\nNorme euclidienne : \" << norme << endl;\n    \n    return 0;\n}

Explication détaillée :

Variables :
- $DIM = 5$ : dimension du vecteur
- $v[5]$ : tableau représentant le vecteur
- $sommeCarre$ : somme des carrés des composantes
- $norme$ : norme euclidienne (résultat final)

Définition de la norme euclidienne :
Pour un vecteur $\\vec{v} = (v_0, v_1, v_2, v_3, v_4)$ dans $\\mathbb{R}^5$, la norme euclidienne est :
$\\|\\vec{v}\\| = \\sqrt{\\sum_{i=0}^{4} v_i^2} = \\sqrt{v_0^2 + v_1^2 + v_2^2 + v_3^2 + v_4^2}$

Propriété : La norme euclidienne représente la distance du point $\\vec{v}$ à l'origine dans l'espace $\\mathbb{R}^5$.

Algorithme :
1. Initialiser $sommeCarre = 0$
2. Pour $i = 0$ à $4$ :
   $sommeCarre = sommeCarre + v_i^2$
3. Calculer $norme = \\sqrt{sommeCarre}$
4. Retourner $norme$

Exemple avec le vecteur $\\vec{v} = (3, 4, 0, 0, 0)$ :

Calcul de la somme des carrés :
$sommeCarre = 3^2 + 4^2 + 0^2 + 0^2 + 0^2$
$sommeCarre = 9 + 16 + 0 + 0 + 0 = 25$

Calcul de la norme :
$norme = \\sqrt{25} = 5$

Résultat : $\\|\\vec{v}\\| = 5$

Exemple avec le vecteur $\\vec{v} = (1, 2, 2, 3, 1)$ :
$sommeCarre = 1^2 + 2^2 + 2^2 + 3^2 + 1^2 = 1 + 4 + 4 + 9 + 1 = 19$
$norme = \\sqrt{19} \\approx 4.359$

Propriétés de la norme :
- $\\|\\vec{v}\\| \\geq 0$ (positivité)
- $\\|\\vec{v}\\| = 0$ si et seulement si $\\vec{v} = \\vec{0}$
- $\\|k\\vec{v}\\| = |k| \\|\\vec{v}\\|$ (homogénéité)",
    "id_category": "2",
    "id_number": "53"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui affiche la suite de Fibonacci jusqu'au $n$-ième terme. La suite de Fibonacci est définie par $F_0 = 0$, $F_1 = 1$, et $F_k = F_{k-1} + F_{k-2}$ pour $k \\geq 2$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code C++ :
#include <iostream>\nusing namespace std;\n\nint main() {\n    int n;\n    long long fib0 = 0, fib1 = 1, fibNext;\n    \n    // Lecture de n\n    cout << \"Entrez le nombre de termes n : \";\n    cin >> n;\n    \n    // Vérification\n    if(n < 1) {\n        cout << \"Erreur : n doit etre >= 1\" << endl;\n        return 1;\n    }\n    \n    cout << \"\\nSuite de Fibonacci (\" << n << \" premiers termes) :\" << endl;\n    \n    // Cas particuliers\n    if(n >= 1) {\n        cout << \"F(0) = \" << fib0 << endl;\n    }\n    if(n >= 2) {\n        cout << \"F(1) = \" << fib1 << endl;\n    }\n    \n    // Calcul des termes suivants\n    for(int i = 2; i < n; i++) {\n        fibNext = fib0 + fib1;\n        cout << \"F(\" << i << \") = \" << fibNext << endl;\n        \n        // Mise à jour pour l'itération suivante\n        fib0 = fib1;\n        fib1 = fibNext;\n    }\n    \n    return 0;\n}

Explication détaillée :

Variables :
- $n$ : nombre de termes à afficher
- $fib0, fib1$ : deux termes consécutifs de la suite
- $fibNext$ : terme suivant calculé
- $i$ : indice du terme

Définition récursive de Fibonacci :
$F_k = \\begin{cases} 0 & \\text{si } k = 0 \\\\ 1 & \\text{si } k = 1 \\\\ F_{k-1} + F_{k-2} & \\text{si } k \\geq 2 \\end{cases}$

Algorithme itératif :
1. Initialiser $F_0 = 0$ et $F_1 = 1$
2. Pour $k = 2$ à $n-1$ :
   a) Calculer $F_k = F_{k-1} + F_{k-2}$
   b) Mettre à jour : $F_{k-2} \\leftarrow F_{k-1}$ et $F_{k-1} \\leftarrow F_k$

Exemple pour $n = 8$ :

$F_0 = 0$
$F_1 = 1$
$F_2 = F_1 + F_0 = 1 + 0 = 1$
$F_3 = F_2 + F_1 = 1 + 1 = 2$
$F_4 = F_3 + F_2 = 2 + 1 = 3$
$F_5 = F_4 + F_3 = 3 + 2 = 5$
$F_6 = F_5 + F_4 = 5 + 3 = 8$
$F_7 = F_6 + F_5 = 8 + 5 = 13$

Séquence complète : $0, 1, 1, 2, 3, 5, 8, 13$

Détail des itérations :

Initial : $fib0 = 0, fib1 = 1$

Itération $i = 2$ :
  $fibNext = 0 + 1 = 1$
  Mise à jour : $fib0 = 1, fib1 = 1$

Itération $i = 3$ :
  $fibNext = 1 + 1 = 2$
  Mise à jour : $fib0 = 1, fib1 = 2$

Itération $i = 4$ :
  $fibNext = 1 + 2 = 3$
  Mise à jour : $fib0 = 2, fib1 = 3$

Formule de Binet (formule explicite) :
$F_n = \\frac{\\phi^n - \\psi^n}{\\sqrt{5}}$
où $\\phi = \\frac{1 + \\sqrt{5}}{2} \\approx 1.618$ (nombre d'or) et $\\psi = \\frac{1 - \\sqrt{5}}{2}$",
    "id_category": "2",
    "id_number": "54"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui multiplie une matrice $2 \\times 3$ par un scalaire $k$. La multiplication par un scalaire est définie par $(kA)_{ij} = k \\times A_{ij}$ pour tous les indices $i, j$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code C++ :
#include <iostream>\nusing namespace std;\n\nint main() {\n    const int LIGNES = 2;\n    const int COLONNES = 3;\n    double A[LIGNES][COLONNES];\n    double B[LIGNES][COLONNES];  // Résultat\n    double k;\n    \n    // Lecture de la matrice A\n    cout << \"Entrez les elements de la matrice 2x3 :\" << endl;\n    for(int i = 0; i < LIGNES; i++) {\n        for(int j = 0; j < COLONNES; j++) {\n            cout << \"A[\" << i << \"][\" << j << \"] : \";\n            cin >> A[i][j];\n        }\n    }\n    \n    // Lecture du scalaire k\n    cout << \"\\nEntrez le scalaire k : \";\n    cin >> k;\n    \n    // Multiplication par le scalaire\n    for(int i = 0; i < LIGNES; i++) {\n        for(int j = 0; j < COLONNES; j++) {\n            B[i][j] = k * A[i][j];\n        }\n    }\n    \n    // Affichage de la matrice A\n    cout << \"\\nMatrice A originale :\" << endl;\n    for(int i = 0; i < LIGNES; i++) {\n        for(int j = 0; j < COLONNES; j++) {\n            cout << A[i][j] << \"\\t\";\n        }\n        cout << endl;\n    }\n    \n    // Affichage de la matrice B = k*A\n    cout << \"\\nMatrice B = \" << k << \" * A :\" << endl;\n    for(int i = 0; i < LIGNES; i++) {\n        for(int j = 0; j < COLONNES; j++) {\n            cout << B[i][j] << \"\\t\";\n        }\n        cout << endl;\n    }\n    \n    return 0;\n}

Explication détaillée :

Variables :
- $LIGNES = 2, COLONNES = 3$
- $A[2][3]$ : matrice d'entrée
- $B[2][3]$ : matrice résultat
- $k$ : scalaire multiplicateur

Définition de la multiplication scalaire :
Soit $A$ une matrice $m \\times n$ et $k \\in \\mathbb{R}$ un scalaire. Le produit $B = kA$ est défini par :
$B_{ij} = k \\cdot A_{ij}, \\quad \\forall i \\in \\{0, ..., m-1\\}, \\forall j \\in \\{0, ..., n-1\\}$

Représentation matricielle :
Si $A = \\begin{pmatrix} a_{00} & a_{01} & a_{02} \\\\ a_{10} & a_{11} & a_{12} \\end{pmatrix}$

Alors $kA = \\begin{pmatrix} k \\cdot a_{00} & k \\cdot a_{01} & k \\cdot a_{02} \\\\ k \\cdot a_{10} & k \\cdot a_{11} & k \\cdot a_{12} \\end{pmatrix}$

Algorithme :
Pour $i = 0$ à $LIGNES-1$ :
  Pour $j = 0$ à $COLONNES-1$ :
    $B[i][j] = k \\times A[i][j]$

Exemple numérique avec :
$A = \\begin{pmatrix} 2 & 4 & 6 \\\\ 1 & 3 & 5 \\end{pmatrix}$ et $k = 3$

Calcul élément par élément :
$B_{00} = 3 \\times 2 = 6$
$B_{01} = 3 \\times 4 = 12$
$B_{02} = 3 \\times 6 = 18$
$B_{10} = 3 \\times 1 = 3$
$B_{11} = 3 \\times 3 = 9$
$B_{12} = 3 \\times 5 = 15$

Résultat :
$B = 3A = \\begin{pmatrix} 6 & 12 & 18 \\\\ 3 & 9 & 15 \\end{pmatrix}$

Propriétés de la multiplication scalaire :
- $k(A + B) = kA + kB$ (distributivité)
- $(k_1 + k_2)A = k_1 A + k_2 A$
- $(k_1 k_2)A = k_1(k_2 A)$ (associativité)
- $1 \\cdot A = A$ (élément neutre)",
    "id_category": "2",
    "id_number": "55"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui recherche un élément $x$ dans un tableau trié de $10$ entiers en utilisant la recherche binaire (dichotomique). L'algorithme compare $x$ avec l'élément du milieu et réduit l'intervalle de recherche de moitié à chaque itération.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code C++ :
#include <iostream>\nusing namespace std;\n\nint main() {\n    const int N = 10;\n    int tab[N];\n    int x;\n    int gauche, droite, milieu;\n    bool trouve = false;\n    int position = -1;\n    \n    // Remplissage du tableau (doit être trié)\n    cout << \"Entrez 10 entiers TRIES dans l'ordre croissant :\" << endl;\n    for(int i = 0; i < N; i++) {\n        cout << \"Element \" << i << \" : \";\n        cin >> tab[i];\n    }\n    \n    // Lecture de l'élément à chercher\n    cout << \"\\nEntrez l'element a chercher : \";\n    cin >> x;\n    \n    // Recherche binaire\n    gauche = 0;\n    droite = N - 1;\n    \n    while(gauche <= droite && !trouve) {\n        milieu = (gauche + droite) / 2;\n        \n        if(tab[milieu] == x) {\n            trouve = true;\n            position = milieu;\n        }\n        else if(x < tab[milieu]) {\n            droite = milieu - 1;  // Chercher dans la moitié gauche\n        }\n        else {\n            gauche = milieu + 1;  // Chercher dans la moitié droite\n        }\n    }\n    \n    // Affichage du résultat\n    if(trouve) {\n        cout << \"\\nElement \" << x << \" trouve a la position \" << position << endl;\n    }\n    else {\n        cout << \"\\nElement \" << x << \" non trouve dans le tableau\" << endl;\n    }\n    \n    return 0;\n}

Explication détaillée :

Variables :
- $N = 10$ : taille du tableau
- $tab[10]$ : tableau trié d'entiers
- $x$ : élément à rechercher
- $gauche, droite$ : bornes de l'intervalle de recherche
- $milieu$ : indice de l'élément central
- $trouve$ : booléen indiquant si l'élément est trouvé

Principe de la recherche binaire :
Pour un tableau trié, on compare $x$ avec l'élément du milieu :
- Si $x = tab[milieu]$, l'élément est trouvé
- Si $x < tab[milieu]$, chercher dans la moitié gauche
- Si $x > tab[milieu]$, chercher dans la moitié droite

Algorithme :
1. Initialiser $gauche = 0$ et $droite = N-1$
2. Tant que $gauche \\leq droite$ :
   a) Calculer $milieu = \\lfloor \\frac{gauche + droite}{2} \\rfloor$
   b) Si $tab[milieu] = x$, retourner $milieu$
   c) Si $x < tab[milieu]$, alors $droite = milieu - 1$
   d) Sinon, $gauche = milieu + 1$
3. Retourner \"non trouvé\"

Complexité temporelle :
À chaque itération, la taille de l'intervalle est divisée par $2$. Donc :
$T(n) = O(\\log_2 n)$

Exemple avec le tableau trié $[2, 5, 8, 12, 16, 23, 38, 45, 56, 67]$ et $x = 23$ :

Itération 1 :
$gauche = 0, droite = 9$
$milieu = \\lfloor \\frac{0+9}{2} \\rfloor = 4$
$tab[4] = 16 < 23$ donc $gauche = 5$

Itération 2 :
$gauche = 5, droite = 9$
$milieu = \\lfloor \\frac{5+9}{2} \\rfloor = 7$
$tab[7] = 45 > 23$ donc $droite = 6$

Itération 3 :
$gauche = 5, droite = 6$
$milieu = \\lfloor \\frac{5+6}{2} \\rfloor = 5$
$tab[5] = 23 = x$

Résultat : Élément $23$ trouvé à la position $5$

Condition nécessaire : Le tableau doit être trié pour que l'algorithme fonctionne correctement.",
    "id_category": "2",
    "id_number": "56"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui calcule le PGCD (Plus Grand Commun Diviseur) de deux entiers positifs $a$ et $b$ en utilisant l'algorithme d'Euclide. L'algorithme est basé sur la relation $\\text{PGCD}(a, b) = \\text{PGCD}(b, a \\bmod b)$ jusqu'à ce que $b = 0$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code C++ :
#include <iostream>\nusing namespace std;\n\nint main() {\n    int a, b;\n    int reste;\n    int a_initial, b_initial;  // Pour l'affichage final\n    \n    // Lecture des deux entiers\n    cout << \"Entrez le premier entier a : \";\n    cin >> a;\n    cout << \"Entrez le deuxieme entier b : \";\n    cin >> b;\n    \n    // Vérification\n    if(a <= 0 || b <= 0) {\n        cout << \"Erreur : a et b doivent etre positifs\" << endl;\n        return 1;\n    }\n    \n    // Sauvegarde des valeurs initiales\n    a_initial = a;\n    b_initial = b;\n    \n    // Algorithme d'Euclide\n    while(b != 0) {\n        reste = a % b;  // Calcul du reste\n        a = b;          // a prend la valeur de b\n        b = reste;      // b prend la valeur du reste\n    }\n    \n    // À la fin, a contient le PGCD\n    cout << \"\\nPGCD(\" << a_initial << \", \" << b_initial << \") = \" << a << endl;\n    \n    return 0;\n}

Explication détaillée :

Variables :
- $a, b$ : les deux entiers dont on cherche le PGCD
- $reste$ : reste de la division euclidienne $a \\bmod b$
- $a_{initial}, b_{initial}$ : sauvegarde des valeurs d'entrée

Définition du PGCD :
Le PGCD de deux entiers $a$ et $b$ est le plus grand entier qui divise à la fois $a$ et $b$ :
$\\text{PGCD}(a, b) = \\max\\{d \\in \\mathbb{N} : d | a \\text{ et } d | b\\}$

Propriété fondamentale (algorithme d'Euclide) :
$\\text{PGCD}(a, b) = \\text{PGCD}(b, a \\bmod b)$
avec la condition d'arrêt : $\\text{PGCD}(a, 0) = a$

Algorithme d'Euclide :
Tant que $b \\neq 0$ :
1. Calculer $reste = a \\bmod b$
2. Mettre à jour : $a \\leftarrow b$ et $b \\leftarrow reste$
3. Retourner $a$

Exemple pour $a = 48$ et $b = 18$ :

Itération 1 :
$a = 48, b = 18$
$reste = 48 \\bmod 18 = 12$
Mise à jour : $a = 18, b = 12$

Itération 2 :
$a = 18, b = 12$
$reste = 18 \\bmod 12 = 6$
Mise à jour : $a = 12, b = 6$

Itération 3 :
$a = 12, b = 6$
$reste = 12 \\bmod 6 = 0$
Mise à jour : $a = 6, b = 0$

Condition d'arrêt : $b = 0$
Résultat : $\\text{PGCD}(48, 18) = 6$

Vérification :
Diviseurs de $48$ : $1, 2, 3, 4, 6, 8, 12, 16, 24, 48$
Diviseurs de $18$ : $1, 2, 3, 6, 9, 18$
Diviseurs communs : $1, 2, 3, 6$
Le plus grand est bien $6$.

Complexité : L'algorithme d'Euclide a une complexité $O(\\log \\min(a,b))$, ce qui le rend très efficace.",
    "id_category": "2",
    "id_number": "57"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui remplit une matrice identité $4 \\times 4$. Une matrice identité $I$ est une matrice carrée où $I_{ij} = 1$ si $i = j$ (diagonale principale) et $I_{ij} = 0$ si $i \\neq j$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code C++ :
#include <iostream>\nusing namespace std;\n\nint main() {\n    const int N = 4;\n    int identite[N][N];\n    \n    // Remplissage de la matrice identité\n    for(int i = 0; i < N; i++) {\n        for(int j = 0; j < N; j++) {\n            if(i == j) {\n                identite[i][j] = 1;  // Diagonale principale\n            }\n            else {\n                identite[i][j] = 0;  // Ailleurs\n            }\n        }\n    }\n    \n    // Affichage de la matrice identité\n    cout << \"Matrice identite 4x4 :\" << endl;\n    for(int i = 0; i < N; i++) {\n        for(int j = 0; j < N; j++) {\n            cout << identite[i][j] << \"\\t\";\n        }\n        cout << endl;\n    }\n    \n    return 0;\n}

Explication détaillée :

Variables :
- $N = 4$ : dimension de la matrice
- $identite[4][4]$ : matrice identité
- $i, j$ : indices de ligne et colonne

Définition de la matrice identité :
La matrice identité $I_n$ de dimension $n \\times n$ est définie par :
$I_{ij} = \\delta_{ij} = \\begin{cases} 1 & \\text{si } i = j \\\\ 0 & \\text{si } i \\neq j \\end{cases}$

où $\\delta_{ij}$ est le symbole de Kronecker.

Représentation de la matrice identité $4 \\times 4$ :
$I_4 = \\begin{pmatrix} 1 & 0 & 0 & 0 \\\\ 0 & 1 & 0 & 0 \\\\ 0 & 0 & 1 & 0 \\\\ 0 & 0 & 0 & 1 \\end{pmatrix}$

Algorithme :
Pour $i = 0$ à $N-1$ :
  Pour $j = 0$ à $N-1$ :
    Si $i = j$ alors $I[i][j] = 1$
    Sinon $I[i][j] = 0$

Détail du remplissage :

Ligne $i = 0$ :
  $j = 0 : i = j \\Rightarrow identite[0][0] = 1$
  $j = 1 : i \\neq j \\Rightarrow identite[0][1] = 0$
  $j = 2 : i \\neq j \\Rightarrow identite[0][2] = 0$
  $j = 3 : i \\neq j \\Rightarrow identite[0][3] = 0$

Ligne $i = 1$ :
  $j = 0 : i \\neq j \\Rightarrow identite[1][0] = 0$
  $j = 1 : i = j \\Rightarrow identite[1][1] = 1$
  $j = 2 : i \\neq j \\Rightarrow identite[1][2] = 0$
  $j = 3 : i \\neq j \\Rightarrow identite[1][3] = 0$

Et ainsi de suite...

Propriétés de la matrice identité :
1. $I \\cdot A = A \\cdot I = A$ pour toute matrice $A$ (élément neutre de la multiplication)
2. $I^n = I$ pour tout $n \\in \\mathbb{N}$
3. $\\det(I) = 1$ (déterminant)
4. $I^{-1} = I$ (inverse)
5. $\\text{trace}(I_n) = n$ (somme des éléments diagonaux)

Résultat affiché :
1  0  0  0\n0  1  0  0\n0  0  1  0\n0  0  0  1
",
    "id_category": "2",
    "id_number": "58"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui calcule la variance d'un ensemble de $8$ nombres réels saisis par l'utilisateur. La variance est définie par $\\sigma^2 = \\frac{1}{n} \\sum_{i=0}^{n-1} (x_i - \\bar{x})^2$, où $\\bar{x}$ est la moyenne.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code C++ :
#include <iostream>\n#include <cmath>\nusing namespace std;\n\nint main() {\n    const int N = 8;\n    double donnees[N];\n    double somme = 0.0;\n    double moyenne = 0.0;\n    double variance = 0.0;\n    double sommeEcartsCarres = 0.0;\n    \n    // Lecture des données\n    cout << \"Entrez 8 nombres reels :\" << endl;\n    for(int i = 0; i < N; i++) {\n        cout << \"Valeur \" << (i+1) << \" : \";\n        cin >> donnees[i];\n    }\n    \n    // Calcul de la moyenne\n    for(int i = 0; i < N; i++) {\n        somme = somme + donnees[i];\n    }\n    moyenne = somme / N;\n    \n    // Calcul de la somme des écarts au carré\n    for(int i = 0; i < N; i++) {\n        double ecart = donnees[i] - moyenne;\n        sommeEcartsCarres = sommeEcartsCarres + (ecart * ecart);\n    }\n    \n    // Calcul de la variance\n    variance = sommeEcartsCarres / N;\n    \n    // Affichage des résultats\n    cout << \"\\nMoyenne : \" << moyenne << endl;\n    cout << \"Variance : \" << variance << endl;\n    cout << \"Ecart-type : \" << sqrt(variance) << endl;\n    \n    return 0;\n}

Explication détaillée :

Variables :
- $N = 8$ : nombre de valeurs
- $donnees[8]$ : tableau des valeurs
- $somme$ : somme des valeurs pour calculer la moyenne
- $moyenne$ : moyenne arithmétique $\\bar{x}$
- $sommeEcartsCarres$ : somme des carrés des écarts à la moyenne
- $variance$ : résultat final $\\sigma^2$

Définition de la moyenne :
$\\bar{x} = \\frac{1}{n} \\sum_{i=0}^{n-1} x_i = \\frac{x_0 + x_1 + ... + x_{n-1}}{n}$

Définition de la variance :
$\\sigma^2 = \\frac{1}{n} \\sum_{i=0}^{n-1} (x_i - \\bar{x})^2$

Définition de l'écart-type :
$\\sigma = \\sqrt{\\sigma^2}$

Algorithme :
1. Calculer la moyenne : $\\bar{x} = \\frac{1}{n} \\sum_{i=0}^{n-1} x_i$
2. Pour chaque valeur $x_i$, calculer l'écart : $e_i = x_i - \\bar{x}$
3. Calculer la somme des carrés des écarts : $S = \\sum_{i=0}^{n-1} e_i^2$
4. Calculer la variance : $\\sigma^2 = \\frac{S}{n}$

Exemple avec les données $[2, 4, 4, 4, 5, 5, 7, 9]$ :

Étape 1 - Calcul de la moyenne :
$\\bar{x} = \\frac{2 + 4 + 4 + 4 + 5 + 5 + 7 + 9}{8} = \\frac{40}{8} = 5$

Étape 2 - Calcul des écarts :
$e_0 = 2 - 5 = -3$
$e_1 = 4 - 5 = -1$
$e_2 = 4 - 5 = -1$
$e_3 = 4 - 5 = -1$
$e_4 = 5 - 5 = 0$
$e_5 = 5 - 5 = 0$
$e_6 = 7 - 5 = 2$
$e_7 = 9 - 5 = 4$

Étape 3 - Calcul des carrés des écarts :
$e_0^2 = (-3)^2 = 9$
$e_1^2 = (-1)^2 = 1$
$e_2^2 = (-1)^2 = 1$
$e_3^2 = (-1)^2 = 1$
$e_4^2 = 0^2 = 0$
$e_5^2 = 0^2 = 0$
$e_6^2 = 2^2 = 4$
$e_7^2 = 4^2 = 16$

Somme : $S = 9 + 1 + 1 + 1 + 0 + 0 + 4 + 16 = 32$

Étape 4 - Calcul de la variance :
$\\sigma^2 = \\frac{32}{8} = 4$

Écart-type :
$\\sigma = \\sqrt{4} = 2$

Interprétation :
La variance mesure la dispersion des données autour de la moyenne. Plus elle est grande, plus les données sont dispersées.",
    "id_category": "2",
    "id_number": "59"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui vérifie si une matrice carrée $3 \\times 3$ est symétrique. Une matrice $A$ est symétrique si $A_{ij} = A_{ji}$ pour tous les indices $i, j$, c'est-à-dire si $A = A^T$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code C++ :
#include <iostream>\nusing namespace std;\n\nint main() {\n    const int N = 3;\n    int matrice[N][N];\n    bool estSymetrique = true;\n    \n    // Lecture de la matrice\n    cout << \"Entrez les elements de la matrice 3x3 :\" << endl;\n    for(int i = 0; i < N; i++) {\n        for(int j = 0; j < N; j++) {\n            cout << \"Element [\" << i << \"][\" << j << \"] : \";\n            cin >> matrice[i][j];\n        }\n    }\n    \n    // Affichage de la matrice\n    cout << \"\\nMatrice saisie :\" << endl;\n    for(int i = 0; i < N; i++) {\n        for(int j = 0; j < N; j++) {\n            cout << matrice[i][j] << \"\\t\";\n        }\n        cout << endl;\n    }\n    \n    // Vérification de la symétrie\n    for(int i = 0; i < N; i++) {\n        for(int j = 0; j < N; j++) {\n            if(matrice[i][j] != matrice[j][i]) {\n                estSymetrique = false;\n                break;  // Inutile de continuer\n            }\n        }\n        if(!estSymetrique) break;\n    }\n    \n    // Affichage du résultat\n    if(estSymetrique) {\n        cout << \"\\nLa matrice est symetrique\" << endl;\n    }\n    else {\n        cout << \"\\nLa matrice n'est pas symetrique\" << endl;\n    }\n    \n    return 0;\n}

Explication détaillée :

Variables :
- $N = 3$ : dimension de la matrice
- $matrice[3][3]$ : matrice carrée à vérifier
- $estSymetrique$ : booléen initialisé à $true$
- $i, j$ : indices de ligne et colonne

Définition d'une matrice symétrique :
Une matrice carrée $A$ de dimension $n \\times n$ est symétrique si et seulement si :
$A_{ij} = A_{ji}, \\quad \\forall i, j \\in \\{0, 1, ..., n-1\\}$

Ceci est équivalent à dire que $A = A^T$, où $A^T$ est la transposée de $A$.

Représentation générale d'une matrice symétrique $3 \\times 3$ :
$A = \\begin{pmatrix} a & b & c \\\\ b & d & e \\\\ c & e & f \\end{pmatrix}$

Notez que les éléments symétriques par rapport à la diagonale sont égaux.

Algorithme de vérification :
Pour $i = 0$ à $N-1$ :
  Pour $j = 0$ à $N-1$ :
    Si $A_{ij} \\neq A_{ji}$ alors la matrice n'est pas symétrique

Optimisation :
Il suffit de vérifier uniquement les éléments au-dessus de la diagonale ($j > i$), car la diagonale est toujours symétrique avec elle-même.

Exemple 1 - Matrice symétrique :
$A = \\begin{pmatrix} 4 & 2 & 7 \\\\ 2 & 5 & 3 \\\\ 7 & 3 & 6 \\end{pmatrix}$

Vérification :
$A_{01} = 2 = A_{10}$ ✓
$A_{02} = 7 = A_{20}$ ✓
$A_{12} = 3 = A_{21}$ ✓

Conclusion : La matrice est symétrique.

Exemple 2 - Matrice non symétrique :
$B = \\begin{pmatrix} 1 & 2 & 3 \\\\ 4 & 5 & 6 \\\\ 7 & 8 & 9 \\end{pmatrix}$

Vérification :
$B_{01} = 2 \\neq 4 = B_{10}$ ✗

Conclusion : La matrice n'est pas symétrique.

Propriétés des matrices symétriques :
1. La somme de deux matrices symétriques est symétrique
2. Le produit d'une matrice symétrique par un scalaire est symétrique
3. Les valeurs propres d'une matrice symétrique réelle sont réelles
4. $(A^T)^T = A$ (involution)",
    "id_category": "2",
    "id_number": "60"
  },
  {
    "category": "Exercices corriges en c++ ",
    "question": "Écrire un programme C++ qui effectue le produit matriciel de deux matrices : $A$ de dimension $2 \\times 3$ et $B$ de dimension $3 \\times 2$. Le produit $C = A \\times B$ est une matrice $2 \\times 2$ où $C_{ij} = \\sum_{k=0}^{2} A_{ik} \\times B_{kj}$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code C++ :
#include <iostream>\nusing namespace std;\n\nint main() {\n    const int M = 2;  // Lignes de A\n    const int N = 3;  // Colonnes de A = Lignes de B\n    const int P = 2;  // Colonnes de B\n    \n    int A[M][N], B[N][P], C[M][P];\n    \n    // Lecture de la matrice A (2x3)\n    cout << \"Entrez les elements de la matrice A (2x3) :\" << endl;\n    for(int i = 0; i < M; i++) {\n        for(int j = 0; j < N; j++) {\n            cout << \"A[\" << i << \"][\" << j << \"] : \";\n            cin >> A[i][j];\n        }\n    }\n    \n    // Lecture de la matrice B (3x2)\n    cout << \"\\nEntrez les elements de la matrice B (3x2) :\" << endl;\n    for(int i = 0; i < N; i++) {\n        for(int j = 0; j < P; j++) {\n            cout << \"B[\" << i << \"][\" << j << \"] : \";\n            cin >> B[i][j];\n        }\n    }\n    \n    // Initialisation de C à 0\n    for(int i = 0; i < M; i++) {\n        for(int j = 0; j < P; j++) {\n            C[i][j] = 0;\n        }\n    }\n    \n    // Calcul du produit matriciel C = A * B\n    for(int i = 0; i < M; i++) {\n        for(int j = 0; j < P; j++) {\n            for(int k = 0; k < N; k++) {\n                C[i][j] = C[i][j] + A[i][k] * B[k][j];\n            }\n        }\n    }\n    \n    // Affichage de A\n    cout << \"\\nMatrice A (2x3) :\" << endl;\n    for(int i = 0; i < M; i++) {\n        for(int j = 0; j < N; j++) {\n            cout << A[i][j] << \"\\t\";\n        }\n        cout << endl;\n    }\n    \n    // Affichage de B\n    cout << \"\\nMatrice B (3x2) :\" << endl;\n    for(int i = 0; i < N; i++) {\n        for(int j = 0; j < P; j++) {\n            cout << B[i][j] << \"\\t\";\n        }\n        cout << endl;\n    }\n    \n    // Affichage de C = A * B\n    cout << \"\\nMatrice C = A * B (2x2) :\" << endl;\n    for(int i = 0; i < M; i++) {\n        for(int j = 0; j < P; j++) {\n            cout << C[i][j] << \"\\t\";\n        }\n        cout << endl;\n    }\n    \n    return 0;\n}

Explication détaillée :

Variables :
- $M = 2$ : nombre de lignes de $A$
- $N = 3$ : nombre de colonnes de $A$ et lignes de $B$
- $P = 2$ : nombre de colonnes de $B$
- $A[2][3], B[3][2]$ : matrices d'entrée
- $C[2][2]$ : matrice résultat du produit

Condition de compatibilité :
Le produit $A \\times B$ est défini si et seulement si le nombre de colonnes de $A$ égale le nombre de lignes de $B$.

Si $A$ est $m \\times n$ et $B$ est $n \\times p$, alors $C = AB$ est $m \\times p$.

Formule du produit matriciel :
$C_{ij} = \\sum_{k=0}^{n-1} A_{ik} \\times B_{kj}$

Pour notre cas ($n = 3$) :
$C_{ij} = A_{i0} B_{0j} + A_{i1} B_{1j} + A_{i2} B_{2j}$

Algorithme à trois boucles imbriquées :
Pour $i = 0$ à $M-1$ :
  Pour $j = 0$ à $P-1$ :
    Initialiser $C[i][j] = 0$
    Pour $k = 0$ à $N-1$ :
      $C[i][j] = C[i][j] + A[i][k] \\times B[k][j]$

Exemple numérique :
$A = \\begin{pmatrix} 1 & 2 & 3 \\\\ 4 & 5 & 6 \\end{pmatrix}, \\quad B = \\begin{pmatrix} 7 & 8 \\\\ 9 & 10 \\\\ 11 & 12 \\end{pmatrix}$

Calcul de $C_{00}$ :
$C_{00} = A_{00} \\times B_{00} + A_{01} \\times B_{10} + A_{02} \\times B_{20}$
$C_{00} = 1 \\times 7 + 2 \\times 9 + 3 \\times 11 = 7 + 18 + 33 = 58$

Calcul de $C_{01}$ :
$C_{01} = A_{00} \\times B_{01} + A_{01} \\times B_{11} + A_{02} \\times B_{21}$
$C_{01} = 1 \\times 8 + 2 \\times 10 + 3 \\times 12 = 8 + 20 + 36 = 64$

Calcul de $C_{10}$ :
$C_{10} = A_{10} \\times B_{00} + A_{11} \\times B_{10} + A_{12} \\times B_{20}$
$C_{10} = 4 \\times 7 + 5 \\times 9 + 6 \\times 11 = 28 + 45 + 66 = 139$

Calcul de $C_{11}$ :
$C_{11} = A_{10} \\times B_{01} + A_{11} \\times B_{11} + A_{12} \\times B_{21}$
$C_{11} = 4 \\times 8 + 5 \\times 10 + 6 \\times 12 = 32 + 50 + 72 = 154$

Résultat :
$C = A \\times B = \\begin{pmatrix} 58 & 64 \\\\ 139 & 154 \\end{pmatrix}$

Complexité : $O(M \\times N \\times P)$ multiplications.",
    "id_category": "2",
    "id_number": "61"
  },
  {
    "category": "Exercices corriges en python ",
    "question": "Développer un programme Python qui lit deux listes $A$ et $B$ de même longueur $n$, puis calcule le produit scalaire $P = \\sum_{i=0}^{n-1} A[i] \\times B[i]$. Afficher le résultat étape par étape.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
# Lecture de n\nn = int(input('Longueur des listes : '))\n\n# Lecture de la liste A\nA = []\nprint('Entrez les éléments de A :')\nfor i in range(n):\n    valeur = float(input(f'A[{i}] : '))\n    A.append(valeur)\n\n# Lecture de la liste B\nB = []\nprint('Entrez les éléments de B :')\nfor i in range(n):\n    valeur = float(input(f'B[{i}] : '))\n    B.append(valeur)\n\nprint(f'Liste A : {A}')\nprint(f'Liste B : {B}')\n\n# Calcul du produit scalaire\nproduit_scalaire = 0\nprint('\\nCalcul détaillé :')\nfor i in range(n):\n    terme = A[i] * B[i]\n    produit_scalaire += terme\n    print(f'A[{i}] × B[{i}] = {A[i]} × {B[i]} = {terme}')\n\nprint(f'\\nProduit scalaire P = {produit_scalaire}')

Explication détaillée :

Étape 1 - Définition du produit scalaire :
Formule mathématique : $P = \\sum_{i=0}^{n-1} A[i] \\times B[i]$
On multiplie terme à terme et on somme.

Étape 2 - Lecture des listes :
On utilise $float()$ pour accepter des nombres décimaux.
Les listes sont indexées de $0$ à $n-1$ en Python.

Étape 3 - Calcul itératif :
Initialisation : $P = 0$
Pour chaque indice $i$ : $P = P + A[i] \\times B[i]$

Exemple avec $A = [2, 3, 5]$ et $B = [4, 1, 6]$ :
$n = 3$
Calcul détaillé :
$A[0] \\times B[0] = 2 \\times 4 = 8$
$A[1] \\times B[1] = 3 \\times 1 = 3$
$A[2] \\times B[2] = 5 \\times 6 = 30$
Produit scalaire : $P = 8 + 3 + 30 = 41$",
    "id_category": "3",
    "id_number": "1"
  },
  {
    "category": "Exercices corriges en python ",
    "question": "Créer un programme Python qui génère une matrice carrée $M$ de dimension $n \\times n$ avec des valeurs aléatoires entre $0$ et $10$. Calculer et afficher la somme de la diagonale principale $D = \\sum_{i=0}^{n-1} M[i][i]$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
import random\n\n# Lecture de la dimension\nn = int(input('Dimension de la matrice n : '))\n\n# Génération de la matrice\nM = []\nfor i in range(n):\n    ligne = []\n    for j in range(n):\n        valeur = random.randint(0, 10)\n        ligne.append(valeur)\n    M.append(ligne)\n\n# Affichage de la matrice\nprint('\\nMatrice M :')\nfor i in range(n):\n    print(M[i])\n\n# Calcul de la somme diagonale\nsomme_diag = 0\nprint('\\nÉléments de la diagonale principale :')\nfor i in range(n):\n    print(f'M[{i}][{i}] = {M[i][i]}')\n    somme_diag += M[i][i]\n\nprint(f'\\nSomme de la diagonale : D = {somme_diag}')

Explication détaillée :

Étape 1 - Structure de la matrice :
Une matrice $n \\times n$ est représentée par une liste de listes.
Élément à la position $(i, j)$ : $M[i][j]$

Étape 2 - Génération aléatoire :
Boucle externe : parcourt les $n$ lignes.
Boucle interne : génère $n$ colonnes par ligne.
$random.randint(0, 10)$ génère un entier entre $0$ et $10$ inclus.

Étape 3 - Diagonale principale :
Éléments diagonaux : $M[0][0], M[1][1], ..., M[n-1][n-1]$
Formule : $D = \\sum_{i=0}^{n-1} M[i][i]$

Exemple pour $n=3$ :
Matrice :
$M = \\begin{pmatrix} 5 & 2 & 8 \\\\ 3 & 7 & 1 \\\\ 4 & 6 & 9 \\end{pmatrix}$
Diagonale : $M[0][0]=5, M[1][1]=7, M[2][2]=9$
Somme : $D = 5 + 7 + 9 = 21$",
    "id_category": "3",
    "id_number": "2"
  },
  {
    "category": "Exercices corriges en python ",
    "question": "Écrire un programme Python qui lit une liste de $n$ nombres et calcule la variance $\\sigma^2 = \\frac{1}{n}\\sum_{i=0}^{n-1}(x_i - \\mu)^2$ et l'écart-type $\\sigma = \\sqrt{\\sigma^2}$, où $\\mu$ est la moyenne.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
import math\n\n# Lecture de n\nn = int(input('Nombre d éléments : '))\n\n# Lecture de la liste\nliste = []\nprint('Entrez les valeurs :')\nfor i in range(n):\n    valeur = float(input(f'x[{i}] : '))\n    liste.append(valeur)\n\nprint(f'\\nListe : {liste}')\n\n# Calcul de la moyenne\nsomme = 0\nfor x in liste:\n    somme += x\nmoyenne = somme / n\nprint(f'Moyenne μ = {moyenne:.4f}')\n\n# Calcul de la variance\nsomme_carres = 0\nprint('\\nCalcul des écarts au carré :')\nfor i in range(n):\n    ecart = liste[i] - moyenne\n    carre_ecart = ecart ** 2\n    print(f'(x[{i}] - μ)² = ({liste[i]} - {moyenne:.4f})² = {carre_ecart:.4f}')\n    somme_carres += carre_ecart\n\nvariance = somme_carres / n\necart_type = math.sqrt(variance)\n\nprint(f'\\nVariance σ² = {variance:.4f}')\nprint(f'Écart-type σ = {ecart_type:.4f}')

Explication détaillée :

Étape 1 - Calcul de la moyenne :
Formule : $\\mu = \\frac{1}{n}\\sum_{i=0}^{n-1} x_i$
On additionne tous les éléments et on divise par $n$.

Étape 2 - Calcul de la variance :
Formule : $\\sigma^2 = \\frac{1}{n}\\sum_{i=0}^{n-1}(x_i - \\mu)^2$
Pour chaque élément :
- Calculer l'écart : $e_i = x_i - \\mu$
- Élever au carré : $e_i^2$
- Sommer tous les carrés
- Diviser par $n$

Étape 3 - Calcul de l'écart-type :
Formule : $\\sigma = \\sqrt{\\sigma^2}$
On utilise $math.sqrt()$ pour la racine carrée.

Exemple avec liste $[4, 8, 6, 5, 7]$ :
$n = 5$
Moyenne : $\\mu = \\frac{4+8+6+5+7}{5} = \\frac{30}{5} = 6.0$
Écarts au carré : $(4-6)^2=4, (8-6)^2=4, (6-6)^2=0, (5-6)^2=1, (7-6)^2=1$
Variance : $\\sigma^2 = \\frac{4+4+0+1+1}{5} = \\frac{10}{5} = 2.0$
Écart-type : $\\sigma = \\sqrt{2.0} = 1.4142$",
    "id_category": "3",
    "id_number": "3"
  },
  {
    "category": "Exercices corriges en python ",
    "question": "Développer un programme Python qui lit une matrice $M$ de dimension $m \\times n$ et calcule sa transposée $M^T$ de dimension $n \\times m$ telle que $M^T[j][i] = M[i][j]$. Afficher les deux matrices.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
# Lecture des dimensions\nm = int(input('Nombre de lignes m : '))\nn = int(input('Nombre de colonnes n : '))\n\n# Lecture de la matrice M\nM = []\nprint('\\nEntrez les éléments de la matrice :')\nfor i in range(m):\n    ligne = []\n    for j in range(n):\n        valeur = float(input(f'M[{i}][{j}] : '))\n        ligne.append(valeur)\n    M.append(ligne)\n\n# Affichage de M\nprint('\\nMatrice M originale :')\nfor i in range(m):\n    print(M[i])\n\n# Calcul de la transposée\nMT = []\nfor j in range(n):\n    ligne_T = []\n    for i in range(m):\n        ligne_T.append(M[i][j])\n    MT.append(ligne_T)\n\n# Affichage de MT\nprint('\\nMatrice transposée MT :')\nfor j in range(n):\n    print(MT[j])

Explication détaillée :

Étape 1 - Définition de la transposée :
Pour une matrice $M$ de dimension $m \\times n$ :
La transposée $M^T$ a pour dimension $n \\times m$
Relation : $M^T[j][i] = M[i][j]$
Les lignes deviennent des colonnes et vice-versa.

Étape 2 - Lecture de la matrice :
Boucle externe : parcourt $m$ lignes.
Boucle interne : lit $n$ colonnes.

Étape 3 - Construction de $M^T$ :
Boucle externe : parcourt $n$ lignes (colonnes de $M$).
Boucle interne : parcourt $m$ colonnes (lignes de $M$).
Affectation : $M^T[j][i] = M[i][j]$

Exemple pour $m=2, n=3$ :
Matrice originale :
$M = \\begin{pmatrix} 1 & 2 & 3 \\\\ 4 & 5 & 6 \\end{pmatrix}$
Dimension : $2 \\times 3$
Transposée :
$M^T = \\begin{pmatrix} 1 & 4 \\\\ 2 & 5 \\\\ 3 & 6 \\end{pmatrix}$
Dimension : $3 \\times 2$
Vérification : $M^T[0][1] = M[1][0] = 4$",
    "id_category": "3",
    "id_number": "4"
  },
  {
    "category": "Exercices corriges en python ",
    "question": "Créer un programme Python qui lit deux matrices $A$ et $B$ de dimension $n \\times n$, puis calcule leur somme $C = A + B$ où $C[i][j] = A[i][j] + B[i][j]$ pour tout $i, j$. Afficher les trois matrices.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
# Lecture de la dimension\nn = int(input('Dimension des matrices n : '))\n\n# Lecture de la matrice A\nA = []\nprint('\\nEntrez les éléments de la matrice A :')\nfor i in range(n):\n    ligne = []\n    for j in range(n):\n        valeur = float(input(f'A[{i}][{j}] : '))\n        ligne.append(valeur)\n    A.append(ligne)\n\n# Lecture de la matrice B\nB = []\nprint('\\nEntrez les éléments de la matrice B :')\nfor i in range(n):\n    ligne = []\n    for j in range(n):\n        valeur = float(input(f'B[{i}][{j}] : '))\n        ligne.append(valeur)\n    B.append(ligne)\n\n# Calcul de C = A + B\nC = []\nfor i in range(n):\n    ligne = []\n    for j in range(n):\n        somme = A[i][j] + B[i][j]\n        ligne.append(somme)\n    C.append(ligne)\n\n# Affichage des matrices\nprint('\\nMatrice A :')\nfor i in range(n):\n    print(A[i])\n\nprint('\\nMatrice B :')\nfor i in range(n):\n    print(B[i])\n\nprint('\\nMatrice C = A + B :')\nfor i in range(n):\n    print(C[i])

Explication détaillée :

Étape 1 - Addition matricielle :
Pour deux matrices de même dimension $n \\times n$ :
Formule : $C[i][j] = A[i][j] + B[i][j]$
On additionne élément par élément (addition terme à terme).

Étape 2 - Lecture des matrices :
On lit $n^2$ éléments pour chaque matrice.
Structure : liste de $n$ listes de $n$ éléments.

Étape 3 - Calcul de la somme :
Double boucle imbriquée :
- Boucle externe : parcourt les lignes ($i$ de $0$ à $n-1$).
- Boucle interne : parcourt les colonnes ($j$ de $0$ à $n-1$).
Pour chaque position $(i,j)$ : $C[i][j] = A[i][j] + B[i][j]$

Exemple pour $n=2$ :
$A = \\begin{pmatrix} 1 & 2 \\\\ 3 & 4 \\end{pmatrix}, \\quad B = \\begin{pmatrix} 5 & 6 \\\\ 7 & 8 \\end{pmatrix}$
Calcul élément par élément :
$C[0][0] = A[0][0] + B[0][0] = 1 + 5 = 6$
$C[0][1] = A[0][1] + B[0][1] = 2 + 6 = 8$
$C[1][0] = A[1][0] + B[1][0] = 3 + 7 = 10$
$C[1][1] = A[1][1] + B[1][1] = 4 + 8 = 12$
Résultat :
$C = \\begin{pmatrix} 6 & 8 \\\\ 10 & 12 \\end{pmatrix}$",
    "id_category": "3",
    "id_number": "5"
  },
  {
    "category": "Exercices corriges en python ",
    "question": "Écrire un programme Python qui lit une liste de $n$ nombres entiers et trouve le deuxième plus grand élément. Afficher cet élément et sa position dans la liste.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
# Lecture de n\nn = int(input('Nombre d éléments (n >= 2) : '))\n\nif n < 2:\n    print('Erreur : il faut au moins 2 éléments')\nelse:\n    # Lecture de la liste\n    liste = []\n    print('Entrez les entiers :')\n    for i in range(n):\n        valeur = int(input(f'Élément {i} : '))\n        liste.append(valeur)\n    \n    print(f'\\nListe : {liste}')\n    \n    # Recherche du maximum\n    max1 = liste[0]\n    position_max1 = 0\n    for i in range(1, n):\n        if liste[i] > max1:\n            max1 = liste[i]\n            position_max1 = i\n    \n    # Recherche du deuxième maximum\n    max2 = None\n    position_max2 = -1\n    for i in range(n):\n        if liste[i] < max1:\n            if max2 is None or liste[i] > max2:\n                max2 = liste[i]\n                position_max2 = i\n    \n    if max2 is None:\n        print('Tous les éléments sont identiques')\n    else:\n        print(f'\\nPremier maximum : {max1} à la position {position_max1}')\n        print(f'Deuxième maximum : {max2} à la position {position_max2}')

Explication détaillée :

Étape 1 - Validation :
Condition : $n \\geq 2$ pour avoir au moins deux valeurs.

Étape 2 - Recherche du premier maximum :
Initialisation : $max1 = liste[0]$
Parcours : pour chaque $i$ de $1$ à $n-1$
Si $liste[i] > max1$, alors $max1 = liste[i]$

Étape 3 - Recherche du deuxième maximum :
Condition : $liste[i] < max1$ (exclure le maximum)
Parmi les éléments restants, trouver le plus grand.
Si $max2$ est $None$ ou $liste[i] > max2$, mettre à jour $max2$.

Étape 4 - Cas particulier :
Si tous les éléments sont égaux, $max2$ reste $None$.

Exemple avec liste $[15, 8, 23, 19, 12]$ :
$n = 5$
Premier maximum : $max1 = 23$ à la position $2$
Éléments restants : $[15, 8, 19, 12]$
Deuxième maximum : $max2 = 19$ à la position $3$",
    "id_category": "3",
    "id_number": "6"
  },
  {
    "category": "Exercices corriges en python ",
    "question": "Développer un programme Python qui lit un tableau de $n$ entiers et le trie par 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 :

Code Python :
# Lecture de n\nn = int(input('Nombre d éléments : '))\n\n# Lecture du tableau\ntableau = []\nprint('Entrez les entiers :')\nfor i in range(n):\n    valeur = int(input(f'Élément {i} : '))\n    tableau.append(valeur)\n\nprint(f'\\nTableau avant tri : {tableau}')\n\n# Tri par sélection\nfor i in range(n-1):\n    # Recherche du minimum dans tableau[i:n]\n    indice_min = i\n    for j in range(i+1, n):\n        if tableau[j] < tableau[indice_min]:\n            indice_min = j\n    \n    # Échange si nécessaire\n    if indice_min != i:\n        temp = tableau[i]\n        tableau[i] = tableau[indice_min]\n        tableau[indice_min] = temp\n        print(f'Étape {i+1} : Échange {tableau[indice_min]} et {temp} -> {tableau}')\n    else:\n        print(f'Étape {i+1} : Pas d échange -> {tableau}')\n\nprint(f'\\nTableau après tri : {tableau}')

Explication détaillée :

Étape 1 - Principe du tri par sélection :
Pour chaque position $i$ de $0$ à $n-2$ :
1. Trouver le minimum dans $tableau[i:n]$
2. Échanger ce minimum avec $tableau[i]$

Étape 2 - Recherche du minimum :
Initialisation : $indice\\_min = i$
Parcours de $j = i+1$ à $n-1$
Si $tableau[j] < tableau[indice\\_min]$, mettre à jour $indice\\_min = j$

Étape 3 - Échange :
Si $indice\\_min \\neq i$, échanger :
$temp = tableau[i]$
$tableau[i] = tableau[indice\\_min]$
$tableau[indice\\_min] = temp$

Étape 4 - Complexité :
Nombre de comparaisons : $\\frac{n(n-1)}{2}$
Complexité : $O(n^2)$

Exemple avec tableau $[64, 25, 12, 22, 11]$ :
Étape 1 : Minimum dans $[64,25,12,22,11]$ est $11$. Échange $64 \\leftrightarrow 11$ : $[11,25,12,22,64]$
Étape 2 : Minimum dans $[25,12,22,64]$ est $12$. Échange $25 \\leftrightarrow 12$ : $[11,12,25,22,64]$
Étape 3 : Minimum dans $[25,22,64]$ est $22$. Échange $25 \\leftrightarrow 22$ : $[11,12,22,25,64]$
Étape 4 : Minimum dans $[25,64]$ est $25$. Pas d'échange : $[11,12,22,25,64]$
Résultat final : $[11,12,22,25,64]$",
    "id_category": "3",
    "id_number": "7"
  },
  {
    "category": "Exercices corriges en python ",
    "question": "Écrire un programme Python qui calcule la factorielle $n! = n \\times (n-1) \\times (n-2) \\times ... \\times 2 \\times 1$ d'un entier $n$ de deux manières : avec une boucle et avec une fonction récursive.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
# Méthode 1 : Avec boucle\ndef factorielle_boucle(n):\n    if n < 0:\n        return None\n    if n == 0 or n == 1:\n        return 1\n    \n    resultat = 1\n    for i in range(2, n+1):\n        resultat *= i\n    return resultat\n\n# Méthode 2 : Récursive\ndef factorielle_recursive(n):\n    if n < 0:\n        return None\n    if n == 0 or n == 1:\n        return 1\n    return n * factorielle_recursive(n-1)\n\n# Programme principal\nn = int(input('Entrez un entier n : '))\n\nif n < 0:\n    print('Erreur : n doit être >= 0')\nelse:\n    # Calcul avec boucle\n    fact_boucle = factorielle_boucle(n)\n    print(f'\\nFactorielle par boucle : {n}! = {fact_boucle}')\n    \n    # Calcul récursif\n    fact_rec = factorielle_recursive(n)\n    print(f'Factorielle récursive : {n}! = {fact_rec}')\n    \n    # Affichage détaillé\n    if n <= 10:\n        chaine = ' × '.join(str(i) for i in range(n, 0, -1))\n        print(f'\\nDétail : {n}! = {chaine} = {fact_boucle}')

Explication détaillée :

Étape 1 - Définition mathématique :
Formule : $n! = n \\times (n-1) \\times (n-2) \\times ... \\times 2 \\times 1$
Cas particuliers : $0! = 1$ et $1! = 1$

Étape 2 - Méthode itérative (boucle) :
Initialisation : $resultat = 1$
Boucle de $i=2$ à $n$ : $resultat = resultat \\times i$
Complexité : $O(n)$

Étape 3 - Méthode récursive :
Cas de base : Si $n = 0$ ou $n = 1$, retourner $1$
Cas récursif : $n! = n \\times (n-1)!$
Appel récursif jusqu'au cas de base.

Étape 4 - Validation :
Condition : $n \\geq 0$

Exemple pour $n = 5$ :
Méthode boucle :
$resultat = 1$
$i=2: resultat = 1 \\times 2 = 2$
$i=3: resultat = 2 \\times 3 = 6$
$i=4: resultat = 6 \\times 4 = 24$
$i=5: resultat = 24 \\times 5 = 120$
Méthode récursive :
$5! = 5 \\times 4!$
$4! = 4 \\times 3!$
$3! = 3 \\times 2!$
$2! = 2 \\times 1!$
$1! = 1$
Remontée : $2! = 2 \\times 1 = 2$, $3! = 3 \\times 2 = 6$, $4! = 4 \\times 6 = 24$, $5! = 5 \\times 24 = 120$",
    "id_category": "3",
    "id_number": "8"
  },
  {
    "category": "Exercices corriges en python ",
    "question": "Créer un programme Python qui lit une matrice $M$ de dimension $n \\times n$ et vérifie si elle est symétrique, c'est-à-dire si $M[i][j] = M[j][i]$ pour tout $i, j$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
# Lecture de la dimension\nn = int(input('Dimension de la matrice n : '))\n\n# Lecture de la matrice\nM = []\nprint('\\nEntrez les éléments de la matrice :')\nfor i in range(n):\n    ligne = []\n    for j in range(n):\n        valeur = float(input(f'M[{i}][{j}] : '))\n        ligne.append(valeur)\n    M.append(ligne)\n\n# Affichage de la matrice\nprint('\\nMatrice M :')\nfor i in range(n):\n    print(M[i])\n\n# Vérification de la symétrie\nest_symetrique = True\nprint('\\nVérification de la symétrie :')\nfor i in range(n):\n    for j in range(i+1, n):\n        print(f'M[{i}][{j}] = {M[i][j]}, M[{j}][{i}] = {M[j][i]}', end='')\n        if M[i][j] != M[j][i]:\n            print(' -> Différents')\n            est_symetrique = False\n        else:\n            print(' -> Égaux')\n\nif est_symetrique:\n    print('\\nLa matrice est SYMÉTRIQUE')\nelse:\n    print('\\nLa matrice n est PAS symétrique')

Explication détaillée :

Étape 1 - Définition de symétrie :
Une matrice $M$ de dimension $n \\times n$ est symétrique si :
$M[i][j] = M[j][i]$ pour tout $i, j \\in \\{0, 1, ..., n-1\\}$
Équivalence : $M = M^T$ (la matrice égale sa transposée)

Étape 2 - Optimisation de la vérification :
Il suffit de vérifier la moitié supérieure de la matrice.
Boucle externe : $i$ de $0$ à $n-1$
Boucle interne : $j$ de $i+1$ à $n-1$
Comparer $M[i][j]$ avec $M[j][i]$

Étape 3 - Test de condition :
Variable booléenne : $est\\_symetrique = True$
Dès qu'on trouve $M[i][j] \\neq M[j][i]$, on met $est\\_symetrique = False$

Exemple 1 - Matrice symétrique pour $n=3$ :
$M = \\begin{pmatrix} 1 & 2 & 3 \\\\ 2 & 4 & 5 \\\\ 3 & 5 & 6 \\end{pmatrix}$
Vérifications :
$M[0][1]=2, M[1][0]=2$ ✓
$M[0][2]=3, M[2][0]=3$ ✓
$M[1][2]=5, M[2][1]=5$ ✓
Conclusion : Matrice SYMÉTRIQUE

Exemple 2 - Matrice non symétrique :
$M = \\begin{pmatrix} 1 & 2 & 3 \\\\ 4 & 5 & 6 \\\\ 7 & 8 & 9 \\end{pmatrix}$
$M[0][1]=2, M[1][0]=4$ ✗
Conclusion : Matrice NON symétrique",
    "id_category": "3",
    "id_number": "9"
  },
  {
    "category": "Exercices corriges en python ",
    "question": "Écrire un programme Python qui lit un tableau de $n$ entiers et inverse l'ordre des éléments sans utiliser de tableau auxiliaire. Afficher le tableau avant et après l'inversion.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
# Lecture de n\nn = int(input('Nombre d éléments : '))\n\n# Lecture du tableau\ntableau = []\nprint('Entrez les entiers :')\nfor i in range(n):\n    valeur = int(input(f'Élément {i} : '))\n    tableau.append(valeur)\n\nprint(f'\\nTableau avant inversion : {tableau}')\n\n# Inversion du tableau\nprint('\\nÉtapes de l inversion :')\nfor i in range(n // 2):\n    # Calcul de l'indice opposé\n    j = n - 1 - i\n    \n    # Affichage de l'échange\n    print(f'Échange tableau[{i}] = {tableau[i]} avec tableau[{j}] = {tableau[j]}')\n    \n    # Échange des éléments\n    temp = tableau[i]\n    tableau[i] = tableau[j]\n    tableau[j] = temp\n    \n    print(f'Résultat : {tableau}')\n\nprint(f'\\nTableau après inversion : {tableau}')

Explication détaillée :

Étape 1 - Principe de l'inversion :
Échanger les éléments symétriques par rapport au centre.
Élément $i$ ↔ Élément $n-1-i$
Nombre d'échanges : $\\lfloor \\frac{n}{2} \\rfloor$

Étape 2 - Algorithme d'échange :
Boucle de $i=0$ à $\\lfloor \\frac{n}{2} \\rfloor - 1$
Pour chaque $i$ :
- Calculer $j = n - 1 - i$
- Échanger $tableau[i]$ et $tableau[j]$ avec variable temporaire

Étape 3 - Échange avec variable temporaire :
$temp = tableau[i]$
$tableau[i] = tableau[j]$
$tableau[j] = temp$
La variable $temp$ sauvegarde la valeur avant écrasement.

Étape 4 - Complexité :
Temps : $O(n)$
Espace : $O(1)$ (pas de tableau auxiliaire)

Exemple pour $n=5$ avec tableau $[10, 20, 30, 40, 50]$ :
Nombre d'échanges : $\\lfloor \\frac{5}{2} \\rfloor = 2$
Échange 1 : $i=0, j=4$
Avant : $[10, 20, 30, 40, 50]$
Échange $10 \\leftrightarrow 50$
Après : $[50, 20, 30, 40, 10]$
Échange 2 : $i=1, j=3$
Avant : $[50, 20, 30, 40, 10]$
Échange $20 \\leftrightarrow 40$
Après : $[50, 40, 30, 20, 10]$
L'élément central $30$ reste en place.
Résultat final : $[50, 40, 30, 20, 10]$",
    "id_category": "3",
    "id_number": "10"
  },
  {
    "category": "Exercices corriges en python ",
    "question": "Développer un programme Python qui lit deux listes $A$ et $B$ de longueurs quelconques et crée une liste $C$ contenant tous les éléments communs aux deux listes (intersection). Afficher les trois listes.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
# Lecture de la liste A\nn_a = int(input('Nombre d éléments dans A : '))\nA = []\nprint('Entrez les éléments de A :')\nfor i in range(n_a):\n    valeur = int(input(f'A[{i}] : '))\n    A.append(valeur)\n\n# Lecture de la liste B\nn_b = int(input('\\nNombre d éléments dans B : '))\nB = []\nprint('Entrez les éléments de B :')\nfor i in range(n_b):\n    valeur = int(input(f'B[{i}] : '))\n    B.append(valeur)\n\nprint(f'\\nListe A : {A}')\nprint(f'Liste B : {B}')\n\n# Calcul de l'intersection\nC = []\nfor element in A:\n    if element in B and element not in C:\n        C.append(element)\n        print(f'Élément commun trouvé : {element}')\n\nprint(f'\\nIntersection C = A ∩ B : {C}')\n\nif len(C) == 0:\n    print('Les listes n ont aucun élément commun')

Explication détaillée :

Étape 1 - Définition de l'intersection :
Intersection $C = A \\cap B$ : ensemble des éléments présents dans $A$ ET dans $B$.
Condition : $x \\in C \\Leftrightarrow (x \\in A) \\land (x \\in B)$

Étape 2 - Algorithme de recherche :
Parcourir chaque élément de $A$
Pour chaque $element$ dans $A$ :
- Vérifier si $element$ est dans $B$
- Vérifier si $element$ n'est pas déjà dans $C$ (éviter les doublons)
- Si les deux conditions sont vraies, ajouter à $C$

Étape 3 - Test d'appartenance :
L'opérateur $in$ en Python teste l'appartenance.
$element in B$ retourne $True$ si $element$ est dans $B$
$element not in C$ retourne $True$ si $element$ n'est pas dans $C$

Étape 4 - Complexité :
Temps : $O(n_a \\times n_b)$ pour les listes
Peut être optimisé avec des ensembles (sets).

Exemple avec $A=[5,2,8,3,9]$ et $B=[3,7,2,6]$ :
Parcours de $A$ :
$5 \\in B$ ? Non, on ne l'ajoute pas
$2 \\in B$ ? Oui → Ajouter $2$ à $C$ : $C=[2]$
$8 \\in B$ ? Non
$3 \\in B$ ? Oui → Ajouter $3$ à $C$ : $C=[2,3]$
$9 \\in B$ ? Non
Résultat : $C = [2, 3]$",
    "id_category": "3",
    "id_number": "11"
  },
  {
    "category": "Exercices corriges en python ",
    "question": "Écrire un programme Python qui calcule la somme des chiffres d'un entier positif $n$. Par exemple, pour $n=1234$, la somme est $1+2+3+4=10$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
# Lecture de l'entier\nn = int(input('Entrez un entier positif : '))\n\nif n < 0:\n    print('Erreur : l entier doit être positif')\nelse:\n    # Sauvegarde de la valeur originale\n    n_original = n\n    \n    # Calcul de la somme des chiffres\n    somme = 0\n    print('\\nExtraction des chiffres :')\n    while n > 0:\n        chiffre = n % 10\n        print(f'Chiffre extrait : {chiffre}')\n        somme += chiffre\n        n = n // 10\n    \n    print(f'\\nSomme des chiffres de {n_original} : {somme}')

Explication détaillée :

Étape 1 - Principe d'extraction :
Pour extraire les chiffres d'un nombre :
- Dernier chiffre : $chiffre = n \\bmod 10$
- Supprimer le dernier chiffre : $n = \\lfloor \\frac{n}{10} \\rfloor$
Répéter jusqu'à ce que $n = 0$

Étape 2 - Opérateurs Python :
$\\%$ : reste de la division (modulo)
$//$ : division entière (quotient)
Exemple : $1234 \\bmod 10 = 4$, $\\lfloor \\frac{1234}{10} \\rfloor = 123$

Étape 3 - Algorithme itératif :
Initialisation : $somme = 0$
Tant que $n > 0$ :
1. Extraire : $chiffre = n \\bmod 10$
2. Additionner : $somme = somme + chiffre$
3. Réduire : $n = \\lfloor \\frac{n}{10} \\rfloor$

Exemple détaillé pour $n = 1234$ :
Itération 1 :
$n = 1234$
$chiffre = 1234 \\bmod 10 = 4$
$somme = 0 + 4 = 4$
$n = \\lfloor \\frac{1234}{10} \\rfloor = 123$
Itération 2 :
$n = 123$
$chiffre = 123 \\bmod 10 = 3$
$somme = 4 + 3 = 7$
$n = \\lfloor \\frac{123}{10} \\rfloor = 12$
Itération 3 :
$n = 12$
$chiffre = 12 \\bmod 10 = 2$
$somme = 7 + 2 = 9$
$n = \\lfloor \\frac{12}{10} \\rfloor = 1$
Itération 4 :
$n = 1$
$chiffre = 1 \\bmod 10 = 1$
$somme = 9 + 1 = 10$
$n = \\lfloor \\frac{1}{10} \\rfloor = 0$
Boucle terminée.
Résultat final : $somme = 10$",
    "id_category": "3",
    "id_number": "12"
  },
  {
    "category": "Exercices corriges en python ",
    "question": "Créer un programme Python qui lit une matrice $M$ de dimension $m \\times n$ et calcule la somme de chaque ligne. Stocker les résultats dans une liste $S$ et afficher cette liste.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
# Lecture des dimensions\nm = int(input('Nombre de lignes m : '))\nn = int(input('Nombre de colonnes n : '))\n\n# Lecture de la matrice\nM = []\nprint('\\nEntrez les éléments de la matrice :')\nfor i in range(m):\n    ligne = []\n    for j in range(n):\n        valeur = float(input(f'M[{i}][{j}] : '))\n        ligne.append(valeur)\n    M.append(ligne)\n\n# Affichage de la matrice\nprint('\\nMatrice M :')\nfor i in range(m):\n    print(M[i])\n\n# Calcul des sommes par ligne\nS = []\nprint('\\nCalcul des sommes par ligne :')\nfor i in range(m):\n    somme_ligne = 0\n    for j in range(n):\n        somme_ligne += M[i][j]\n    S.append(somme_ligne)\n    print(f'Ligne {i} : somme = {somme_ligne}')\n\nprint(f'\\nListe des sommes S : {S}')

Explication détaillée :

Étape 1 - Structure de la matrice :
Matrice $M$ de dimension $m \\times n$ : $m$ lignes et $n$ colonnes.
Ligne $i$ : $M[i][0], M[i][1], ..., M[i][n-1]$

Étape 2 - Formule de la somme d'une ligne :
Pour la ligne $i$ :
$S[i] = \\sum_{j=0}^{n-1} M[i][j]$
On additionne tous les éléments de la ligne $i$.

Étape 3 - Algorithme de calcul :
Pour chaque ligne $i$ de $0$ à $m-1$ :
1. Initialiser $somme\\_ligne = 0$
2. Pour chaque colonne $j$ de $0$ à $n-1$ : $somme\\_ligne = somme\\_ligne + M[i][j]$
3. Ajouter $somme\\_ligne$ à la liste $S$

Étape 4 - Résultat :
La liste $S$ contient $m$ éléments.
$S[i]$ représente la somme de la ligne $i$.

Exemple pour $m=3, n=4$ :
Matrice :
$M = \\begin{pmatrix} 1 & 2 & 3 & 4 \\\\ 5 & 6 & 7 & 8 \\\\ 9 & 10 & 11 & 12 \\end{pmatrix}$
Calcul des sommes :
Ligne 0 : $S[0] = 1 + 2 + 3 + 4 = 10$
Ligne 1 : $S[1] = 5 + 6 + 7 + 8 = 26$
Ligne 2 : $S[2] = 9 + 10 + 11 + 12 = 42$
Résultat : $S = [10, 26, 42]$",
    "id_category": "3",
    "id_number": "13"
  },
  {
    "category": "Exercices corriges en python ",
    "question": "Écrire un programme Python qui génère les $n$ premiers termes de la suite de Fibonacci définie par $F_0=0$, $F_1=1$, et $F_k = F_{k-1} + F_{k-2}$ pour $k \\geq 2$. Stocker les termes dans une liste et les afficher.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
# Lecture de n\nn = int(input('Nombre de termes de Fibonacci : '))\n\nif n <= 0:\n    print('Erreur : n doit être > 0')\nelif n == 1:\n    fibonacci = [0]\n    print(f'Suite de Fibonacci : {fibonacci}')\nelse:\n    # Initialisation\n    fibonacci = [0, 1]\n    \n    # Génération des termes suivants\n    print('\\nGénération des termes :')\n    print(f'F[0] = {fibonacci[0]}')\n    print(f'F[1] = {fibonacci[1]}')\n    \n    for k in range(2, n):\n        terme = fibonacci[k-1] + fibonacci[k-2]\n        fibonacci.append(terme)\n        print(f'F[{k}] = F[{k-1}] + F[{k-2}] = {fibonacci[k-1]} + {fibonacci[k-2]} = {terme}')\n    \n    print(f'\\nSuite de Fibonacci ({n} termes) : {fibonacci}')

Explication détaillée :

Étape 1 - Définition de la suite :
Conditions initiales :
$F_0 = 0$
$F_1 = 1$
Relation de récurrence pour $k \\geq 2$ :
$F_k = F_{k-1} + F_{k-2}$

Étape 2 - Initialisation de la liste :
Créer une liste avec les deux premiers termes : $fibonacci = [0, 1]$

Étape 3 - Génération itérative :
Pour $k$ de $2$ à $n-1$ :
1. Calculer : $terme = fibonacci[k-1] + fibonacci[k-2]$
2. Ajouter à la liste : $fibonacci.append(terme)$

Étape 4 - Cas particuliers :
Si $n=1$ : liste $=[0]$
Si $n=2$ : liste $=[0, 1]$

Exemple pour $n=10$ :
$F_0 = 0$
$F_1 = 1$
$F_2 = F_1 + F_0 = 1 + 0 = 1$
$F_3 = F_2 + F_1 = 1 + 1 = 2$
$F_4 = F_3 + F_2 = 2 + 1 = 3$
$F_5 = F_4 + F_3 = 3 + 2 = 5$
$F_6 = F_5 + F_4 = 5 + 3 = 8$
$F_7 = F_6 + F_5 = 8 + 5 = 13$
$F_8 = F_7 + F_6 = 13 + 8 = 21$
$F_9 = F_8 + F_7 = 21 + 13 = 34$
Suite complète : $[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]$",
    "id_category": "3",
    "id_number": "14"
  },
  {
    "category": "Exercices corriges en python ",
    "question": "Développer un programme Python qui lit une matrice $M$ de dimension $n \\times n$ et calcule la trace $Tr(M) = \\sum_{i=0}^{n-1} M[i][i]$, puis vérifie si la matrice est diagonale (tous les éléments hors diagonale sont nuls).",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
# Lecture de la dimension\nn = int(input('Dimension de la matrice n : '))\n\n# Lecture de la matrice\nM = []\nprint('\\nEntrez les éléments de la matrice :')\nfor i in range(n):\n    ligne = []\n    for j in range(n):\n        valeur = float(input(f'M[{i}][{j}] : '))\n        ligne.append(valeur)\n    M.append(ligne)\n\n# Affichage de la matrice\nprint('\\nMatrice M :')\nfor i in range(n):\n    print(M[i])\n\n# Calcul de la trace\ntrace = 0\nprint('\\nÉléments diagonaux :')\nfor i in range(n):\n    print(f'M[{i}][{i}] = {M[i][i]}')\n    trace += M[i][i]\n\nprint(f'\\nTrace Tr(M) = {trace}')\n\n# Vérification si matrice diagonale\nest_diagonale = True\nprint('\\nVérification des éléments hors diagonale :')\nfor i in range(n):\n    for j in range(n):\n        if i != j and M[i][j] != 0:\n            print(f'M[{i}][{j}] = {M[i][j]} ≠ 0')\n            est_diagonale = False\n\nif est_diagonale:\n    print('\\nLa matrice est DIAGONALE')\nelse:\n    print('\\nLa matrice n est PAS diagonale')

Explication détaillée :

Étape 1 - Définition de la trace :
La trace d'une matrice carrée est la somme des éléments diagonaux :
$Tr(M) = \\sum_{i=0}^{n-1} M[i][i]$
On additionne $M[0][0] + M[1][1] + ... + M[n-1][n-1]$

Étape 2 - Calcul de la trace :
Initialisation : $trace = 0$
Boucle de $i=0$ à $n-1$ : $trace = trace + M[i][i]$

Étape 3 - Définition de matrice diagonale :
Une matrice est diagonale si tous les éléments hors diagonale sont nuls :
$M[i][j] = 0$ pour tout $i \\neq j$

Étape 4 - Vérification :
Parcourir tous les éléments $M[i][j]$
Si $i \\neq j$ et $M[i][j] \\neq 0$, alors la matrice n'est pas diagonale.

Exemple 1 - Matrice diagonale pour $n=3$ :
$M = \\begin{pmatrix} 5 & 0 & 0 \\\\ 0 & 3 & 0 \\\\ 0 & 0 & 7 \\end{pmatrix}$
Trace : $Tr(M) = 5 + 3 + 7 = 15$
Éléments hors diagonale : tous égaux à $0$
Conclusion : Matrice DIAGONALE

Exemple 2 - Matrice non diagonale :
$M = \\begin{pmatrix} 2 & 1 & 0 \\\\ 0 & 4 & 0 \\\\ 0 & 0 & 6 \\end{pmatrix}$
Trace : $Tr(M) = 2 + 4 + 6 = 12$
Élément $M[0][1] = 1 \\neq 0$
Conclusion : Matrice NON diagonale",
    "id_category": "3",
    "id_number": "15"
  },
  {
    "category": "Exercices corriges en python ",
    "question": "Écrire un programme Python qui lit une liste de $n$ entiers et détermine si elle est triée par ordre croissant, c'est-à-dire si $liste[i] \\leq liste[i+1]$ pour tout $i$ de $0$ à $n-2$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
# Lecture de n\nn = int(input('Nombre d éléments : '))\n\nif n <= 1:\n    print('Une liste de 0 ou 1 élément est toujours triée')\nelse:\n    # Lecture de la liste\n    liste = []\n    print('Entrez les entiers :')\n    for i in range(n):\n        valeur = int(input(f'Élément {i} : '))\n        liste.append(valeur)\n    \n    print(f'\\nListe : {liste}')\n    \n    # Vérification du tri\n    est_triee = True\n    print('\\nVérification de l ordre croissant :')\n    for i in range(n-1):\n        print(f'Comparaison : liste[{i}] = {liste[i]} et liste[{i+1}] = {liste[i+1]}', end='')\n        if liste[i] > liste[i+1]:\n            print(' -> Ordre décroissant détecté')\n            est_triee = False\n            break\n        else:\n            print(' -> OK')\n    \n    if est_triee:\n        print('\\nLa liste est TRIÉE par ordre croissant')\n    else:\n        print('\\nLa liste n est PAS triée par ordre croissant')

Explication détaillée :

Étape 1 - Définition de tri croissant :
Une liste est triée par ordre croissant si :
$liste[i] \\leq liste[i+1]$ pour tout $i \\in \\{0, 1, ..., n-2\\}$
Chaque élément est inférieur ou égal au suivant.

Étape 2 - Algorithme de vérification :
Parcourir les paires d'éléments consécutifs.
Pour $i$ de $0$ à $n-2$ :
Comparer $liste[i]$ et $liste[i+1]$
Si $liste[i] > liste[i+1]$, la liste n'est pas triée.

Étape 3 - Optimisation :
Dès qu'on trouve une paire désordonnée, on peut arrêter avec $break$.
Variable booléenne : $est\\_triee$ initialisée à $True$.

Étape 4 - Cas particuliers :
Liste vide ou à un élément : toujours triée.
Égalités acceptées : $liste[i] = liste[i+1]$ est valide.

Exemple 1 - Liste triée $[2, 5, 5, 8, 12]$ :
$n = 5$
Vérifications :
$liste[0]=2 \\leq liste[1]=5$ ✓
$liste[1]=5 \\leq liste[2]=5$ ✓ (égalité acceptée)
$liste[2]=5 \\leq liste[3]=8$ ✓
$liste[3]=8 \\leq liste[4]=12$ ✓
Conclusion : Liste TRIÉE

Exemple 2 - Liste non triée $[3, 7, 5, 9]$ :
$n = 4$
Vérifications :
$liste[0]=3 \\leq liste[1]=7$ ✓
$liste[1]=7 > liste[2]=5$ ✗
Ordre décroissant détecté à la position $i=1$
Conclusion : Liste NON triée",
    "id_category": "3",
    "id_number": "16"
  },
  {
    "category": "Exercices corriges en python ",
    "question": "Créer un programme Python qui lit deux matrices $A$ de dimension $p \\times q$ et $B$ de dimension $q \\times r$, puis calcule leur produit $C = A \\times B$ de dimension $p \\times r$ où $C[i][j] = \\sum_{k=0}^{q-1} A[i][k] \\times B[k][j]$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
# Lecture des dimensions\np = int(input('Dimension p (lignes de A) : '))\nq = int(input('Dimension q (colonnes de A et lignes de B) : '))\nr = int(input('Dimension r (colonnes de B) : '))\n\n# Lecture de la matrice A\nA = []\nprint('\\nEntrez les éléments de la matrice A :')\nfor i in range(p):\n    ligne = []\n    for j in range(q):\n        valeur = float(input(f'A[{i}][{j}] : '))\n        ligne.append(valeur)\n    A.append(ligne)\n\n# Lecture de la matrice B\nB = []\nprint('\\nEntrez les éléments de la matrice B :')\nfor i in range(q):\n    ligne = []\n    for j in range(r):\n        valeur = float(input(f'B[{i}][{j}] : '))\n        ligne.append(valeur)\n    B.append(ligne)\n\n# Affichage des matrices\nprint('\\nMatrice A :')\nfor i in range(p):\n    print(A[i])\n\nprint('\\nMatrice B :')\nfor i in range(q):\n    print(B[i])\n\n# Calcul du produit C = A × B\nC = []\nfor i in range(p):\n    ligne = []\n    for j in range(r):\n        somme = 0\n        for k in range(q):\n            somme += A[i][k] * B[k][j]\n        ligne.append(somme)\n    C.append(ligne)\n\n# Affichage de C\nprint('\\nMatrice C = A × B :')\nfor i in range(p):\n    print(C[i])

Explication détaillée :

Étape 1 - Compatibilité des dimensions :
Pour multiplier $A$ par $B$, le nombre de colonnes de $A$ doit égaler le nombre de lignes de $B$.
$A$ : dimension $p \\times q$
$B$ : dimension $q \\times r$
$C = A \\times B$ : dimension $p \\times r$

Étape 2 - Formule du produit matriciel :
Pour chaque élément $C[i][j]$ :
$C[i][j] = \\sum_{k=0}^{q-1} A[i][k] \\times B[k][j]$
On multiplie la ligne $i$ de $A$ par la colonne $j$ de $B$.

Étape 3 - Triple boucle imbriquée :
Boucle 1 : $i$ de $0$ à $p-1$ (lignes de $C$)
Boucle 2 : $j$ de $0$ à $r-1$ (colonnes de $C$)
Boucle 3 : $k$ de $0$ à $q-1$ (somme des produits)

Étape 4 - Complexité :
Temps : $O(p \\times q \\times r)$

Exemple avec $p=2, q=3, r=2$ :
Matrice $A$ ($2 \\times 3$) :
$A = \\begin{pmatrix} 1 & 2 & 3 \\\\ 4 & 5 & 6 \\end{pmatrix}$
Matrice $B$ ($3 \\times 2$) :
$B = \\begin{pmatrix} 7 & 8 \\\\ 9 & 10 \\\\ 11 & 12 \\end{pmatrix}$
Calcul de $C$ ($2 \\times 2$) :
$C[0][0] = A[0][0] \\times B[0][0] + A[0][1] \\times B[1][0] + A[0][2] \\times B[2][0]$
$C[0][0] = 1 \\times 7 + 2 \\times 9 + 3 \\times 11 = 7 + 18 + 33 = 58$
$C[0][1] = 1 \\times 8 + 2 \\times 10 + 3 \\times 12 = 8 + 20 + 36 = 64$
$C[1][0] = 4 \\times 7 + 5 \\times 9 + 6 \\times 11 = 28 + 45 + 66 = 139$
$C[1][1] = 4 \\times 8 + 5 \\times 10 + 6 \\times 12 = 32 + 50 + 72 = 154$
Résultat :
$C = \\begin{pmatrix} 58 & 64 \\\\ 139 & 154 \\end{pmatrix}$",
    "id_category": "3",
    "id_number": "17"
  },
  {
    "category": "exercice",
    "question": "Écrire un programme Python qui lit un entier $n$ et calcule la somme des entiers de $1$ à $n$ en utilisant la formule $S = \\frac{n(n+1)}{2}$. Vérifier ensuite le résultat avec une boucle.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
n = int(input('Entrez un entier n : '))\n\n# Méthode 1 : Formule directe\nsomme_formule = n * (n + 1) // 2\nprint(f'Somme par formule : {somme_formule}')\n\n# Méthode 2 : Boucle de vérification\nsomme_boucle = 0\nfor i in range(1, n + 1):\n    somme_boucle += i\nprint(f'Somme par boucle : {somme_boucle}')

Explication détaillée :

Variables :
- $n$ : entier saisi par l'utilisateur
- $somme\\_formule$ : résultat calculé par la formule $S = \\frac{n(n+1)}{2}$
- $somme\\_boucle$ : résultat calculé par itération

Calcul par formule :
Pour $n = 10$ :
$S = \\frac{10 \\times 11}{2} = \\frac{110}{2} = 55$

Vérification par boucle :
$S = 1 + 2 + 3 + ... + 10 = 55$

Résultat : Les deux méthodes donnent $55$",
    "id_category": "2",
    "id_number": "1"
  },
  {
    "category": "exercice",
    "question": "Créer un programme Python qui lit un nombre réel $x$ et calcule $y = x^3 - 2x^2 + 5x - 7$. Afficher le résultat avec 3 décimales.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
x = float(input('Entrez la valeur de x : '))\n\n# Calcul de y = x^3 - 2x^2 + 5x - 7\ny = x**3 - 2*x**2 + 5*x - 7\n\nprint(f'Pour x = {x:.3f}')\nprint(f'y = {y:.3f}')

Explication détaillée :

Formule :
$y = x^3 - 2x^2 + 5x - 7$

Exemple pour $x = 2.5$ :

Étape 1 : Calcul de $x^3$
$x^3 = (2.5)^3 = 15.625$

Étape 2 : Calcul de $2x^2$
$2x^2 = 2 \\times (2.5)^2 = 2 \\times 6.25 = 12.5$

Étape 3 : Calcul de $5x$
$5x = 5 \\times 2.5 = 12.5$

Étape 4 : Calcul final
$y = 15.625 - 12.5 + 12.5 - 7 = 8.625$

Résultat : $y = 8.625$",
    "id_category": "2",
    "id_number": "2"
  },
  {
    "category": "exercice",
    "question": "Écrire un programme Python qui lit $5$ nombres entiers dans une liste et calcule leur moyenne arithmétique $\\bar{x} = \\frac{1}{n}\\sum_{i=1}^{n} x_i$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
# Initialisation de la liste\nnombres = []\n\n# Lecture de 5 nombres\nfor i in range(5):\n    nombre = int(input(f'Entrez le nombre {i+1} : '))\n    nombres.append(nombre)\n\n# Calcul de la somme\nsomme = sum(nombres)\n\n# Calcul de la moyenne\nmoyenne = somme / len(nombres)\n\nprint(f'Liste : {nombres}')\nprint(f'Somme : {somme}')\nprint(f'Moyenne : {moyenne:.2f}')

Explication détaillée :

Formule de la moyenne :
$\\bar{x} = \\frac{1}{n}\\sum_{i=1}^{n} x_i$

Exemple avec les valeurs : $x_1 = 10, x_2 = 15, x_3 = 20, x_4 = 25, x_5 = 30$

Étape 1 : Calcul de la somme
$\\sum_{i=1}^{5} x_i = 10 + 15 + 20 + 25 + 30 = 100$

Étape 2 : Calcul de la moyenne
$\\bar{x} = \\frac{100}{5} = 20.00$

Résultat : La moyenne est $\\bar{x} = 20.00$",
    "id_category": "2",
    "id_number": "3"
  },
  {
    "category": "exercice",
    "question": "Créer un programme Python qui génère un tableau de $10$ nombres aléatoires entre $1$ et $100$, puis trouve le maximum et le minimum de ce tableau.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
import random\n\n# Génération de 10 nombres aléatoires\ntableau = [random.randint(1, 100) for i in range(10)]\n\n# Recherche du maximum et minimum\nmaximum = max(tableau)\nminimum = min(tableau)\n\nprint(f'Tableau : {tableau}')\nprint(f'Maximum : {maximum}')\nprint(f'Minimum : {minimum}')\nprint(f'Écart : {maximum - minimum}')

Explication détaillée :

Exemple de tableau généré :
$T = [45, 12, 89, 23, 67, 34, 91, 56, 78, 19]$

Recherche du maximum :
Parcours du tableau :
$max = 45 \\rightarrow 45 \\rightarrow 89 \\rightarrow 89 \\rightarrow 89 \\rightarrow 89 \\rightarrow 91 \\rightarrow 91 \\rightarrow 91 \\rightarrow 91$

Résultat : $max = 91$

Recherche du minimum :
Parcours du tableau :
$min = 45 \\rightarrow 12 \\rightarrow 12 \\rightarrow 12 \\rightarrow 12 \\rightarrow 12 \\rightarrow 12 \\rightarrow 12 \\rightarrow 12 \\rightarrow 12$

Résultat : $min = 12$

Écart : $91 - 12 = 79$",
    "id_category": "2",
    "id_number": "4"
  },
  {
    "category": "exercice",
    "question": "Écrire un programme Python qui crée une matrice $3 \\times 3$ avec les valeurs de $1$ à $9$, puis calcule la somme de chaque ligne.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
# Création de la matrice 3x3\nmatrice = [\n    [1, 2, 3],\n    [4, 5, 6],\n    [7, 8, 9]\n]\n\n# Affichage de la matrice\nprint('Matrice :')\nfor ligne in matrice:\n    print(ligne)\n\n# Calcul de la somme de chaque ligne\nprint('\\nSomme de chaque ligne :')\nfor i in range(len(matrice)):\n    somme_ligne = sum(matrice[i])\n    print(f'Ligne {i+1} : {somme_ligne}')

Explication détaillée :

Matrice :
$M = \\begin{pmatrix} 1 & 2 & 3 \\\\ 4 & 5 & 6 \\\\ 7 & 8 & 9 \\end{pmatrix}$

Calcul de la somme ligne 1 :
$S_1 = 1 + 2 + 3 = 6$

Calcul de la somme ligne 2 :
$S_2 = 4 + 5 + 6 = 15$

Calcul de la somme ligne 3 :
$S_3 = 7 + 8 + 9 = 24$

Résultats :
- Ligne $1$ : $6$
- Ligne $2$ : $15$
- Ligne $3$ : $24$",
    "id_category": "2",
    "id_number": "5"
  },
  {
    "category": "exercice",
    "question": "Créer un programme Python qui lit un tableau de $n$ entiers et compte combien de nombres sont pairs et combien sont impairs.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
n = int(input('Combien de nombres ? '))\ntableau = []\n\n# Lecture des nombres\nfor i in range(n):\n    nombre = int(input(f'Nombre {i+1} : '))\n    tableau.append(nombre)\n\n# Comptage des pairs et impairs\npairs = 0\nimpairs = 0\n\nfor nombre in tableau:\n    if nombre % 2 == 0:\n        pairs += 1\n    else:\n        impairs += 1\n\nprint(f'Tableau : {tableau}')\nprint(f'Nombres pairs : {pairs}')\nprint(f'Nombres impairs : {impairs}')

Explication détaillée :

Exemple avec $n = 6$ et tableau : $[12, 7, 24, 9, 15, 18]$

Test de parité :
Un nombre $x$ est pair si $x \\bmod 2 = 0$

Vérification :
- $12 \\bmod 2 = 0$ → pair
- $7 \\bmod 2 = 1$ → impair
- $24 \\bmod 2 = 0$ → pair
- $9 \\bmod 2 = 1$ → impair
- $15 \\bmod 2 = 1$ → impair
- $18 \\bmod 2 = 0$ → pair

Résultats :
- Nombres pairs : $3$
- Nombres impairs : $3$",
    "id_category": "2",
    "id_number": "6"
  },
  {
    "category": "exercice",
    "question": "Écrire un programme Python qui calcule le produit scalaire de deux vecteurs $\\vec{u}$ et $\\vec{v}$ de dimension $n$ en utilisant la formule $\\vec{u} \\cdot \\vec{v} = \\sum_{i=1}^{n} u_i v_i$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
# Définition des vecteurs\nu = [1, 2, 3, 4]\nv = [5, 6, 7, 8]\n\n# Vérification que les vecteurs ont la même dimension\nif len(u) != len(v):\n    print('Erreur : dimensions différentes')\nelse:\n    # Calcul du produit scalaire\n    produit_scalaire = 0\n    for i in range(len(u)):\n        produit_scalaire += u[i] * v[i]\n    \n    print(f'Vecteur u : {u}')\n    print(f'Vecteur v : {v}')\n    print(f'Produit scalaire : {produit_scalaire}')

Explication détaillée :

Formule du produit scalaire :
$\\vec{u} \\cdot \\vec{v} = \\sum_{i=1}^{n} u_i v_i$

Vecteurs :
$\\vec{u} = (1, 2, 3, 4)$
$\\vec{v} = (5, 6, 7, 8)$

Calcul terme par terme :
$u_1 \\times v_1 = 1 \\times 5 = 5$
$u_2 \\times v_2 = 2 \\times 6 = 12$
$u_3 \\times v_3 = 3 \\times 7 = 21$
$u_4 \\times v_4 = 4 \\times 8 = 32$

Somme totale :
$\\vec{u} \\cdot \\vec{v} = 5 + 12 + 21 + 32 = 70$

Résultat : $70$",
    "id_category": "2",
    "id_number": "7"
  },
  {
    "category": "exercice",
    "question": "Créer un programme Python qui inverse l'ordre des éléments d'un tableau de $n$ nombres sans utiliser la fonction $reverse()$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
# Tableau initial\ntableau = [10, 20, 30, 40, 50]\nprint(f'Tableau initial : {tableau}')\n\n# Méthode 1 : Avec un tableau temporaire\ntableau_inverse = []\nfor i in range(len(tableau) - 1, -1, -1):\n    tableau_inverse.append(tableau[i])\n\nprint(f'Tableau inversé : {tableau_inverse}')\n\n# Méthode 2 : Inversion sur place\ntableau2 = [10, 20, 30, 40, 50]\nn = len(tableau2)\nfor i in range(n // 2):\n    # Échange des éléments\n    temp = tableau2[i]\n    tableau2[i] = tableau2[n - 1 - i]\n    tableau2[n - 1 - i] = temp\n\nprint(f'Inversion sur place : {tableau2}')

Explication détaillée :

Tableau initial :
$T = [10, 20, 30, 40, 50]$
Indices : $0, 1, 2, 3, 4$

Méthode 1 - Nouveau tableau :
Parcours inverse de l'indice $4$ à $0$
$T_{inverse}[0] = T[4] = 50$
$T_{inverse}[1] = T[3] = 40$
$T_{inverse}[2] = T[2] = 30$
$T_{inverse}[3] = T[1] = 20$
$T_{inverse}[4] = T[0] = 10$

Méthode 2 - Sur place :
Échange $T[0]$ et $T[4]$ : $[50, 20, 30, 40, 10]$
Échange $T[1]$ et $T[3]$ : $[50, 40, 30, 20, 10]$

Résultat : $[50, 40, 30, 20, 10]$",
    "id_category": "2",
    "id_number": "8"
  },
  {
    "category": "exercice",
    "question": "Écrire un programme Python qui crée une matrice identité $I_n$ de dimension $n \\times n$ où $I_{ij} = 1$ si $i = j$ et $0$ sinon.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
n = int(input('Dimension de la matrice : '))\n\n# Création de la matrice identité\nidentite = []\nfor i in range(n):\n    ligne = []\n    for j in range(n):\n        if i == j:\n            ligne.append(1)\n        else:\n            ligne.append(0)\n    identite.append(ligne)\n\n# Affichage de la matrice\nprint(f'Matrice identité I_{n} :')\nfor ligne in identite:\n    print(ligne)

Explication détaillée :

Définition :
La matrice identité $I_n$ est définie par :
$I_{ij} = \\begin{cases} 1 & \\text{si } i = j \\\\ 0 & \\text{si } i \\neq j \\end{cases}$

Exemple pour $n = 4$ :

$I_4 = \\begin{pmatrix} 1 & 0 & 0 & 0 \\\\ 0 & 1 & 0 & 0 \\\\ 0 & 0 & 1 & 0 \\\\ 0 & 0 & 0 & 1 \\end{pmatrix}$

Construction :
Pour $i = 0$ : $[1, 0, 0, 0]$ (car $j = 0$ donne $i = j$)
Pour $i = 1$ : $[0, 1, 0, 0]$ (car $j = 1$ donne $i = j$)
Pour $i = 2$ : $[0, 0, 1, 0]$ (car $j = 2$ donne $i = j$)
Pour $i = 3$ : $[0, 0, 0, 1]$ (car $j = 3$ donne $i = j$)",
    "id_category": "2",
    "id_number": "9"
  },
  {
    "category": "exercice",
    "question": "Créer un programme Python qui calcule la factorielle d'un nombre $n$ en utilisant la formule $n! = n \\times (n-1) \\times (n-2) \\times ... \\times 2 \\times 1$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
n = int(input('Entrez un entier positif : '))\n\nif n < 0:\n    print('Erreur : n doit être positif')\nelif n == 0 or n == 1:\n    print(f'{n}! = 1')\nelse:\n    # Calcul de la factorielle\n    factorielle = 1\n    for i in range(2, n + 1):\n        factorielle *= i\n    \n    print(f'{n}! = {factorielle}')

Explication détaillée :

Formule :
$n! = \\prod_{i=1}^{n} i = 1 \\times 2 \\times 3 \\times ... \\times n$

Exemple pour $n = 6$ :

Initialisation : $factorielle = 1$

Itération 1 : $i = 2$, $factorielle = 1 \\times 2 = 2$
Itération 2 : $i = 3$, $factorielle = 2 \\times 3 = 6$
Itération 3 : $i = 4$, $factorielle = 6 \\times 4 = 24$
Itération 4 : $i = 5$, $factorielle = 24 \\times 5 = 120$
Itération 5 : $i = 6$, $factorielle = 120 \\times 6 = 720$

Résultat : $6! = 720$",
    "id_category": "2",
    "id_number": "10"
  },
  {
    "category": "exercice",
    "question": "Écrire un programme Python qui lit deux matrices $A$ et $B$ de dimension $2 \\times 2$ et calcule leur somme $C = A + B$ où $C_{ij} = A_{ij} + B_{ij}$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
# Définition des matrices\nA = [[1, 2], \n     [3, 4]]\n\nB = [[5, 6],\n     [7, 8]]\n\n# Calcul de la somme C = A + B\nC = []\nfor i in range(len(A)):\n    ligne = []\n    for j in range(len(A[0])):\n        ligne.append(A[i][j] + B[i][j])\n    C.append(ligne)\n\n# Affichage\nprint('Matrice A :')\nfor ligne in A:\n    print(ligne)\n\nprint('\\nMatrice B :')\nfor ligne in B:\n    print(ligne)\n\nprint('\\nMatrice C = A + B :')\nfor ligne in C:\n    print(ligne)

Explication détaillée :

Matrices :
$A = \\begin{pmatrix} 1 & 2 \\\\ 3 & 4 \\end{pmatrix}, \\quad B = \\begin{pmatrix} 5 & 6 \\\\ 7 & 8 \\end{pmatrix}$

Formule de la somme :
$C_{ij} = A_{ij} + B_{ij}$

Calcul terme par terme :
$C_{11} = A_{11} + B_{11} = 1 + 5 = 6$
$C_{12} = A_{12} + B_{12} = 2 + 6 = 8$
$C_{21} = A_{21} + B_{21} = 3 + 7 = 10$
$C_{22} = A_{22} + B_{22} = 4 + 8 = 12$

Résultat :
$C = \\begin{pmatrix} 6 & 8 \\\\ 10 & 12 \\end{pmatrix}$",
    "id_category": "2",
    "id_number": "11"
  },
  {
    "category": "exercice",
    "question": "Créer un programme Python qui trouve tous les diviseurs d'un nombre entier $n$ et affiche leur somme.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
n = int(input('Entrez un entier positif : '))\n\nif n <= 0:\n    print('Erreur : n doit être positif')\nelse:\n    # Recherche des diviseurs\n    diviseurs = []\n    for i in range(1, n + 1):\n        if n % i == 0:\n            diviseurs.append(i)\n    \n    # Calcul de la somme\n    somme = sum(diviseurs)\n    \n    print(f'Diviseurs de {n} : {diviseurs}')\n    print(f'Nombre de diviseurs : {len(diviseurs)}')\n    print(f'Somme des diviseurs : {somme}')

Explication détaillée :

Exemple pour $n = 12$ :

Test de divisibilité :
Un nombre $d$ est diviseur de $n$ si $n \\bmod d = 0$

Vérification :
$12 \\bmod 1 = 0$ → $1$ est diviseur
$12 \\bmod 2 = 0$ → $2$ est diviseur
$12 \\bmod 3 = 0$ → $3$ est diviseur
$12 \\bmod 4 = 0$ → $4$ est diviseur
$12 \\bmod 5 = 2$ → $5$ n'est pas diviseur
$12 \\bmod 6 = 0$ → $6$ est diviseur
$12 \\bmod 12 = 0$ → $12$ est diviseur

Liste des diviseurs : $[1, 2, 3, 4, 6, 12]$

Somme : $1 + 2 + 3 + 4 + 6 + 12 = 28$",
    "id_category": "2",
    "id_number": "12"
  },
  {
    "category": "exercice",
    "question": "Écrire un programme Python qui calcule la norme euclidienne d'un vecteur $\\vec{v}$ en utilisant la formule $\\|\\vec{v}\\| = \\sqrt{\\sum_{i=1}^{n} v_i^2}$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
import math\n\n# Définition du vecteur\nvecteur = [3, 4, 5, 6]\n\n# Calcul de la somme des carrés\nsomme_carres = 0\nfor element in vecteur:\n    somme_carres += element ** 2\n\n# Calcul de la norme\nnorme = math.sqrt(somme_carres)\n\nprint(f'Vecteur : {vecteur}')\nprint(f'Somme des carrés : {somme_carres}')\nprint(f'Norme : {norme:.4f}')

Explication détaillée :

Formule de la norme euclidienne :
$\\|\\vec{v}\\| = \\sqrt{\\sum_{i=1}^{n} v_i^2}$

Vecteur : $\\vec{v} = (3, 4, 5, 6)$

Étape 1 : Calcul des carrés
$v_1^2 = 3^2 = 9$
$v_2^2 = 4^2 = 16$
$v_3^2 = 5^2 = 25$
$v_4^2 = 6^2 = 36$

Étape 2 : Somme des carrés
$\\sum_{i=1}^{4} v_i^2 = 9 + 16 + 25 + 36 = 86$

Étape 3 : Racine carrée
$\\|\\vec{v}\\| = \\sqrt{86} \\approx 9.2736$

Résultat : $\\|\\vec{v}\\| = 9.2736$",
    "id_category": "2",
    "id_number": "13"
  },
  {
    "category": "exercice",
    "question": "Créer un programme Python qui transpose une matrice $A$ de dimension $3 \\times 2$ pour obtenir $A^T$ de dimension $2 \\times 3$ où $A^T_{ij} = A_{ji}$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
# Matrice originale 3x2\nA = [[1, 2],\n     [3, 4],\n     [5, 6]]\n\n# Dimensions\nm = len(A)      # nombre de lignes = 3\nn = len(A[0])   # nombre de colonnes = 2\n\n# Création de la transposée\nA_T = []\nfor j in range(n):\n    ligne = []\n    for i in range(m):\n        ligne.append(A[i][j])\n    A_T.append(ligne)\n\n# Affichage\nprint('Matrice A (3x2) :')\nfor ligne in A:\n    print(ligne)\n\nprint('\\nMatrice transposée A^T (2x3) :')\nfor ligne in A_T:\n    print(ligne)

Explication détaillée :

Matrice originale :
$A = \\begin{pmatrix} 1 & 2 \\\\ 3 & 4 \\\\ 5 & 6 \\end{pmatrix}_{3 \\times 2}$

Formule de transposition :
$A^T_{ij} = A_{ji}$

Construction de $A^T$ :

Ligne $1$ de $A^T$ = Colonne $1$ de $A$ :
$A^T_1 = [A_{11}, A_{21}, A_{31}] = [1, 3, 5]$

Ligne $2$ de $A^T$ = Colonne $2$ de $A$ :
$A^T_2 = [A_{12}, A_{22}, A_{32}] = [2, 4, 6]$

Résultat :
$A^T = \\begin{pmatrix} 1 & 3 & 5 \\\\ 2 & 4 & 6 \\end{pmatrix}_{2 \\times 3}$",
    "id_category": "2",
    "id_number": "14"
  },
  {
    "category": "exercice",
    "question": "Écrire un programme Python qui recherche un élément $x$ dans un tableau trié et retourne son indice en utilisant la recherche séquentielle.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
# Tableau trié\ntableau = [2, 5, 8, 12, 16, 23, 38, 45, 56, 67]\nx = int(input('Élément à rechercher : '))\n\n# Recherche séquentielle\nindice = -1\nfor i in range(len(tableau)):\n    if tableau[i] == x:\n        indice = i\n        break\n\n# Affichage du résultat\nprint(f'Tableau : {tableau}')\nif indice != -1:\n    print(f'Élément {x} trouvé à l\\'indice {indice}')\nelse:\n    print(f'Élément {x} non trouvé')

Explication détaillée :

Tableau : $T = [2, 5, 8, 12, 16, 23, 38, 45, 56, 67]$
Élément recherché : $x = 23$

Recherche séquentielle :

$i = 0$ : $T[0] = 2 \\neq 23$, continuer
$i = 1$ : $T[1] = 5 \\neq 23$, continuer
$i = 2$ : $T[2] = 8 \\neq 23$, continuer
$i = 3$ : $T[3] = 12 \\neq 23$, continuer
$i = 4$ : $T[4] = 16 \\neq 23$, continuer
$i = 5$ : $T[5] = 23 = 23$, trouvé !

Résultat : L'élément $23$ est trouvé à l'indice $5$

Complexité : $O(n)$ dans le pire cas",
    "id_category": "2",
    "id_number": "15"
  },
  {
    "category": "exercice",
    "question": "Créer un programme Python qui calcule la trace d'une matrice carrée $A$ de dimension $n \\times n$ en utilisant la formule $tr(A) = \\sum_{i=1}^{n} A_{ii}$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
# Matrice carrée 4x4\nA = [[5, 2, 3, 1],\n     [4, 8, 6, 2],\n     [7, 1, 9, 4],\n     [3, 5, 2, 6]]\n\n# Vérification que la matrice est carrée\nif len(A) != len(A[0]):\n    print('Erreur : la matrice doit être carrée')\nelse:\n    # Calcul de la trace\n    trace = 0\n    for i in range(len(A)):\n        trace += A[i][i]\n    \n    print('Matrice A :')\n    for ligne in A:\n        print(ligne)\n    \n    print(f'\\nTrace de A : {trace}')

Explication détaillée :

Formule de la trace :
$tr(A) = \\sum_{i=1}^{n} A_{ii}$

Matrice :
$A = \\begin{pmatrix} 5 & 2 & 3 & 1 \\\\ 4 & 8 & 6 & 2 \\\\ 7 & 1 & 9 & 4 \\\\ 3 & 5 & 2 & 6 \\end{pmatrix}$

Éléments diagonaux :
La diagonale principale contient : $A_{11}, A_{22}, A_{33}, A_{44}$

Calcul :
$A_{11} = 5$
$A_{22} = 8$
$A_{33} = 9$
$A_{44} = 6$

Somme :
$tr(A) = 5 + 8 + 9 + 6 = 28$

Résultat : $tr(A) = 28$",
    "id_category": "2",
    "id_number": "16"
  },
  {
    "category": "exercice",
    "question": "Écrire un programme Python qui multiplie une matrice $A$ de dimension $2 \\times 3$ par un scalaire $k$ pour obtenir $B = kA$ où $B_{ij} = k \\times A_{ij}$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
# Matrice A (2x3)\nA = [[2, 4, 6],\n     [3, 5, 7]]\n\n# Scalaire\nk = 3\n\n# Multiplication par le scalaire\nB = []\nfor i in range(len(A)):\n    ligne = []\n    for j in range(len(A[0])):\n        ligne.append(k * A[i][j])\n    B.append(ligne)\n\n# Affichage\nprint(f'Scalaire k = {k}')\nprint('\\nMatrice A :')\nfor ligne in A:\n    print(ligne)\n\nprint('\\nMatrice B = kA :')\nfor ligne in B:\n    print(ligne)

Explication détaillée :

Matrice originale :
$A = \\begin{pmatrix} 2 & 4 & 6 \\\\ 3 & 5 & 7 \\end{pmatrix}$

Scalaire : $k = 3$

Formule : $B_{ij} = k \\times A_{ij}$

Calcul terme par terme :
$B_{11} = 3 \\times 2 = 6$
$B_{12} = 3 \\times 4 = 12$
$B_{13} = 3 \\times 6 = 18$
$B_{21} = 3 \\times 3 = 9$
$B_{22} = 3 \\times 5 = 15$
$B_{23} = 3 \\times 7 = 21$

Résultat :
$B = \\begin{pmatrix} 6 & 12 & 18 \\\\ 9 & 15 & 21 \\end{pmatrix}$",
    "id_category": "2",
    "id_number": "17"
  },
  {
    "category": "exercice",
    "question": "Créer un programme Python qui calcule la variance d'un ensemble de $n$ nombres en utilisant la formule $\\sigma^2 = \\frac{1}{n}\\sum_{i=1}^{n}(x_i - \\bar{x})^2$ où $\\bar{x}$ est la moyenne.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
# Ensemble de données\ndata = [12, 15, 18, 20, 25, 30]\n\n# Calcul de la moyenne\nn = len(data)\nmoyenne = sum(data) / n\n\n# Calcul de la variance\nsomme_ecarts_carres = 0\nfor x in data:\n    ecart = x - moyenne\n    somme_ecarts_carres += ecart ** 2\n\nvariance = somme_ecarts_carres / n\n\n# Écart-type\necart_type = variance ** 0.5\n\nprint(f'Données : {data}')\nprint(f'Moyenne : {moyenne:.2f}')\nprint(f'Variance : {variance:.2f}')\nprint(f'Écart-type : {ecart_type:.2f}')

Explication détaillée :

Données : $x = [12, 15, 18, 20, 25, 30]$, $n = 6$

Étape 1 : Calcul de la moyenne
$\\bar{x} = \\frac{1}{6}(12 + 15 + 18 + 20 + 25 + 30) = \\frac{120}{6} = 20$

Étape 2 : Calcul des écarts au carré
$(x_1 - \\bar{x})^2 = (12 - 20)^2 = (-8)^2 = 64$
$(x_2 - \\bar{x})^2 = (15 - 20)^2 = (-5)^2 = 25$
$(x_3 - \\bar{x})^2 = (18 - 20)^2 = (-2)^2 = 4$
$(x_4 - \\bar{x})^2 = (20 - 20)^2 = 0^2 = 0$
$(x_5 - \\bar{x})^2 = (25 - 20)^2 = 5^2 = 25$
$(x_6 - \\bar{x})^2 = (30 - 20)^2 = 10^2 = 100$

Étape 3 : Somme et variance
$\\sum (x_i - \\bar{x})^2 = 64 + 25 + 4 + 0 + 25 + 100 = 218$
$\\sigma^2 = \\frac{218}{6} = 36.33$

Résultat : Variance = $36.33$",
    "id_category": "2",
    "id_number": "18"
  },
  {
    "category": "exercice",
    "question": "Écrire un programme Python qui fusionne deux tableaux triés $A$ et $B$ en un seul tableau trié $C$ sans utiliser de fonction de tri.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
# Tableaux triés\nA = [1, 5, 9, 12, 18]\nB = [3, 7, 11, 15, 20]\n\n# Fusion des tableaux\nC = []\ni = 0  # indice pour A\nj = 0  # indice pour B\n\n# Comparaison et fusion\nwhile i < len(A) and j < len(B):\n    if A[i] <= B[j]:\n        C.append(A[i])\n        i += 1\n    else:\n        C.append(B[j])\n        j += 1\n\n# Ajout des éléments restants de A\nwhile i < len(A):\n    C.append(A[i])\n    i += 1\n\n# Ajout des éléments restants de B\nwhile j < len(B):\n    C.append(B[j])\n    j += 1\n\nprint(f'Tableau A : {A}')\nprint(f'Tableau B : {B}')\nprint(f'Tableau fusionné C : {C}')

Explication détaillée :

Tableaux :
$A = [1, 5, 9, 12, 18]$
$B = [3, 7, 11, 15, 20]$

Processus de fusion :

Comparaison $A[0]=1$ et $B[0]=3$ : $1 \\leq 3$ → $C=[1]$, $i=1$
Comparaison $A[1]=5$ et $B[0]=3$ : $5 > 3$ → $C=[1,3]$, $j=1$
Comparaison $A[1]=5$ et $B[1]=7$ : $5 \\leq 7$ → $C=[1,3,5]$, $i=2$
Comparaison $A[2]=9$ et $B[1]=7$ : $9 > 7$ → $C=[1,3,5,7]$, $j=2$
Comparaison $A[2]=9$ et $B[2]=11$ : $9 \\leq 11$ → $C=[1,3,5,7,9]$, $i=3$
Continuation...

Résultat final :
$C = [1, 3, 5, 7, 9, 11, 12, 15, 18, 20]$",
    "id_category": "2",
    "id_number": "19"
  },
  {
    "category": "exercice",
    "question": "Créer un programme Python qui multiplie deux matrices $A$ de dimension $2 \\times 3$ et $B$ de dimension $3 \\times 2$ pour obtenir $C = A \\times B$ en utilisant $C_{ij} = \\sum_{k=1}^{3} A_{ik} \\times B_{kj}$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
# Matrice A (2x3)\nA = [[1, 2, 3],\n     [4, 5, 6]]\n\n# Matrice B (3x2)\nB = [[7, 8],\n     [9, 10],\n     [11, 12]]\n\n# Dimensions\nm = len(A)      # 2 lignes\np = len(A[0])   # 3 colonnes = lignes de B\nn = len(B[0])   # 2 colonnes\n\n# Multiplication C = A x B (2x2)\nC = []\nfor i in range(m):\n    ligne = []\n    for j in range(n):\n        somme = 0\n        for k in range(p):\n            somme += A[i][k] * B[k][j]\n        ligne.append(somme)\n    C.append(ligne)\n\nprint('Matrice A (2x3) :')\nfor ligne in A:\n    print(ligne)\n\nprint('\\nMatrice B (3x2) :')\nfor ligne in B:\n    print(ligne)\n\nprint('\\nMatrice C = A x B (2x2) :')\nfor ligne in C:\n    print(ligne)

Explication détaillée :

Matrices :
$A = \\begin{pmatrix} 1 & 2 & 3 \\ 4 & 5 & 6 \\end{pmatrix}_{2 \\times 3}, \\quad B = \\begin{pmatrix} 7 & 8 \\ 9 & 10 \\ 11 & 12 \\end{pmatrix}_{3 \\times 2}$

Formule : $C_{ij} = \\sum_{k=1}^{3} A_{ik} \\times B_{kj}$

Calcul de $C_{11}$ :
$C_{11} = A_{11} \\times B_{11} + A_{12} \\times B_{21} + A_{13} \\times B_{31}$
$C_{11} = 1 \\times 7 + 2 \\times 9 + 3 \\times 11 = 7 + 18 + 33 = 58$

Calcul de $C_{12}$ :
$C_{12} = 1 \\times 8 + 2 \\times 10 + 3 \\times 12 = 8 + 20 + 36 = 64$

Calcul de $C_{21}$ :
$C_{21} = 4 \\times 7 + 5 \\times 9 + 6 \\times 11 = 28 + 45 + 66 = 139$

Calcul de $C_{22}$ :
$C_{22} = 4 \\times 8 + 5 \\times 10 + 6 \\times 12 = 32 + 50 + 72 = 154$

Résultat :
$C = \\begin{pmatrix} 58 & 64 \\ 139 & 154 \\end{pmatrix}_{2 \\times 2}$",
    "id_category": "2",
    "id_number": "20"
  },
  {
    "category": "Exercices corriges en python ",
    "question": "Écrire un programme Python qui lit deux nombres entiers $a$ et $b$, puis calcule et affiche leur somme $S = a + b$, leur produit $P = a \\times b$ et leur moyenne arithmétique $M = \\frac{a + b}{2}$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
# Lecture des deux entiers\na = int(input('Entrez le premier entier a : '))\nb = int(input('Entrez le deuxième entier b : '))\n\n# Calcul de la somme\nS = a + b\nprint(f'Somme S = {S}')\n\n# Calcul du produit\nP = a * b\nprint(f'Produit P = {P}')\n\n# Calcul de la moyenne\nM = (a + b) / 2\nprint(f'Moyenne M = {M}')

Explication étape par étape :

Étape 1 : Lecture des données
On utilise $input()$ pour lire les valeurs et $int()$ pour convertir en entiers

Étape 2 : Calcul de la somme
Formule : $S = a + b$
Exemple avec $a = 10$ et $b = 5$ : $S = 10 + 5 = 15$

Étape 3 : Calcul du produit
Formule : $P = a \\times b$
Exemple : $P = 10 \\times 5 = 50$

Étape 4 : Calcul de la moyenne
Formule : $M = \\frac{a + b}{2}$
Exemple : $M = \\frac{10 + 5}{2} = \\frac{15}{2} = 7.5$",
    "id_category": "3",
    "id_number": "18"
  },
  {
    "category": "Exercices corriges en python ",
    "question": "Créer un programme Python qui génère une liste de $n$ nombres entiers aléatoires entre $1$ et $100$. Calculer et afficher la somme totale $S = \\sum_{i=1}^{n} x_i$, le maximum $\\max(x_i)$ et le minimum $\\min(x_i)$ de cette liste.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
import random\n\n# Lecture du nombre d'éléments\nn = int(input('Entrez le nombre d\\'éléments n : '))\n\n# Génération de la liste\nliste = [random.randint(1, 100) for i in range(n)]\nprint(f'Liste générée : {liste}')\n\n# Calcul de la somme\nS = sum(liste)\nprint(f'Somme totale S = {S}')\n\n# Calcul du maximum\nmaxi = max(liste)\nprint(f'Maximum = {maxi}')\n\n# Calcul du minimum\nmini = min(liste)\nprint(f'Minimum = {mini}')

Explication étape par étape :

Étape 1 : Importation du module
Le module $random$ permet de générer des nombres aléatoires

Étape 2 : Génération de la liste
On utilise une list comprehension : $[random.randint(1, 100) for i in range(n)]$
Exemple pour $n = 5$ : $[45, 12, 89, 23, 67]$

Étape 3 : Calcul de la somme
Formule : $S = \\sum_{i=1}^{n} x_i$
Exemple : $S = 45 + 12 + 89 + 23 + 67 = 236$

Étape 4 : Maximum et minimum
Fonctions $max()$ et $min()$ intégrées en Python
Exemple : $\\max = 89$, $\\min = 12$",
    "id_category": "3",
    "id_number": "19"
  },
  {
    "category": "Exercices corriges en python ",
    "question": "Écrire un programme Python qui calcule la factorielle $n! = n \\times (n-1) \\times (n-2) \\times ... \\times 2 \\times 1$ d'un entier $n$ donné en utilisant une boucle for. Afficher également les étapes intermédiaires.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
# Lecture de l'entier\nn = int(input('Entrez un entier n : '))\n\n# Vérification\nif n < 0:\n    print('Erreur : n doit être positif')\nelse:\n    # Calcul de la factorielle\n    factorielle = 1\n    print(f'Calcul de {n}! :')\n    \n    for i in range(1, n + 1):\n        factorielle = factorielle * i\n        print(f'Étape {i} : factorielle = {factorielle}')\n    \n    print(f'\\nRésultat final : {n}! = {factorielle}')

Explication étape par étape :

Étape 1 : Initialisation
On initialise $factorielle = 1$ (élément neutre de la multiplication)

Étape 2 : Boucle de calcul
Formule générale : $n! = \\prod_{i=1}^{n} i$

Exemple pour $n = 5$ :
Étape $1$ : $factorielle = 1 \\times 1 = 1$
Étape $2$ : $factorielle = 1 \\times 2 = 2$
Étape $3$ : $factorielle = 2 \\times 3 = 6$
Étape $4$ : $factorielle = 6 \\times 4 = 24$
Étape $5$ : $factorielle = 24 \\times 5 = 120$

Résultat : $5! = 120$",
    "id_category": "3",
    "id_number": "20"
  },
  {
    "category": "Exercices corriges en python ",
    "question": "Créer un programme Python qui lit une liste de $n$ nombres réels et calcule la variance $\\sigma^2 = \\frac{1}{n}\\sum_{i=1}^{n}(x_i - \\mu)^2$ et l'écart-type $\\sigma = \\sqrt{\\sigma^2}$, où $\\mu$ est la moyenne arithmétique.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
import math\n\n# Lecture du nombre d'éléments\nn = int(input('Entrez le nombre d\\'éléments n : '))\n\n# Lecture de la liste\nliste = []\nfor i in range(n):\n    x = float(input(f'Entrez l\\'élément {i+1} : '))\n    liste.append(x)\n\nprint(f'Liste : {liste}')\n\n# Calcul de la moyenne\nmu = sum(liste) / n\nprint(f'Moyenne μ = {mu}')\n\n# Calcul de la variance\nvariance = sum([(x - mu)**2 for x in liste]) / n\nprint(f'Variance σ² = {variance}')\n\n# Calcul de l'écart-type\necart_type = math.sqrt(variance)\nprint(f'Écart-type σ = {ecart_type}')

Explication étape par étape :

Étape 1 : Calcul de la moyenne
Formule : $\\mu = \\frac{1}{n}\\sum_{i=1}^{n} x_i$
Exemple avec $[10, 12, 14, 16, 18]$ : $\\mu = \\frac{10+12+14+16+18}{5} = \\frac{70}{5} = 14$

Étape 2 : Calcul des écarts au carré
Pour chaque $x_i$, on calcule $(x_i - \\mu)^2$
$(10-14)^2 = 16$, $(12-14)^2 = 4$, $(14-14)^2 = 0$, $(16-14)^2 = 4$, $(18-14)^2 = 16$

Étape 3 : Calcul de la variance
Formule : $\\sigma^2 = \\frac{1}{n}\\sum_{i=1}^{n}(x_i - \\mu)^2$
$\\sigma^2 = \\frac{16+4+0+4+16}{5} = \\frac{40}{5} = 8$

Étape 4 : Calcul de l'écart-type
Formule : $\\sigma = \\sqrt{\\sigma^2} = \\sqrt{8} \\approx 2.83$",
    "id_category": "3",
    "id_number": "21"
  },
  {
    "category": "Exercices corriges en python ",
    "question": "Écrire un programme Python qui crée une matrice $A$ de dimension $m \\times n$ remplie de zéros, puis remplit la diagonale principale avec des $1$ (pour une matrice carrée). Afficher la matrice résultante.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
# Lecture des dimensions\nm = int(input('Entrez le nombre de lignes m : '))\nn = int(input('Entrez le nombre de colonnes n : '))\n\n# Création de la matrice de zéros\nA = [[0 for j in range(n)] for i in range(m)]\n\nprint('Matrice initiale (zéros) :')\nfor ligne in A:\n    print(ligne)\n\n# Remplissage de la diagonale\nfor i in range(min(m, n)):\n    A[i][i] = 1\n\nprint('\\nMatrice après remplissage de la diagonale :')\nfor ligne in A:\n    print(ligne)

Explication étape par étape :

Étape 1 : Création de la matrice de zéros
Formule : $A_{ij} = 0$ pour tout $i \\in [1,m]$ et $j \\in [1,n]$
Exemple pour $m=3$, $n=3$ :
$A = \\begin{pmatrix} 0 & 0 & 0 \\\\ 0 & 0 & 0 \\\\ 0 & 0 & 0 \\end{pmatrix}$

Étape 2 : Remplissage de la diagonale
On modifie $A_{ii} = 1$ pour $i = 1, 2, ..., \\min(m,n)$

Résultat pour $m=3$, $n=3$ :
$A = \\begin{pmatrix} 1 & 0 & 0 \\\\ 0 & 1 & 0 \\\\ 0 & 0 & 1 \\end{pmatrix}$

C'est la matrice identité $I_3$",
    "id_category": "3",
    "id_number": "22"
  },
  {
    "category": "Exercices corriges en python ",
    "question": "Créer un programme Python qui calcule la somme des $n$ premiers termes de la suite harmonique $H_n = 1 + \\frac{1}{2} + \\frac{1}{3} + ... + \\frac{1}{n}$. Afficher la somme partielle à chaque itération.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
# Lecture de n\nn = int(input('Entrez le nombre de termes n : '))\n\n# Initialisation\nH = 0\n\nprint(f'Calcul de la suite harmonique H_{n} :')\nprint()\n\n# Calcul de la somme\nfor i in range(1, n + 1):\n    terme = 1 / i\n    H = H + terme\n    print(f'H_{i} = H_{i-1} + 1/{i} = {H:.6f}')\n\nprint(f'\\nRésultat final : H_{n} = {H:.6f}')

Explication étape par étape :

Formule générale :
$H_n = \\sum_{k=1}^{n} \\frac{1}{k}$

Exemple pour $n = 5$ :

Itération $1$ :
$H_1 = \\frac{1}{1} = 1.000000$

Itération $2$ :
$H_2 = H_1 + \\frac{1}{2} = 1 + 0.5 = 1.500000$

Itération $3$ :
$H_3 = H_2 + \\frac{1}{3} = 1.5 + 0.333333 = 1.833333$

Itération $4$ :
$H_4 = H_3 + \\frac{1}{4} = 1.833333 + 0.25 = 2.083333$

Itération $5$ :
$H_5 = H_4 + \\frac{1}{5} = 2.083333 + 0.2 = 2.283333$

Résultat : $H_5 = 2.283333$",
    "id_category": "3",
    "id_number": "23"
  },
  {
    "category": "Exercices corriges en python ",
    "question": "Écrire un programme Python qui lit deux vecteurs $\\vec{u}$ et $\\vec{v}$ de dimension $n$, puis calcule leur produit scalaire $\\vec{u} \\cdot \\vec{v} = \\sum_{i=1}^{n} u_i v_i$ et leur norme euclidienne $||\\vec{u}|| = \\sqrt{\\sum_{i=1}^{n} u_i^2}$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
import math\n\n# Lecture de la dimension\nn = int(input('Entrez la dimension n : '))\n\n# Lecture du premier vecteur\nprint('Entrez les composantes du vecteur u :')\nu = [float(input(f'u[{i+1}] = ')) for i in range(n)]\n\n# Lecture du second vecteur\nprint('Entrez les composantes du vecteur v :')\nv = [float(input(f'v[{i+1}] = ')) for i in range(n)]\n\nprint(f'\\nVecteur u = {u}')\nprint(f'Vecteur v = {v}')\n\n# Calcul du produit scalaire\nproduit_scalaire = sum([u[i] * v[i] for i in range(n)])\nprint(f'\\nProduit scalaire u·v = {produit_scalaire}')\n\n# Calcul de la norme de u\nnorme_u = math.sqrt(sum([u[i]**2 for i in range(n)]))\nprint(f'Norme ||u|| = {norme_u:.4f}')\n\n# Calcul de la norme de v\nnorme_v = math.sqrt(sum([v[i]**2 for i in range(n)]))\nprint(f'Norme ||v|| = {norme_v:.4f}')

Explication étape par étape :

Exemple avec $n=3$, $\\vec{u} = (1, 2, 3)$, $\\vec{v} = (4, 5, 6)$ :

Étape 1 : Produit scalaire
Formule : $\\vec{u} \\cdot \\vec{v} = \\sum_{i=1}^{n} u_i v_i$
$\\vec{u} \\cdot \\vec{v} = (1)(4) + (2)(5) + (3)(6)$
$= 4 + 10 + 18 = 32$

Étape 2 : Norme de $\\vec{u}$
Formule : $||\\vec{u}|| = \\sqrt{\\sum_{i=1}^{n} u_i^2}$
$||\\vec{u}|| = \\sqrt{1^2 + 2^2 + 3^2}$
$= \\sqrt{1 + 4 + 9} = \\sqrt{14} \\approx 3.7417$

Étape 3 : Norme de $\\vec{v}$
$||\\vec{v}|| = \\sqrt{4^2 + 5^2 + 6^2}$
$= \\sqrt{16 + 25 + 36} = \\sqrt{77} \\approx 8.7750$",
    "id_category": "3",
    "id_number": "24"
  },
  {
    "category": "Exercices corriges en python ",
    "question": "Créer un programme Python qui génère une matrice $A$ de dimension $3 \\times 3$ avec des valeurs aléatoires entières entre $1$ et $10$, puis calcule la somme de chaque ligne $S_i = \\sum_{j=1}^{3} A_{ij}$ et de chaque colonne $S_j = \\sum_{i=1}^{3} A_{ij}$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
import random\n\n# Génération de la matrice 3x3\nA = [[random.randint(1, 10) for j in range(3)] for i in range(3)]\n\nprint('Matrice A :')\nfor ligne in A:\n    print(ligne)\n\nprint('\\nSommes des lignes :')\nfor i in range(3):\n    somme_ligne = sum(A[i])\n    print(f'Ligne {i+1} : S_{i+1} = {A[i][0]} + {A[i][1]} + {A[i][2]} = {somme_ligne}')\n\nprint('\\nSommes des colonnes :')\nfor j in range(3):\n    somme_colonne = sum([A[i][j] for i in range(3)])\n    print(f'Colonne {j+1} : S_{j+1} = {A[0][j]} + {A[1][j]} + {A[2][j]} = {somme_colonne}')

Explication étape par étape :

Exemple avec la matrice :
$A = \\begin{pmatrix} 3 & 7 & 2 \\\\ 5 & 1 & 8 \\\\ 4 & 6 & 9 \\end{pmatrix}$

Étape 1 : Sommes des lignes
Formule : $S_i = \\sum_{j=1}^{3} A_{ij}$

Ligne $1$ : $S_1 = A_{11} + A_{12} + A_{13} = 3 + 7 + 2 = 12$
Ligne $2$ : $S_2 = A_{21} + A_{22} + A_{23} = 5 + 1 + 8 = 14$
Ligne $3$ : $S_3 = A_{31} + A_{32} + A_{33} = 4 + 6 + 9 = 19$

Étape 2 : Sommes des colonnes
Formule : $S_j = \\sum_{i=1}^{3} A_{ij}$

Colonne $1$ : $S_1 = A_{11} + A_{21} + A_{31} = 3 + 5 + 4 = 12$
Colonne $2$ : $S_2 = A_{12} + A_{22} + A_{32} = 7 + 1 + 6 = 14$
Colonne $3$ : $S_3 = A_{13} + A_{23} + A_{33} = 2 + 8 + 9 = 19$",
    "id_category": "3",
    "id_number": "25"
  },
  {
    "category": "Exercices corriges en python ",
    "question": "Écrire un programme Python qui calcule la somme des $n$ premiers nombres pairs $S = 2 + 4 + 6 + ... + 2n$ en utilisant la formule directe $S = n(n+1)$ et en vérifiant avec une boucle.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
# Lecture de n\nn = int(input('Entrez n : '))\n\n# Méthode 1 : Formule directe\nS_formule = n * (n + 1)\nprint(f'Méthode 1 (formule) : S = n(n+1) = {n}×{n+1} = {S_formule}')\n\n# Méthode 2 : Boucle\nS_boucle = 0\nprint(f'\\nMéthode 2 (boucle) :')\nfor i in range(1, n + 1):\n    nombre_pair = 2 * i\n    S_boucle = S_boucle + nombre_pair\n    print(f'Étape {i} : ajout de {nombre_pair}, S = {S_boucle}')\n\nprint(f'\\nVérification : S_formule = {S_formule}, S_boucle = {S_boucle}')\nif S_formule == S_boucle:\n    print('Les deux méthodes donnent le même résultat ✓')

Explication étape par étape :

Démonstration de la formule :
Somme : $S = 2 + 4 + 6 + ... + 2n$
$S = 2(1 + 2 + 3 + ... + n)$
$S = 2 \\times \\frac{n(n+1)}{2} = n(n+1)$

Exemple pour $n = 5$ :

Méthode 1 (formule) :
$S = n(n+1) = 5 \\times 6 = 30$

Méthode 2 (boucle) :
Étape $1$ : $2 \\times 1 = 2$, $S = 2$
Étape $2$ : $2 \\times 2 = 4$, $S = 2 + 4 = 6$
Étape $3$ : $2 \\times 3 = 6$, $S = 6 + 6 = 12$
Étape $4$ : $2 \\times 4 = 8$, $S = 12 + 8 = 20$
Étape $5$ : $2 \\times 5 = 10$, $S = 20 + 10 = 30$

Résultat : $S = 30$ (les deux méthodes concordent)",
    "id_category": "3",
    "id_number": "26"
  },
  {
    "category": "Exercices corriges en python ",
    "question": "Créer un programme Python qui lit une liste de $n$ nombres entiers et trouve tous les nombres premiers dans cette liste. Un nombre $p$ est premier si $p > 1$ et ses seuls diviseurs sont $1$ et $p$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
# Fonction pour tester si un nombre est premier\ndef est_premier(p):\n    if p < 2:\n        return False\n    for i in range(2, int(p**0.5) + 1):\n        if p % i == 0:\n            return False\n    return True\n\n# Lecture de n\nn = int(input('Entrez le nombre d\\'éléments n : '))\n\n# Lecture de la liste\nliste = []\nfor i in range(n):\n    x = int(input(f'Entrez l\\'élément {i+1} : '))\n    liste.append(x)\n\nprint(f'\\nListe : {liste}')\n\n# Recherche des nombres premiers\npremiers = []\nfor nombre in liste:\n    if est_premier(nombre):\n        premiers.append(nombre)\n        print(f'{nombre} est premier')\n    else:\n        print(f'{nombre} n\\'est pas premier')\n\nprint(f'\\nNombres premiers trouvés : {premiers}')\nprint(f'Nombre total de premiers : {len(premiers)}')

Explication étape par étape :

Test de primalité :
Pour tester si $p$ est premier, on vérifie si $p$ est divisible par un nombre $i$ tel que $2 \\leq i \\leq \\sqrt{p}$

Exemple avec la liste $[2, 8, 13, 15, 17, 20]$ :

$p = 2$ : Premier (aucun diviseur entre $2$ et $\\sqrt{2} \\approx 1.4$)
$p = 8$ : Non premier ($8 = 2 \\times 4$)
$p = 13$ : Premier (testé avec $i = 2, 3$, aucun ne divise $13$)
$p = 15$ : Non premier ($15 = 3 \\times 5$)
$p = 17$ : Premier (testé avec $i = 2, 3, 4$, aucun ne divise $17$)
$p = 20$ : Non premier ($20 = 2 \\times 10$)

Résultat : Nombres premiers = $[2, 13, 17]$",
    "id_category": "3",
    "id_number": "27"
  },
  {
    "category": "Exercices corriges en python ",
    "question": "Écrire un programme Python qui calcule la puissance $x^n$ d'un nombre réel $x$ pour un exposant entier $n$ en utilisant trois méthodes : l'opérateur $**$, une boucle, et la formule récursive.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
# Lecture des valeurs\nx = float(input('Entrez la base x : '))\nn = int(input('Entrez l\\'exposant n : '))\n\n# Méthode 1 : Opérateur **\nresultat1 = x ** n\nprint(f'\\nMéthode 1 (opérateur **) : {x}^{n} = {resultat1}')\n\n# Méthode 2 : Boucle\nresultat2 = 1\nfor i in range(n):\n    resultat2 = resultat2 * x\nprint(f'Méthode 2 (boucle) : {x}^{n} = {resultat2}')\n\n# Méthode 3 : Fonction récursive\ndef puissance(base, exp):\n    if exp == 0:\n        return 1\n    else:\n        return base * puissance(base, exp - 1)\n\nresultat3 = puissance(x, n)\nprint(f'Méthode 3 (récursive) : {x}^{n} = {resultat3}')\n\nprint(f'\\nVérification : tous les résultats sont égaux')

Explication étape par étape :

Exemple avec $x = 2$ et $n = 5$ :

Méthode 1 : Opérateur direct
$2^5 = 32$

Méthode 2 : Boucle itérative
Formule : $x^n = \\underbrace{x \\times x \\times ... \\times x}_{n \\text{ fois}}$
Initialisation : $resultat = 1$
Itération $1$ : $resultat = 1 \\times 2 = 2$
Itération $2$ : $resultat = 2 \\times 2 = 4$
Itération $3$ : $resultat = 4 \\times 2 = 8$
Itération $4$ : $resultat = 8 \\times 2 = 16$
Itération $5$ : $resultat = 16 \\times 2 = 32$

Méthode 3 : Récursive
Formule : $x^n = x \\times x^{n-1}$ avec $x^0 = 1$
$2^5 = 2 \\times 2^4 = 2 \\times 16 = 32$",
    "id_category": "3",
    "id_number": "28"
  },
  {
    "category": "Exercices corriges en python ",
    "question": "Créer un programme Python qui transpose une matrice $A$ de dimension $m \\times n$ pour obtenir $A^T$ de dimension $n \\times m$, où $A^T_{ij} = A_{ji}$. Afficher les deux matrices.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
# Lecture des dimensions\nm = int(input('Entrez le nombre de lignes m : '))\nn = int(input('Entrez le nombre de colonnes n : '))\n\n# Création et saisie de la matrice A\nprint('\\nEntrez les éléments de la matrice A :')\nA = []\nfor i in range(m):\n    ligne = []\n    for j in range(n):\n        valeur = float(input(f'A[{i+1}][{j+1}] = '))\n        ligne.append(valeur)\n    A.append(ligne)\n\nprint('\\nMatrice A (dimensions {}×{}) :'.format(m, n))\nfor ligne in A:\n    print(ligne)\n\n# Calcul de la transposée\nA_T = [[A[i][j] for i in range(m)] for j in range(n)]\n\nprint('\\nMatrice transposée A^T (dimensions {}×{}) :'.format(n, m))\nfor ligne in A_T:\n    print(ligne)

Explication étape par étape :

Définition :
La transposée $A^T$ vérifie : $A^T_{ij} = A_{ji}$

Exemple avec $m=2$, $n=3$ :

Matrice originale $A$ :
$A = \\begin{pmatrix} 1 & 2 & 3 \\\\ 4 & 5 & 6 \\end{pmatrix}$
Dimensions : $2 \\times 3$

Construction de $A^T$ :
$A^T_{11} = A_{11} = 1$
$A^T_{12} = A_{21} = 4$
$A^T_{21} = A_{12} = 2$
$A^T_{22} = A_{22} = 5$
$A^T_{31} = A_{13} = 3$
$A^T_{32} = A_{23} = 6$

Matrice transposée $A^T$ :
$A^T = \\begin{pmatrix} 1 & 4 \\\\ 2 & 5 \\\\ 3 & 6 \\end{pmatrix}$
Dimensions : $3 \\times 2$",
    "id_category": "3",
    "id_number": "29"
  },
  {
    "category": "Exercices corriges en python ",
    "question": "Écrire un programme Python qui calcule les $n$ premiers termes de la suite de Fibonacci $F_0 = 0$, $F_1 = 1$, $F_n = F_{n-1} + F_{n-2}$ et affiche le rapport $r_n = \\frac{F_n}{F_{n-1}}$ qui tend vers le nombre d'or $\\phi = \\frac{1 + \\sqrt{5}}{2}$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
import math\n\n# Lecture de n\nn = int(input('Entrez le nombre de termes n : '))\n\n# Calcul du nombre d'or\nphi = (1 + math.sqrt(5)) / 2\nprint(f'Nombre d\\'or φ = {phi:.6f}\\n')\n\n# Initialisation\nif n >= 1:\n    F = [0, 1]  # F_0 = 0, F_1 = 1\n    print(f'F_0 = 0')\n    print(f'F_1 = 1')\n    \n    # Calcul des termes suivants\n    for i in range(2, n):\n        F_i = F[i-1] + F[i-2]\n        F.append(F_i)\n        \n        # Calcul du rapport\n        rapport = F[i] / F[i-1]\n        difference = abs(rapport - phi)\n        \n        print(f'F_{i} = F_{i-1} + F_{i-2} = {F[i-1]} + {F[i-2]} = {F_i}')\n        print(f'  Rapport r_{i} = F_{i}/F_{i-1} = {F_i}/{F[i-1]} = {rapport:.6f}')\n        print(f'  Différence avec φ : {difference:.6f}\\n')

Explication étape par étape :

Formule récurrente :
$F_n = F_{n-1} + F_{n-2}$ avec $F_0 = 0$, $F_1 = 1$

Nombre d'or :
$\\phi = \\frac{1 + \\sqrt{5}}{2} \\approx 1.618034$

Exemple pour $n = 8$ :

$F_0 = 0$
$F_1 = 1$
$F_2 = F_1 + F_0 = 1 + 0 = 1$, $r_2 = \\frac{1}{1} = 1.000000$
$F_3 = F_2 + F_1 = 1 + 1 = 2$, $r_3 = \\frac{2}{1} = 2.000000$
$F_4 = F_3 + F_2 = 2 + 1 = 3$, $r_4 = \\frac{3}{2} = 1.500000$
$F_5 = F_4 + F_3 = 3 + 2 = 5$, $r_5 = \\frac{5}{3} = 1.666667$
$F_6 = F_5 + F_4 = 5 + 3 = 8$, $r_6 = \\frac{8}{5} = 1.600000$
$F_7 = F_6 + F_5 = 8 + 5 = 13$, $r_7 = \\frac{13}{8} = 1.625000$

On observe que $r_n \\to \\phi$ quand $n \\to \\infty$",
    "id_category": "3",
    "id_number": "30"
  },
  {
    "category": "Exercices corriges en python ",
    "question": "Créer un programme Python qui lit deux matrices carrées $A$ et $B$ de dimension $n \\times n$ et calcule leur produit matriciel $C = A \\times B$ où $C_{ij} = \\sum_{k=1}^{n} A_{ik} B_{kj}$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
# Lecture de la dimension\nn = int(input('Entrez la dimension n : '))\n\n# Lecture de la matrice A\nprint('\\nEntrez les éléments de la matrice A :')\nA = [[float(input(f'A[{i+1}][{j+1}] = ')) for j in range(n)] for i in range(n)]\n\n# Lecture de la matrice B\nprint('\\nEntrez les éléments de la matrice B :')\nB = [[float(input(f'B[{i+1}][{j+1}] = ')) for j in range(n)] for i in range(n)]\n\nprint('\\nMatrice A :')\nfor ligne in A:\n    print(ligne)\n\nprint('\\nMatrice B :')\nfor ligne in B:\n    print(ligne)\n\n# Calcul du produit C = A × B\nC = [[0 for j in range(n)] for i in range(n)]\n\nfor i in range(n):\n    for j in range(n):\n        for k in range(n):\n            C[i][j] = C[i][j] + A[i][k] * B[k][j]\n\nprint('\\nMatrice produit C = A × B :')\nfor ligne in C:\n    print(ligne)

Explication étape par étape :

Formule du produit matriciel :
$C_{ij} = \\sum_{k=1}^{n} A_{ik} B_{kj}$

Exemple avec $n=2$ :
$A = \\begin{pmatrix} 1 & 2 \\\\ 3 & 4 \\end{pmatrix}, \\quad B = \\begin{pmatrix} 5 & 6 \\\\ 7 & 8 \\end{pmatrix}$

Calcul de $C_{11}$ :
$C_{11} = \\sum_{k=1}^{2} A_{1k} B_{k1} = A_{11}B_{11} + A_{12}B_{21}$
$= (1)(5) + (2)(7) = 5 + 14 = 19$

Calcul de $C_{12}$ :
$C_{12} = A_{11}B_{12} + A_{12}B_{22} = (1)(6) + (2)(8) = 6 + 16 = 22$

Calcul de $C_{21}$ :
$C_{21} = A_{21}B_{11} + A_{22}B_{21} = (3)(5) + (4)(7) = 15 + 28 = 43$

Calcul de $C_{22}$ :
$C_{22} = A_{21}B_{12} + A_{22}B_{22} = (3)(6) + (4)(8) = 18 + 32 = 50$

Résultat :
$C = \\begin{pmatrix} 19 & 22 \\\\ 43 & 50 \\end{pmatrix}$",
    "id_category": "3",
    "id_number": "31"
  },
  {
    "category": "Exercices corriges en python ",
    "question": "Écrire un programme Python qui calcule la somme alternée $S_n = 1 - \\frac{1}{2} + \\frac{1}{3} - \\frac{1}{4} + ... + (-1)^{n+1}\\frac{1}{n}$ des $n$ premiers termes, qui converge vers $\\ln(2)$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
import math\n\n# Lecture de n\nn = int(input('Entrez le nombre de termes n : '))\n\n# Valeur de référence\nln2 = math.log(2)\nprint(f'Valeur de ln(2) = {ln2:.6f}\\n')\n\n# Calcul de la somme alternée\nS = 0\n\nfor i in range(1, n + 1):\n    # Calcul du signe : (-1)^(i+1)\n    signe = (-1) ** (i + 1)\n    \n    # Calcul du terme\n    terme = signe / i\n    \n    # Ajout à la somme\n    S = S + terme\n    \n    print(f'Terme {i} : signe = {signe:+d}, terme = {terme:+.6f}, S_{i} = {S:.6f}')\n\nprint(f'\\nSomme finale S_{n} = {S:.6f}')\nprint(f'Différence avec ln(2) : {abs(S - ln2):.6f}')

Explication étape par étape :

Formule générale :
$S_n = \\sum_{i=1}^{n} \\frac{(-1)^{i+1}}{i}$

Valeur de convergence :
$\\lim_{n \\to \\infty} S_n = \\ln(2) \\approx 0.693147$

Exemple pour $n = 6$ :

Terme $1$ : $(-1)^{1+1} = (-1)^2 = +1$, terme = $+\\frac{1}{1} = +1.000000$, $S_1 = 1.000000$

Terme $2$ : $(-1)^{2+1} = (-1)^3 = -1$, terme = $-\\frac{1}{2} = -0.500000$, $S_2 = 0.500000$

Terme $3$ : $(-1)^{3+1} = (-1)^4 = +1$, terme = $+\\frac{1}{3} = +0.333333$, $S_3 = 0.833333$

Terme $4$ : terme = $-\\frac{1}{4} = -0.250000$, $S_4 = 0.583333$

Terme $5$ : terme = $+\\frac{1}{5} = +0.200000$, $S_5 = 0.783333$

Terme $6$ : terme = $-\\frac{1}{6} = -0.166667$, $S_6 = 0.616667$

Plus $n$ est grand, plus $S_n$ se rapproche de $\\ln(2)$",
    "id_category": "3",
    "id_number": "32"
  },
  {
    "category": "Exercices corriges en python ",
    "question": "Créer un programme Python qui trie une liste de $n$ nombres en ordre croissant en utilisant l'algorithme du tri par sélection. À chaque étape, afficher la position du minimum et l'état de la liste.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
# Lecture de n\nn = int(input('Entrez le nombre d\\'éléments n : '))\n\n# Lecture de la liste\nliste = []\nfor i in range(n):\n    x = float(input(f'Entrez l\\'élément {i+1} : '))\n    liste.append(x)\n\nprint(f'\\nListe initiale : {liste}')\nprint('\\nTri par sélection :\\n')\n\n# Tri par sélection\nfor i in range(n - 1):\n    # Recherche du minimum dans liste[i:n]\n    indice_min = i\n    for j in range(i + 1, n):\n        if liste[j] < liste[indice_min]:\n            indice_min = j\n    \n    print(f'Étape {i+1} :')\n    print(f'  Zone non triée : {liste[i:]}')\n    print(f'  Minimum trouvé : {liste[indice_min]} à l\\'indice {indice_min}')\n    \n    # Échange\n    liste[i], liste[indice_min] = liste[indice_min], liste[i]\n    \n    print(f'  Après échange : {liste}\\n')\n\nprint(f'Liste triée finale : {liste}')

Explication étape par étape :

Principe du tri par sélection :
À l'étape $i$, on cherche le minimum dans $liste[i:n]$ et on l'échange avec $liste[i]$

Exemple avec $[64, 25, 12, 22, 11]$ :

Étape $1$ :
Zone non triée : $[64, 25, 12, 22, 11]$
Minimum = $11$ (indice $4$)
Échange $liste[0]$ et $liste[4]$ : $[11, 25, 12, 22, 64]$

Étape $2$ :
Zone non triée : $[25, 12, 22, 64]$
Minimum = $12$ (indice $2$)
Échange $liste[1]$ et $liste[2]$ : $[11, 12, 25, 22, 64]$

Étape $3$ :
Zone non triée : $[25, 22, 64]$
Minimum = $22$ (indice $3$)
Échange $liste[2]$ et $liste[3]$ : $[11, 12, 22, 25, 64]$

Étape $4$ :
Zone non triée : $[25, 64]$
Minimum = $25$ (indice $3$)
Pas d'échange : $[11, 12, 22, 25, 64]$

Complexité : $O(n^2)$",
    "id_category": "3",
    "id_number": "33"
  },
  {
    "category": "Exercices corriges en python ",
    "question": "Écrire un programme Python qui calcule l'approximation de $\\pi$ en utilisant la série de Leibniz : $\\frac{\\pi}{4} = 1 - \\frac{1}{3} + \\frac{1}{5} - \\frac{1}{7} + ...$ pour $n$ termes. Afficher l'erreur relative $\\epsilon = \\frac{|\\pi_{approx} - \\pi|}{\\pi} \\times 100\\%$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
import math\n\n# Lecture de n\nn = int(input('Entrez le nombre de termes n : '))\n\n# Valeur exacte de π\npi_exact = math.pi\nprint(f'Valeur exacte de π = {pi_exact:.10f}\\n')\n\n# Calcul de π/4 avec la série de Leibniz\nsomme = 0\n\nfor i in range(n):\n    # Dénominateur : 2i + 1\n    denominateur = 2 * i + 1\n    \n    # Signe : (-1)^i\n    signe = (-1) ** i\n    \n    # Terme de la série\n    terme = signe / denominateur\n    \n    # Ajout à la somme\n    somme = somme + terme\n    \n    # Calcul de π approximé\n    pi_approx = 4 * somme\n    \n    # Erreur relative\n    erreur = abs(pi_approx - pi_exact) / pi_exact * 100\n    \n    if (i + 1) % 100 == 0 or i < 10:\n        print(f'n={i+1:5d} : π ≈ {pi_approx:.10f}, erreur = {erreur:.6f}%')\n\nprint(f'\\nApproximation finale avec {n} termes : π ≈ {pi_approx:.10f}')\nprint(f'Erreur relative finale : {erreur:.6f}%')

Explication étape par étape :

Formule de Leibniz :
$\\frac{\\pi}{4} = \\sum_{i=0}^{\\infty} \\frac{(-1)^i}{2i+1}$
Donc : $\\pi = 4 \\sum_{i=0}^{\\infty} \\frac{(-1)^i}{2i+1}$

Développement des premiers termes :

Terme $i=0$ : $\\frac{(-1)^0}{2(0)+1} = \\frac{1}{1} = 1$
Somme partielle : $\\frac{\\pi}{4} \\approx 1$, donc $\\pi \\approx 4$

Terme $i=1$ : $\\frac{(-1)^1}{2(1)+1} = -\\frac{1}{3}$
Somme partielle : $1 - \\frac{1}{3} = \\frac{2}{3}$, donc $\\pi \\approx 4 \\times \\frac{2}{3} = 2.667$

Terme $i=2$ : $\\frac{(-1)^2}{2(2)+1} = \\frac{1}{5}$
Somme partielle : $\\frac{2}{3} + \\frac{1}{5} = \\frac{13}{15}$, donc $\\pi \\approx 4 \\times \\frac{13}{15} = 3.467$

Convergence :
Plus $n$ augmente, plus $\\pi_{approx}$ se rapproche de $\\pi = 3.14159265...$
Pour $n=1000$ : erreur $\\approx 0.03\\%$",
    "id_category": "3",
    "id_number": "34"
  },
  {
    "category": "Exercices corriges en python ",
    "question": "Créer un programme Python qui calcule le déterminant d'une matrice $2 \\times 2$ : $\\det(A) = A_{11}A_{22} - A_{12}A_{21}$ et d'une matrice $3 \\times 3$ en utilisant la règle de Sarrus.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
# Choix de la dimension\nprint('Calcul de déterminant')\nprint('1 - Matrice 2×2')\nprint('2 - Matrice 3×3')\nchoix = int(input('Votre choix : '))\n\nif choix == 1:\n    # Matrice 2×2\n    print('\\nEntrez les éléments de la matrice 2×2 :')\n    A = [[float(input(f'A[{i+1}][{j+1}] = ')) for j in range(2)] for i in range(2)]\n    \n    print('\\nMatrice A :')\n    for ligne in A:\n        print(ligne)\n    \n    # Calcul du déterminant\n    det = A[0][0] * A[1][1] - A[0][1] * A[1][0]\n    \n    print(f'\\nCalcul : det(A) = A₁₁×A₂₂ - A₁₂×A₂₁')\n    print(f'       = {A[0][0]}×{A[1][1]} - {A[0][1]}×{A[1][0]}')\n    print(f'       = {A[0][0] * A[1][1]} - {A[0][1] * A[1][0]}')\n    print(f'       = {det}')\n\nelif choix == 2:\n    # Matrice 3×3\n    print('\\nEntrez les éléments de la matrice 3×3 :')\n    A = [[float(input(f'A[{i+1}][{j+1}] = ')) for j in range(3)] for i in range(3)]\n    \n    print('\\nMatrice A :')\n    for ligne in A:\n        print(ligne)\n    \n    # Règle de Sarrus\n    det = (A[0][0]*A[1][1]*A[2][2] + A[0][1]*A[1][2]*A[2][0] + A[0][2]*A[1][0]*A[2][1]\n           - A[0][2]*A[1][1]*A[2][0] - A[0][1]*A[1][0]*A[2][2] - A[0][0]*A[1][2]*A[2][1])\n    \n    print(f'\\nRègle de Sarrus :')\n    print(f'det(A) = A₁₁A₂₂A₃₃ + A₁₂A₂₃A₃₁ + A₁₃A₂₁A₃₂')\n    print(f'       - A₁₃A₂₂A₃₁ - A₁₂A₂₁A₃₃ - A₁₁A₂₃A₃₂')\n    print(f'       = {det}')

Explication étape par étape :

Cas $2 \\times 2$ :
Pour $A = \\begin{pmatrix} 3 & 5 \\\\ 2 & 4 \\end{pmatrix}$

Formule : $\\det(A) = A_{11}A_{22} - A_{12}A_{21}$
$= (3)(4) - (5)(2)$
$= 12 - 10 = 2$

Cas $3 \\times 3$ (Règle de Sarrus) :
Pour $A = \\begin{pmatrix} 1 & 2 & 3 \\\\ 4 & 5 & 6 \\\\ 7 & 8 & 9 \\end{pmatrix}$

Termes positifs :
$A_{11}A_{22}A_{33} = (1)(5)(9) = 45$
$A_{12}A_{23}A_{31} = (2)(6)(7) = 84$
$A_{13}A_{21}A_{32} = (3)(4)(8) = 96$
Somme = $45 + 84 + 96 = 225$

Termes négatifs :
$A_{13}A_{22}A_{31} = (3)(5)(7) = 105$
$A_{12}A_{21}A_{33} = (2)(4)(9) = 72$
$A_{11}A_{23}A_{32} = (1)(6)(8) = 48$
Somme = $105 + 72 + 48 = 225$

$\\det(A) = 225 - 225 = 0$",
    "id_category": "3",
    "id_number": "35"
  },
  {
    "category": "Exercices corriges en python ",
    "question": "Écrire un programme Python qui calcule l'intégrale numérique de la fonction $f(x) = x^2$ sur l'intervalle $[a, b]$ en utilisant la méthode des rectangles avec $n$ subdivisions. Comparer avec la valeur exacte $I = \\frac{b^3 - a^3}{3}$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
# Définition de la fonction\ndef f(x):\n    return x**2\n\n# Lecture des paramètres\na = float(input('Entrez la borne inférieure a : '))\nb = float(input('Entrez la borne supérieure b : '))\nn = int(input('Entrez le nombre de subdivisions n : '))\n\n# Calcul de la largeur de chaque rectangle\nh = (b - a) / n\nprint(f'\\nLargeur de chaque subdivision h = (b-a)/n = ({b}-{a})/{n} = {h}')\n\n# Méthode des rectangles (point milieu)\nintegrale_approx = 0\n\nprint('\\nCalcul des aires des rectangles :')\nfor i in range(n):\n    # Point milieu de l'intervalle [xi, xi+1]\n    x_milieu = a + (i + 0.5) * h\n    \n    # Aire du rectangle\n    aire = h * f(x_milieu)\n    integrale_approx = integrale_approx + aire\n    \n    if i < 5 or i >= n - 2:  # Afficher premiers et derniers\n        print(f'Rectangle {i+1} : x = {x_milieu:.4f}, f(x) = {f(x_milieu):.4f}, aire = {aire:.6f}')\n    elif i == 5:\n        print('...')\n\nprint(f'\\nIntégrale approximée : I ≈ {integrale_approx:.6f}')\n\n# Calcul de la valeur exacte\nintegrale_exacte = (b**3 - a**3) / 3\nprint(f'\\nValeur exacte : I = (b³-a³)/3 = ({b}³-{a}³)/3 = {integrale_exacte:.6f}')\n\n# Erreur\nerreur = abs(integrale_approx - integrale_exacte)\nerreur_relative = erreur / integrale_exacte * 100\nprint(f'\\nErreur absolue : {erreur:.6f}')\nprint(f'Erreur relative : {erreur_relative:.4f}%')

Explication étape par étape :

Méthode des rectangles :
On divise $[a,b]$ en $n$ intervalles de largeur $h = \\frac{b-a}{n}$
Intégrale : $I \\approx \\sum_{i=0}^{n-1} h \\cdot f(x_i)$ où $x_i$ est le point milieu

Exemple avec $a=0$, $b=2$, $n=4$ :

Largeur : $h = \\frac{2-0}{4} = 0.5$

Rectangle $1$ : $x_1 = 0.25$, $f(0.25) = 0.0625$, aire = $0.5 \\times 0.0625 = 0.03125$
Rectangle $2$ : $x_2 = 0.75$, $f(0.75) = 0.5625$, aire = $0.5 \\times 0.5625 = 0.28125$
Rectangle $3$ : $x_3 = 1.25$, $f(1.25) = 1.5625$, aire = $0.5 \\times 1.5625 = 0.78125$
Rectangle $4$ : $x_4 = 1.75$, $f(1.75) = 3.0625$, aire = $0.5 \\times 3.0625 = 1.53125$

Somme approximée : $I \\approx 2.625$

Valeur exacte : $I = \\frac{2^3 - 0^3}{3} = \\frac{8}{3} \\approx 2.6667$

Erreur relative : $\\approx 1.56\\%$",
    "id_category": "3",
    "id_number": "36"
  },
  {
    "category": "Exercices corriges en python ",
    "question": "Créer un programme Python qui convertit un nombre décimal $n$ en binaire, octal et hexadécimal. Afficher également la représentation en puissances de $2$ pour la conversion binaire.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
# Lecture du nombre décimal\nn = int(input('Entrez un nombre décimal n : '))\n\nprint(f'\\nNombre décimal : {n}')\nprint()\n\n# Conversion en binaire\nbinaire = bin(n)[2:]  # [2:] pour enlever le préfixe '0b'\nprint(f'Binaire : {binaire}')\n\n# Représentation en puissances de 2\nprint('\\nDécomposition en puissances de 2 :')\ntemp = n\npuissances = []\ni = 0\nwhile temp > 0:\n    if temp % 2 == 1:\n        puissances.append(i)\n        print(f'  2^{i} = {2**i}')\n    temp = temp // 2\n    i = i + 1\n\nsomme_str = ' + '.join([f'2^{p}' for p in reversed(puissances)])\nprint(f'\\n{n} = {somme_str}')\n\n# Conversion en octal\noctal = oct(n)[2:]  # [2:] pour enlever le préfixe '0o'\nprint(f'\\nOctal : {octal}')\n\n# Conversion en hexadécimal\nhexadecimal = hex(n)[2:].upper()  # [2:] pour enlever '0x', upper() pour majuscules\nprint(f'Hexadécimal : {hexadecimal}')\n\n# Vérification\nprint('\\nVérification :')\nprint(f'  Binaire {binaire} → décimal : {int(binaire, 2)}')\nprint(f'  Octal {octal} → décimal : {int(octal, 8)}')\nprint(f'  Hexa {hexadecimal} → décimal : {int(hexadecimal, 16)}')

Explication étape par étape :

Exemple avec $n = 45$ :

Conversion binaire :
Division successive par $2$ :
$45 \\div 2 = 22$ reste $1$
$22 \\div 2 = 11$ reste $0$
$11 \\div 2 = 5$ reste $1$
$5 \\div 2 = 2$ reste $1$
$2 \\div 2 = 1$ reste $0$
$1 \\div 2 = 0$ reste $1$

Binaire (en lisant de bas en haut) : $101101$

Puissances de $2$ :
$45 = 32 + 8 + 4 + 1 = 2^5 + 2^3 + 2^2 + 2^0$

Conversion octale :
$45 = 5 \\times 8^1 + 5 \\times 8^0 = 55_8$

Conversion hexadécimale :
$45 = 2 \\times 16^1 + 13 \\times 16^0 = 2D_{16}$ ($D = 13$ en hexa)",
    "id_category": "3",
    "id_number": "37"
  },
  {
    "category": "Exercices corriges en python ",
    "question": "Écrire un programme Python qui résout un système d'équations linéaires $2 \\times 2$ : $\\begin{cases} a_1x + b_1y = c_1 \\\\ a_2x + b_2y = c_2 \\end{cases}$ en utilisant la méthode de Cramer avec les déterminants $\\Delta$, $\\Delta_x$ et $\\Delta_y$.",
    "choices": [
      "A Corrige Type"
    ],
    "correct": [
      "A"
    ],
    "explanation": "Solution complète :

Code Python :
# Lecture des coefficients\nprint('Système d\\'équations linéaires 2×2 :')\nprint('  a₁x + b₁y = c₁')\nprint('  a₂x + b₂y = c₂\\n')\n\na1 = float(input('Entrez a₁ : '))\nb1 = float(input('Entrez b₁ : '))\nc1 = float(input('Entrez c₁ : '))\n\na2 = float(input('Entrez a₂ : '))\nb2 = float(input('Entrez b₂ : '))\nc2 = float(input('Entrez c₂ : '))\n\nprint(f'\\nSystème à résoudre :')\nprint(f'  {a1}x + {b1}y = {c1}')\nprint(f'  {a2}x + {b2}y = {c2}')\n\n# Calcul du déterminant principal\nDelta = a1 * b2 - a2 * b1\nprint(f'\\nDéterminant principal Δ :')\nprint(f'  Δ = a₁b₂ - a₂b₁')\nprint(f'    = ({a1})({b2}) - ({a2})({b1})')\nprint(f'    = {a1*b2} - {a2*b1}')\nprint(f'    = {Delta}')\n\nif Delta == 0:\n    print('\\nΔ = 0 : le système n\\'a pas de solution unique')\nelse:\n    # Calcul de Δx\n    Delta_x = c1 * b2 - c2 * b1\n    print(f'\\nDéterminant Δₓ :')\n    print(f'  Δₓ = c₁b₂ - c₂b₁')\n    print(f'     = ({c1})({b2}) - ({c2})({b1})')\n    print(f'     = {c1*b2} - {c2*b1}')\n    print(f'     = {Delta_x}')\n    \n    # Calcul de Δy\n    Delta_y = a1 * c2 - a2 * c1\n    print(f'\\nDéterminant Δᵧ :')\n    print(f'  Δᵧ = a₁c₂ - a₂c₁')\n    print(f'     = ({a1})({c2}) - ({a2})({c1})')\n    print(f'     = {a1*c2} - {a2*c1}')\n    print(f'     = {Delta_y}')\n    \n    # Solutions\n    x = Delta_x / Delta\n    y = Delta_y / Delta\n    \n    print(f'\\nSolutions (méthode de Cramer) :')\n    print(f'  x = Δₓ/Δ = {Delta_x}/{Delta} = {x}')\n    print(f'  y = Δᵧ/Δ = {Delta_y}/{Delta} = {y}')\n    \n    # Vérification\n    print(f'\\nVérification :')\n    verif1 = a1*x + b1*y\n    verif2 = a2*x + b2*y\n    print(f'  {a1}({x}) + {b1}({y}) = {verif1} ≈ {c1}')\n    print(f'  {a2}({x}) + {b2}({y}) = {verif2} ≈ {c2}')

Explication étape par étape :

Méthode de Cramer :
Pour le système $\\begin{cases} a_1x + b_1y = c_1 \\\\ a_2x + b_2y = c_2 \\end{cases}$

Déterminants :
$\\Delta = \\begin{vmatrix} a_1 & b_1 \\\\ a_2 & b_2 \\end{vmatrix} = a_1b_2 - a_2b_1$

$\\Delta_x = \\begin{vmatrix} c_1 & b_1 \\\\ c_2 & b_2 \\end{vmatrix} = c_1b_2 - c_2b_1$

$\\Delta_y = \\begin{vmatrix} a_1 & c_1 \\\\ a_2 & c_2 \\end{vmatrix} = a_1c_2 - a_2c_1$

Solutions :
$x = \\frac{\\Delta_x}{\\Delta}, \\quad y = \\frac{\\Delta_y}{\\Delta}$

Exemple avec $\\begin{cases} 2x + 3y = 8 \\\\ 4x - y = 2 \\end{cases}$ :

$\\Delta = (2)(-1) - (4)(3) = -2 - 12 = -14$
$\\Delta_x = (8)(-1) - (2)(3) = -8 - 6 = -14$
$\\Delta_y = (2)(2) - (4)(8) = 4 - 32 = -28$

$x = \\frac{-14}{-14} = 1$
$y = \\frac{-28}{-14} = 2$",
    "id_category": "3",
    "id_number": "38"
  }
]