18.1

Correspondances : variables, entrées-sorties, affectation, conditions, boucles, tableaux et fonctions

18.2

Choix d’un langage : Python, C et Java

18.3

Méthode de traduction : pseudo-code, vérification, exécution, tests et correction

18.4

Bonnes pratiques : nommage, indentation, modularité, commentaires et validation

Applications

Traductions complètes et exercices progressifs

Cours

3 h

Correspondances syntaxiques et démarche de traduction

Travaux dirigés

3 h

Traduction et analyse de fragments de programmes

Travaux pratiques

4 h

Implémentation, exécution, tests et débogage

Évaluation

1 h

Programme court accompagné de jeux d’essai

Idée centrale : La traduction ne consiste pas à remplacer mécaniquement chaque mot du pseudo-code. Il faut respecter la syntaxe, les types, les bibliothèques et les conventions du langage choisi tout en préservant la logique de l’algorithme.

À retenir : Toujours conserver le pseudo-code et les jeux d’essai pendant la programmation : ils servent de référence pour vérifier que le programme réalisé correspond bien à la solution conçue.

Variables / Constantes

Mémoriser des données

Choisir un type et une valeur initiale adaptés

Lire / Écrire

Communiquer avec l’utilisateur

Convertir la saisie textuelle si nécessaire

←

Affecter une valeur

Ne pas confondre affectation et comparaison

Si / Sinon

Choisir un traitement

Respecter les opérateurs logiques du langage

Pour / TantQue

Répéter un traitement

Contrôler bornes, pas et condition d’arrêt

Tableau

Regrouper des valeurs

Vérifier les indices et la taille

Fonction

Isoler un calcul réutilisable

Définir paramètres et valeur de retour

Variables
     age : Entier
     moyenne : Réel
     admis : Booléen
     nom : Chaîne

age = 20
moyenne = 14.5
admis = True
nom = "Salma"

#include <stdbool.h>
int age = 20;
double moyenne = 14.5;
bool admis = true;
char nom[] = "Salma";

int age = 20;
double moyenne = 14.5;
boolean admis = true;
String nom = "Salma";

Attention : Le type choisi doit couvrir les valeurs possibles et les opérations prévues. Une division entre entiers peut produire un résultat différent d’une division réelle selon le langage.

Écrire("Donner votre âge : ")
Lire(age)
Écrire("Vous avez ", age, " ans")

age = int(input("Donner votre âge : "))
print("Vous avez", age, "ans")

int age;
printf("Donner votre âge : ");
scanf("%d", &age);
printf("Vous avez %d ans\n", age);

Scanner clavier = new Scanner(System.in);
System.out.print("Donner votre âge : ");
int age = clavier.nextInt();
System.out.println("Vous avez " + age + " ans");

Valeur simple

x ← 5

x = 5

Calcul

somme ← a + b

somme = a + b

Incrémentation

compteur ← compteur + 1

compteur = compteur + 1

Forme abrégée

Non normalisée en pseudo-code

compteur += 1

Erreur fréquente : Dans la plupart des langages, = signifie « affecter ». L’égalité logique s’écrit généralement ==. Écrire x = 5 dans une condition n’a donc pas le même sens que x == 5.

Si note ≥ 10 Alors
     Écrire("Admis")
Sinon
     Écrire("Ajourné")
FinSi

if note >= 10:
     print("Admis")
else:
     print("Ajourné")

if (note >= 10) {
     printf("Admis\n");
} else {
     printf("Ajourne\n");
}

if (note >= 10) {
     System.out.println("Admis");
} else {
     System.out.println("Ajourné");
}

ET

ET

and

&&

OU

OU

or

||

NON

NON

not

!

Égalité

=

==

==

Différence

≠

!=

!=

Pour i allant de 0 à n - 1 Faire
     Écrire(i)
FinPour

for i in range(n):
     print(i)

for (int i = 0; i < n; i++) {
     printf("%d\n", i);
}

for (int i = 0; i < n; i++) {
     System.out.println(i);
}

TantQue valeur ≤ 0 Faire
     Lire(valeur)
FinTantQue

while valeur <= 0:
     valeur = int(input("Nombre positif : "))

while (valeur <= 0) {
     scanf("%d", &valeur);
}

while (valeur <= 0) {
     valeur = clavier.nextInt();
}

Répéter
     Lire(note)
Jusqu’à note ≥ 0 ET note ≤ 20

while True:
     note = float(input("Note : "))
     if 0 <= note <= 20:
         break

do {
     scanf("%lf", &note);
} while (note < 0 || note > 20);

do {
     note = clavier.nextDouble();
} while (note < 0 || note > 20);

Variables
     notes : Tableau[0..4] de Réel

Pour i allant de 0 à 4 Faire
     Lire(notes[i])
FinPour

notes = [0.0] * 5
for i in range(5):
     notes[i] = float(input("Note : "))

double notes[5];
for (int i = 0; i < 5; i++) {
     scanf("%lf", &notes[i]);
}

double[] notes = new double[5];
for (int i = 0; i < 5; i++) {
     notes[i] = clavier.nextDouble();
}

Indice invalide : Un accès comme T[n] est hors limites pour un tableau de n éléments indexé de 0 à n - 1. Cette erreur peut provoquer une exception, un arrêt ou un comportement incorrect selon le langage.

Fonction Maximum(a : Entier, b : Entier) : Entier
     Si a > b Alors
         Retourner a
     Sinon
         Retourner b
     FinSi
FinFonction

def maximum(a: int, b: int) -> int:
     if a > b:
         return a
     return b

int maximum(int a, int b) {
     if (a > b) {
         return a;
     }
     return b;
}

static int maximum(int a, int b) {
     if (a > b) {
         return a;
     }
     return b;
}

def maximum(a: int, b: int) -> int:
     return a if a > b else b

x = int(input("x : "))
y = int(input("y : "))
print("Maximum :", maximum(x, y))

#include <stdio.h>

int maximum(int a, int b) {
     return (a > b) ? a : b;
}

int main(void) {
     int x, y;
     scanf("%d %d", &x, &y);
     printf("Maximum : %d\n", maximum(x, y));
     return 0;
}

import java.util.Scanner;

public class MaximumApp {
     static int maximum(int a, int b) {
         return (a > b) ? a : b;
     }

     public static void main(String[] args) {
         Scanner clavier = new Scanner(System.in);
         int x = clavier.nextInt();
         int y = clavier.nextInt();
         System.out.println("Maximum : " + maximum(x, y));
         clavier.close();
     }
}

Apprentissage

Le langage permet-il de se concentrer rapidement sur la logique ?

Typage

Souhaite-t-on rendre les types très visibles et contrôlés ?

Mémoire

Faut-il comprendre ou maîtriser finement l’allocation mémoire ?

Portabilité

Le programme doit-il fonctionner sur plusieurs plateformes ?

Écosystème

Les bibliothèques nécessaires sont-elles disponibles ?

Domaine

Le langage est-il adapté au Web, à la donnée, à l’embarqué ou aux applications métier ?

Usage pédagogique : Python est particulièrement adapté pour découvrir la programmation, automatiser des tâches, traiter des données et réaliser rapidement des prototypes.

Usage pédagogique : C est fréquent dans les systèmes embarqués, les systèmes d’exploitation, les pilotes et les programmes nécessitant un contrôle fin des ressources.

Usage pédagogique : Java convient aux applications structurées de taille moyenne ou grande et constitue une transition naturelle vers la programmation orientée objet.

Syntaxe initiale

Très concise

Rigoureuse

Rigoureuse et structurée

Typage

Dynamique

Statique

Statique

Exécution

Interprétée / machine virtuelle

Compilation native

Compilation vers bytecode / JVM

Mémoire

Automatique

Contrôle manuel important

Automatique

Tableaux

Listes dynamiques usuelles

Taille explicite

Tableaux et collections

Objet

Possible, non obligatoire au début

Non natif

Central

Débutant

Prise en main rapide

Très formateur mais exigeant

Formateur avec plus de structure

Quelles sont les entrées ?

Un tableau de notes et sa taille

Quel est le résultat ?

La moyenne des notes

Quels cas particuliers ?

Tableau vide, note invalide

Quelles structures ?

Boucle, accumulateur et fonction

[10, 12, 14]

12

Cas normal

[20]

20

Taille minimale non vide

[]

Erreur ou traitement défini

Cas particulier

[0, 20]

10

Valeurs limites

Réel

float ou double selon le langage

Lire une note

input + conversion, scanf ou Scanner

Tableau de n notes

liste, tableau statique ou tableau alloué

Erreur si n = 0

message, valeur spéciale ou exception selon le contexte

Fonction Moyenne(T, n) : Réel
     Si n = 0 Alors
         Retourner 0
     FinSi
     somme ← 0
     Pour i allant de 0 à n - 1 Faire
         somme ← somme + T[i]
     FinPour
     Retourner somme / n
FinFonction

def moyenne(notes: list[float]) -> float:
     if len(notes) == 0:
         return 0.0
     somme = 0.0
     for note in notes:
         somme += note
     return somme / len(notes)

Erreur de syntaxe

Parenthèse, deux-points ou accolade manquante

Lire la ligne et les lignes précédentes

Nom inconnu

Variable mal orthographiée ou hors portée

Comparer avec la déclaration

Type incompatible

Chaîne utilisée comme nombre

Ajouter une conversion ou corriger le type

Bibliothèque absente

Scanner ou fonction non importée

Ajouter l’import ou l’en-tête nécessaire

Syntaxe

Le programme ne démarre pas ou ne compile pas

Message du compilateur ou de l’interpréteur

Exécution

Arrêt pendant le traitement

Trace d’erreur, débogueur, vérification des indices

Logique

Résultat faux sans arrêt

Table de trace, affichages temporaires, tests unitaires

Bonne pratique : Corriger une erreur ne doit pas en masquer une autre. Après chaque modification, relancer les anciens jeux d’essai afin d’éviter les régressions.

Constante N ← 5
Variables notes : Tableau[0..N-1] de Réel
          somme, moyenne : Réel

somme ← 0
Pour i allant de 0 à N - 1 Faire
     Répéter
         Lire(notes[i])
     Jusqu’à notes[i] ≥ 0 ET notes[i] ≤ 20
     somme ← somme + notes[i]
FinPour
moyenne ← somme / N
Écrire(moyenne)
Si moyenne ≥ 10 Alors
     Écrire("Admis")
Sinon
     Écrire("Ajourné")
FinSi

N = 5
notes = []

for i in range(N):
     while True:
         try:
            note = float(input(f"Note {i + 1} : "))
            if 0 <= note <= 20:
                notes.append(note)
                break
            print("La note doit être comprise entre 0 et 20.")
         except ValueError:
            print("Veuillez saisir un nombre.")

moyenne = sum(notes) / N
print(f"Moyenne : {moyenne:.2f}")
print("Admis" if moyenne >= 10 else "Ajourné")

x

nombreEtudiants

Le rôle est immédiatement visible

t

notes

Le contenu du tableau est identifié

f()

calculerMoyenne()

L’action de la fonction est explicite

b

estAdmis

Le nom exprime une valeur booléenne

if moyenne >= 10:
     print("Admis")
     if moyenne >= 16:
         print("Très bien")
else:
     print("Ajourné")

Même formule copiée dans plusieurs endroits

Créer une fonction

Même saisie répétée cinq fois

Utiliser une boucle

Même contrôle pour plusieurs valeurs

Créer une fonction de validation

Même message construit manuellement

Créer une fonction d’affichage

# Correct : explique le choix
# On ignore la première ligne car elle contient les en-têtes du fichier.

# Peu utile : répète le code
compteur += 1  # Ajouter 1 à compteur

Signe de décomposition : Une fonction longue contenant lecture, validation, calcul, tri, affichage et sauvegarde doit généralement être décomposée en plusieurs fonctions spécialisées.

Note

Nombre compris entre 0 et 20

Âge

Entier positif dans une plage plausible

Identifiant

Non vide, longueur et caractères autorisés

Diviseur

Nombre différent de zéro

Indice

Compris entre 0 et taille - 1

Distinction : Un cas particulier n’est pas nécessairement une erreur. Un tableau vide peut être autorisé, mais le résultat attendu doit être défini explicitement.

Variables Python

snake_case : nombre_etudiants

Méthodes Java

camelCase : calculerMoyenne

Constantes

Majuscules : NOTE_MAXIMALE

Fonctions

Verbe indiquant l’action : rechercherEtudiant

Lire(a, b)
Si a > b Alors
     maximum ← a
Sinon
     maximum ← b
FinSi
Écrire(maximum)

a = float(input("a : "))
b = float(input("b : "))
maximum = a if a > b else b
print("Maximum :", maximum)

Lire(N)
somme ← 0
Pour i allant de 1 à N Faire
     somme ← somme + i
FinPour
Écrire(somme)

# C
int n, somme = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
     somme += i;
}
printf("%d\n", somme);

Fonction Rechercher(T, n, valeur) : Entier
     Pour i allant de 0 à n - 1 Faire
         Si T[i] = valeur Alors
            Retourner i
         FinSi
     FinPour
     Retourner -1
FinFonction

static int rechercher(int[] tableau, int valeur) {
     for (int i = 0; i < tableau.length; i++) {
         if (tableau[i] == valeur) {
            return i;
         }
     }
     return -1;
}

def calculer_moyenne(notes: list[float]) -> float:
     if not notes:
         raise ValueError("La liste des notes est vide")
     return sum(notes) / len(notes)

Répéter
     Écrire("1. Ajouter")
     Écrire("2. Afficher")
     Écrire("0. Quitter")
     Lire(choix)
     Selon choix Faire
         Cas 1 : Ajouter()
         Cas 2 : Afficher()
         Cas 0 : Écrire("Fin")
         Sinon : Écrire("Choix invalide")
     FinSelon
Jusqu’à choix = 0

while True:
     print("1. Ajouter\n2. Afficher\n0. Quitter")
     choix = input("Choix : ")
     if choix == "1":
         ajouter()
     elif choix == "2":
         afficher()
     elif choix == "0":
         print("Fin")
         break
     else:
         print("Choix invalide")

Python :
x = 5
y = x * 2
print(y)

C :
int x = 5;
int y = x * 2;
printf("%d
", y);

Java :
int x = 5;
int y = x * 2;
System.out.println(y);

nombre = int(input("Entier : "))
if nombre % 2 == 0:
     print("Pair")
else:
     print("Impair")

for i in range(1, n + 1):
     print(i)

while True:
     try:
         note = float(input("Note : "))
         if 0 <= note <= 20:
            break
     except ValueError:
         pass
     print("Saisie invalide")

def carre(x: float) -> float:
     return x * x

def contient(tableau: list[int], valeur: int) -> bool:
     for element in tableau:
         if element == valeur:
            return True
     return False

def moyenne(valeurs: list[float]) -> float:
     if len(valeurs) == 0:
         raise ValueError("Aucune valeur")
     return sum(valeurs) / len(valeurs)

Algorithme

Description logique et indépendante d’un langage.

Programme

Traduction exécutable respectant la syntaxe d’un langage.

Variable et type

Le type doit être compatible avec les valeurs et les opérations.

Entrée-sortie

La saisie nécessite souvent une conversion et une validation.

Affectation

Le symbole ← devient généralement = ; la comparaison utilise souvent ==.

Condition

La logique est conservée, mais les opérateurs et les blocs changent.

Boucle

Les bornes et la condition d’arrêt doivent être traduites avec précision.

Tableau

Les indices sont généralement compris entre 0 et taille - 1.

Fonction

Les paramètres, le type retourné et les cas particuliers doivent être définis.

Méthode

Concevoir, vérifier, traduire, exécuter, tester et corriger.

Qualité

Lisibilité, modularité, validation et cohérence complètent la correction.

Principe final : Une traduction réussie préserve la logique de l’algorithme, respecte les règles du langage et produit un programme vérifié par des jeux d’essai représentatifs.

Syntaxe

Règles d’écriture imposées par un langage.

Compilation

Transformation du code source avant son exécution.

Interprétation

Exécution du programme par un interpréteur ou un environnement dynamique.

Typage statique

Types vérifiés principalement avant l’exécution.

Typage dynamique

Types associés aux valeurs et vérifiés principalement pendant l’exécution.

Bibliothèque

Ensemble de fonctions et de classes réutilisables.

Débogage

Recherche et correction méthodique des erreurs.

Exception

Mécanisme signalant une situation anormale pendant l’exécution.

Régression

Erreur réintroduite dans une fonctionnalité auparavant correcte.

Convention de code

Règles communes de nommage et de mise en forme.

☐

Je sais distinguer un algorithme d’un programme.

☐

Je sais traduire une déclaration de variable et une affectation.

☐

Je sais réaliser une lecture, une conversion et un affichage.

☐

Je sais traduire une condition avec des opérateurs logiques.

☐

Je sais traduire une boucle Pour et une boucle TantQue.

☐

Je sais manipuler un tableau sans dépasser ses limites.

☐

Je sais écrire et appeler une fonction simple.

☐

Je peux expliquer les différences générales entre Python, C et Java.

☐

Je sais vérifier un pseudo-code avant de programmer.

☐

Je sais préparer des cas normaux, limites et incorrects.

☐

Je sais utiliser les messages d’erreur pour déboguer.

☐

Je sais améliorer les noms, l’indentation et la modularité d’un programme.

Conseil final : Commencer par une version simple et correcte. Ajouter ensuite la validation, les cas particuliers et les améliorations de structure, en relançant les tests après chaque modification.