1. ( ) parenthèses
2. not / non
3. *, /, div, mod, and
4. +, -, or
5. =, <>, <, >, <=, >=

• a div b = quotient de la division entière
• a mod b = reste de la division entière
• Exemple : 17 div 5 = 3 et 17 mod 5 = 2.

// pour la division entière, % pour le modulo. 12 // 5 = 2 et 12 % 5 = 2. ⚠️ / en Python est toujours division réelle : 12 / 5 = 2.4.

not (3 > 5) = not faux = vrai Puis vrai and (2 < 4) = vrai and vrai = vrai.

• Pascal : <> (ex : if x <> 0 then)
• Python : != (ex : if x != 0:)
• Analyse : ≠ ou <>

Pascal n'a pas d'opérateur de puissance natif. Solutions : - Fonction Power(2, 10) (unité Math) - Formule exp(10 * ln(2))

En Python : 2 ** 10 directement.

Booléen (bool) : vrai ou faux (True / False).

// — exemple : 7 // 2 = 3

mod — exemple : 7 mod 2 = 1

1. ( ) — parenthèses
2. * — multiplication / division
3. + — addition / soustraction
4. and — ET logique

faux — car 3 < 5 est vrai, donc not vrai = faux.

<> — par exemple if x <> 0 then ...

Non. On utilise : - la fonction Power(base, exposant) (unité Math), ou - la formule exp(exposant * ln(base)).

2.4 (division réelle). Pour la division entière, utiliser //.

Toute donnée pouvant prendre différentes valeurs tout le long d'un algorithme ou d'un programme.

Caractérisée par : son nom, son type, son contenu.

Toute donnée dont on décide de garder la valeur inchangée tout le long d'un algorithme ou d'un programme.

← (flèche gauche)

:=

Non. Bac, BAC et bac désignent la même variable.

Non — un identificateur ne peut pas comporter le signe + (ni d'autres opérateurs, ni d'espaces).

1. Commencer par une lettre (ou _).
2. Seulement lettres, chiffres et _.
3. Pas d'accents, pas d'espaces, pas d'opérateurs.

réel (nombre à virgule)

`` x ← x + y y ← x - y x ← x - y `` Fonctionne uniquement pour des nombres.

Tableau de Déclaration des Objets — utilisé en Analyse pour lister tous les objets (variables et constantes) d'un algorithme, avec leur type/nature.

if condition then
    instruction;
```
Pour plusieurs instructions :
```pascal
if condition then
begin
    instr1;
    instr2;
end;

• Simple Si C Alors A FinSi : exécute A uniquement si C est vraie.
• Alternative Si C Alors A Sinon B FinSi : exécute A si vrai, B si faux.

Un type ordinal : entier, caractère, booléen, énuméré. ⚠️ Les réels et chaînes sont interdits — utiliser Si ... Sinon Si ... à la place.

Si C1 et C2 Alors A FinSi

Les deux conditions doivent être vraies → on utilise l'opérateur et (and). Plus lisible que l'imbriqué.

``python if condition1: # ... elif condition2: # ... else: # ... ` Python utilise elif (contraction de else if`).

En algorithme : max ← a puis Si b > a Alors max ← b. En Python (one-liner) : max = a if a > b else b En Pascal : pas d'opérateur ternaire — utiliser if.

Quand le nombre d'itérations est connu d'avance (parcours d'un tableau, compteur fixe). Si la fin dépend d'une condition, préférer Tant que ou Répéter.

• `Tant que C Faire ...` : test avant chaque tour → peut ne jamais s'exécuter.
• `Répéter ... Jusqu'à C` : test après chaque tour → s'exécute au moins une fois.

Pour valider une saisie utilisateur : Répéter est préférable.

for i := 1 to n do
    // instruction
```
Pour parcours **décroissant** :
```pascal
for i := n downto 1 do
    // instruction

Les entiers 1, 2, 3, 4, 5 (borne supérieure exclue).

Pour les entiers de 1 à n inclus : range(1, n + 1). Pour les entiers de 0 à n-1 : range(n).

while condition:
    # bloc indenté
```
Python n'a **pas** de `do ... while` (équivalent de `Répéter`). On simule avec :
```python
while True:
    # ...
    if condition_sortie:
        break

La variable testée dans la condition n'est jamais modifiée dans le corps de la boucle.

Exemple buggué : `` i ← 1 Tant que i ≤ 10 Faire Ecrire(i) FinTantque ` → manque i ← i + 1`.

`` s ← 0 ← initialisation Pour i de 1 à n Faire s ← s + T[i] ← accumulation FinPour ` Variations : produit (init=1, s ← s * T[i]), compteur conditionnel (init=0, Si ... Alors cpt ← cpt + 1`).

• `break` : sort immédiatement de la boucle (passe à ce qui suit la boucle).
• `continue` : passe à l'itération suivante sans exécuter le reste du corps.

Les deux n'affectent que la boucle la plus interne.

Pascal : ``pascal var T : array[1..10] of integer; ``

Python (liste) : ``python T = [0] * 10 ``

NumPy : ``python from numpy import array T = array([0] * 10) ``

• Pascal : bornes définies à la déclaration (souvent [1..n]).
• Premier élément : T[1].
• Python : toujours 0-indexé. Premier élément : T[0].
• Dernier élément : T[-1] (indexation négative).

`` s ← 0 ← initialisation à 0 Pour i de 1 à n Faire s ← s + T[i] ← accumulation FinPour ` En Python : sum(T)` (raccourci).

Mauvaise pratique : max ← 0 (échoue si tous les éléments < 0).

Bonne pratique : max ← T[1], puis comparer avec les suivants.

max ← T[1]
Pour i de 2 à n Faire
   Si T[i] > max Alors max ← T[i] FinSi
FinPour

`` i ← 1 Tant que (i ≤ n) et (T[i] ≠ v) Faire i ← i + 1 FinTantque Si i ≤ n Alors trouvé en position i Sinon absent ` Deux cas de sortie possibles : i > n (absent) ou T[i] = v` (trouvé).

T[i] ← T[i] + T[j]
T[j] ← T[i] - T[j]
T[i] ← T[i] - T[j]
```
⚠️ Fonctionne uniquement pour des **nombres**, risque d'overflow.
Préférer la version avec variable temp :
```
tmp ← T[i]
T[i] ← T[j]
T[j] ← tmp

`` cpt ← 0 Pour i de 1 à n Faire Si <condition sur T[i]> Alors cpt ← cpt + 1 FinSi FinPour ` Exemple : compter les pairs → Si T[i] mod 2 = 0. En Python : sum(1 for x in T if condition(x)) ou len([x for x in T if condition(x)])`.

`` existe ← faux Pour i de 1 à n Faire Si T[i] = v Alors existe ← vrai FinSi FinPour ` Plus rapide avec arrêt anticipé (Tant que`).

En Python : v in T (raccourci très lisible).

• Fonction : retourne une valeur explicite (via return en Python,
• ou assignation au nom de la fonction en Pascal).
• Procédure : ne retourne rien explicitement. Peut modifier ses
• paramètres passés par variable (@ / var).

Le sous-programme reçoit une copie du paramètre. Toute modification à l'intérieur n'affecte pas la variable d'appel. C'est le mode par défaut, sûr mais ne permet pas de retourner plusieurs valeurs.

Le sous-programme reçoit une référence vers la variable d'appel. Toute modification se répercute dans l'environnement appelant. Utilisé pour les procédures qui retournent plusieurs valeurs ou pour économiser des copies (grands tableaux).

function NOM(p1: type1; p2: type2): type_retour;
var
    // variables locales
begin
    // ...
    NOM := valeur;   // affecter le résultat au nom de la fonction
end;

``pascal procedure NOM(var a: integer; b: integer); begin a := a + b; end; ` a est passé par variable (var), b` par valeur.

``python def nom(p1, p2): # corps return valeur ` Sans return explicite, la fonction retourne None` (équivalent procédure).

Une variable déclarée à l'intérieur du sous-programme. Elle : - existe uniquement pendant l'exécution du sous-programme - n'est pas accessible depuis l'extérieur - est détruite quand le sous-programme se termine

→ principe d'encapsulation.

1. Réutilisation : on appelle le même code à plusieurs endroits
2. Lisibilité : un bon nom de fonction documente l'intention
3. Maintenance : on corrige un bug à un seul endroit

C'est le fondement de la programmation modulaire.

Un sous-programme qui s'appelle lui-même.

Exemple — factorielle : ``python def fact(n): if n <= 1: return 1 return n * fact(n - 1) `` Toute récursion doit avoir un cas de base (sinon boucle infinie / stack overflow).

Choisir une fonction quand le sous-programme calcule une seule valeur qu'on souhaite utiliser dans une expression (ex : y ← FN cube(x) + 2).

Choisir une procédure quand on doit retourner plusieurs valeurs (via var) ou simplement effectuer une action (affichage, saisie).

À chaque tour : 1. Chercher le minimum des éléments restants 2. L'échanger avec le 1er élément non encore placé

Et recommencer sur le reste du tableau.

Complexité : O(n²) — toujours, même si déjà trié.

Parcourir le tableau et comparer chaque paire d'éléments adjacents. Si T[i] > T[i+1], les échanger. Les plus grands "remontent" comme des bulles.

Répéter jusqu'à ce qu'aucun échange n'ait été fait (tableau trié).

Complexité : O(n²) au pire, O(n) si déjà trié (avec détection).

Pour chaque élément du tableau (de gauche à droite) : - Le comparer aux précédents dans la partie déjà triée - L'insérer à sa bonne place en décalant les autres

Très efficace sur un tableau presque trié — comme trier des cartes à la main.

Complexité : O(n²) au pire, O(n) si déjà trié.

Tous en O(n²) — environ n(n-1)/2 comparaisons.

Pour de gros tableaux, on préfère : - Tri rapide (quicksort) : O(n log n) en moyenne - Tri fusion (mergesort) : O(n log n) garanti

Le tri par insertion, qui fait peu de déplacements car la plupart des éléments sont déjà à leur place.

Tri à bulles avec détection d'échange ≈ équivalent.

Tri par sélection : pas d'avantage (toujours n(n-1)/2 comparaisons).

Parcourir le tableau élément par élément jusqu'à trouver la valeur (ou la fin).

• Complexité : O(n) au pire (parcours complet)
• Fonctionne sur n'importe quel tableau (trié ou non)
• Simple à implémenter

Prérequis : tableau trié.

Principe : comparer la valeur à l'élément du milieu : - si égale → trouvé - si plus petite → chercher dans la moitié gauche - si plus grande → chercher dans la moitié droite

Complexité : O(log n) — pour 1 000 éléments, ~10 comparaisons.

a ← 1, b ← n
Tant que a ≤ b Faire
   m ← (a + b) div 2
   Si T[m] = v Alors trouvé en position m, STOP
   Sinon Si T[m] < v Alors a ← m + 1
   Sinon b ← m - 1
FinTantque
→ absent