NSI 1ère

Pseudo-code lisible
Exercices corrigés

Maîtrisez le pseudo-code lisible : syntaxe, structures, variables, algorithmique et bonnes pratiques grâce à ces 5 exercices détaillés.

Concepts & Exercices
\(\text{Algorithme} = \text{Variables} + \text{Structures} + \text{Logique}\)
Pseudo-code
Variables
VAR nom : type
Stockage
Condition
SI condition ALORS
Choix
Boucle
POUR i DE 1 À n
Répétition
📝
Clarté : Langage proche du français pour décrire un algorithme.
🧩
Universel : Indépendant du langage de programmation.
🎯
Structuré : Utilise des structures algorithmiques claires.
Exercice 1
Écrire un pseudo-code pour saisir et afficher des données
Exercice 2
Utiliser des structures conditionnelles dans le pseudo-code
Exercice 3
Implémenter des boucles dans le pseudo-code
Exercice 4
Créer un algorithme de calcul avec des fonctions
Exercice 5
Écrire un pseudo-code complexe avec imbrication
Corrigé : Exercices 1 à 3
1 Saisie et affichage
Définition :

Saisie et affichage : Instructions de base pour interagir avec l'utilisateur dans un algorithme.

Méthode de base :
  1. Déclarer les variables nécessaires
  2. Utiliser LIRE pour la saisie
  3. Utiliser ECRIRE pour l'affichage
  4. Respecter la syntaxe du pseudo-code
DEBUT // Déclaration des variables VARIABLES nom : CHAINE age : ENTIER taille : REEL // Saisie des données ECRIRE("Entrez votre nom : ") LIRE(nom) ECRIRE("Entrez votre âge : ") LIRE(age) ECRIRE("Entrez votre taille (en m) : ") LIRE(taille) // Affichage des résultats ECRIRE("Bonjour ", nom, " !") ECRIRE("Vous avez ", age, " ans") ECRIRE("Votre taille est de ", taille, " m") FIN
┌─────────────┐
│Début │
└──────┬──────┘
│
┌─────▼─────┐
│Déclaration│
│variables │
└─────┬─────┘
│
┌─────▼─────┐
│LIRE(nom) │
└─────┬─────┘
│
┌─────▼─────┐
│LIRE(age) │
└─────┬─────┘
│
┌─────▼─────┐
│LIRE(taille)│
└─────┬─────┘
│
┌─────▼─────┐
│ECRIRE( │
│résultats) │
└─────┬─────┘
│
┌─────▼─────┐
│Fin │
└───────────┘
Étape 1 : Déclaration des variables

Identifier les données nécessaires et leurs types

Étape 2 : Saisie des données

Demander à l'utilisateur les informations requises

Étape 3 : Affichage des résultats

Montrer les informations à l'utilisateur

Résultat :

Algorithme complet permettant l'interaction avec l'utilisateur

Règles appliquées :

• Clarté : Utiliser des noms de variables explicites

• Syntaxe : Respecter les majuscules pour les mots-clés

• Structure : Organiser logiquement les instructions

2 Structures conditionnelles
Définition :

Structure conditionnelle : Instruction qui exécute un bloc de code seulement si une condition est vraie.

Structure Syntaxe Utilisation SI ... ALORS SI condition ALORS
instructions
FIN SI Exécution conditionnelle simple SI ... ALORS ... SINON SI condition ALORS
instructions
SINON
instructions
FIN SI Alternative binaire SUIVANT SUIVANT expression DE
valeur1 : instructions
valeur2 : instructions
FIN SUIVANT Choix multiple
DEBUT VARIABLES note : REEL mention : CHAINE ECRIRE("Entrez votre note : ") LIRE(note) SI note >= 16 ALORS mention ← "Très bien" SINON SI note >= 14 ALORS mention ← "Bien" SINON SI note >= 12 ALORS mention ← "Assez bien" SINON SI note >= 10 ALORS mention ← "Passable" SINON mention ← "Insuffisant" FIN SI ECRIRE("Votre mention est : ", mention) FIN
┌─────────────┐
│Début │
└──────┬──────┘
│
┌─────▼─────┐
│LIRE(note) │
└─────┬─────┘
│
┌─────▼─────┐
│note>=16? │
├─Oui─┐ ┌─Non─┤
│ │ │ │
┌────▼──┐ │ │ ┌───▼──────────────┐
│mention│ │ │ │note>=14? │
│←"TB" │ │ │ │ ├─Oui─┐ ┌─Non─┤
└───────▲┘ │ │ │ │ │ │ │
│ │ │ │┌───▼──┐ │ │ ┌───▼─────────────┐
│ │ │ │mention│ │ │ │note>=12? │
│ │ │ │←"Bien"│ │ │ │ ├─Oui─┐ ┌─Non─┤
│ │ │ └──────▲┘ │ │ │ │ │ │ │
│ │ │ │ │ │ │┌────▼──┐ │ │ ┌───▼─────────────┐
│ │ │ │ │ │ ││mention│ │ │ │note>=10? │
│ │ │ │ │ │ ││←"AB" │ │ │ │ ├─Oui─┐ ┌─Non─┤
│ │ │ │ │ │ │└──────▲┘ │ │ │ │ │ │ │
│ │ │ │ │ │ │ │ │ │ │┌────▼──┐ │ │ ┌───▼──────────┐
│ │ │ │ │ │ │ │ │ │ ││mention│ │ │ │mention │
│ │ │ │ │ │ │ │ │ │ ││←"Pass"│ │ │ │←"Insuffisant"│
│ │ │ │ │ │ │ │ │ │ │└──────▲┘ │ │ │└─────────────▲┘
│ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
└─┼─┼────────┼─┼─┼─┼───────┼─┼─┼─┼─┼───────┼─┼─┼─┼─────────────┼─┘
│ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
┌────▼─▼────────▼─▼─▼─▼───────▼─▼─▼─▼─▼───────▼─▼─▼─▼─────────────▼──┐
│ECRIRE("Votre mention est : ", mention) │
└─────────────────────────────────────────────────────────────────┘
Étape 1 : Analyser la condition

Identifier la variable à tester et les seuils

Étape 2 : Écrire les conditions

Utiliser des structures SI/SINON SI pour les alternatives

Étape 3 : Affecter les résultats

Assigner la valeur appropriée selon la condition remplie

Résultat :

Structure conditionnelle complète avec plusieurs alternatives

Règles appliquées :

• Hiérarchie : Les conditions sont évaluées dans l'ordre

• Exclusivité : Un seul bloc est exécuté dans une structure SI/SINON

• Clôture : Toute structure ouverte doit être fermée (FIN SI)

3 Boucles
Définition :

Boucle : Structure qui répète un bloc d'instructions tant qu'une condition est remplie ou pour un nombre fixe d'itérations.

DEBUT VARIABLES i, somme, n : ENTIER ECRIRE("Entrez le nombre d'itérations : ") LIRE(n) somme ← 0 // Boucle POUR POUR i DE 1 À n FAIRE somme ← somme + i ECRIRE("Itération ", i, ": somme = ", somme) FIN POUR ECRIRE("Somme totale : ", somme) // Boucle TANT QUE VARIABLES compteur : ENTIER compteur ← 1 TANT QUE compteur <= 5 FAIRE ECRIRE("Tour ", compteur) compteur ← compteur + 1 FIN TANT QUE // Boucle REPETER VARIABLES choix : CHAINE REPETER ECRIRE("Entrez 'quitter' pour sortir : ") LIRE(choix) JUSQU'A choix = "quitter" FIN
Type Syntaxe Condition Usage POUR POUR i DE a À b FAIRE
instructions
FIN POUR Nombre fixe d'itérations Quand on connaît le nombre de répétitions TANT QUE TANT QUE condition FAIRE
instructions
FIN TANT QUE Vérifie avant exécution Peut ne pas s'exécuter REPETER REPETER
instructions
JUSQU'A condition Vérifie après exécution S'exécute au moins une fois
Étape 1 : Choisir le type de boucle

POUR pour un nombre connu d'itérations, TANT QUE ou REPETER pour des conditions

Étape 2 : Initialiser les variables

Préparer les variables de contrôle avant la boucle

Étape 3 : Contrôler la boucle

Assurer la modification des variables pour éviter les boucles infinies

Résultat :

Les trois types de boucles sont utilisés avec leurs spécificités

Règles appliquées :

• Contrôle : La variable de boucle doit être modifiée pour terminer la boucle

• Initialisation : Initialiser correctement les variables de contrôle

• Clôture : Fermer chaque boucle avec le mot-clé approprié

Corrigé : Exercices 4 à 5
4 Fonctions
Définition :

Fonction : Bloc de code nommé qui effectue une tâche spécifique et peut retourner une valeur.

FONCTION factorielle(n : ENTIER) : ENTIER VARIABLES resultat, i : ENTIER resultat ← 1 POUR i DE 1 À n FAIRE resultat ← resultat * i FIN POUR RETOURNER resultat FIN FONCTION FONCTION est_pair(nombre : ENTIER) : BOOLEEN RETOURNER nombre MOD 2 = 0 FIN FONCTION DEBUT VARIABLES n, resultat : ENTIER ECRIRE("Entrez un nombre : ") LIRE(n) resultat ← factorielle(n) ECRIRE("Factorielle de ", n, " = ", resultat) SI est_pair(n) ALORS ECRIRE(n, " est pair") SINON ECRIRE(n, " est impair") FIN SI FIN
Élément Syntaxe Description Déclaration FONCTION nom(params) : type_retour En-tête de la fonction Paramètres nom : type Variables d'entrée de la fonction Retour RETOURNER valeur Valeur renvoyée par la fonction Appel variable ← nom(arguments) Utilisation de la fonction
Étape 1 : Définir la fonction

Spécifier le nom, les paramètres et le type de retour

Étape 2 : Implémenter la logique

Écrire le corps de la fonction avec les instructions nécessaires

Étape 3 : Retourner un résultat

Utiliser RETOURNER pour renvoyer la valeur calculée

Résultat :

Fonctions réutilisables avec paramètres et valeurs de retour

Règles appliquées :

• Signature : Spécifier clairement les paramètres et le type de retour

• Responsabilité : Une fonction devrait avoir une seule tâche

• Appel : Une fonction peut être appelée plusieurs fois avec différents arguments

5 Algorithme complexe
Définition :

Algorithme complexe : Combinaison de plusieurs structures algorithmiques pour résoudre un problème complexe.

DEBUT VARIABLES notes[100] : REEL nb_notes, i, somme : ENTIER moyenne : REEL choix : CHAINE nb_notes ← 0 REPETER ECRIRE("Menu:") ECRIRE("1. Saisir une note") ECRIRE("2. Calculer la moyenne") ECRIRE("3. Afficher les notes") ECRIRE("4. Quitter") ECRIRE("Votre choix : ") LIRE(choix) SI choix = "1" ET nb_notes < 100 ALORS ECRIRE("Entrez la note : ") LIRE(notes[nb_notes]) nb_notes ← nb_notes + 1 ECRIRE("Note ajoutée !") SINON SI choix = "2" ET nb_notes > 0 ALORS somme ← 0 POUR i DE 0 À nb_notes - 1 FAIRE somme ← somme + notes[i] FIN POUR moyenne ← somme / nb_notes ECRIRE("Moyenne : ", moyenne) SINON SI choix = "3" ET nb_notes > 0 ALORS ECRIRE("Notes saisies :") POUR i DE 0 À nb_notes - 1 FAIRE ECRIRE("Note ", i+1, " : ", notes[i]) FIN POUR SINON SI choix = "4" ALORS ECRIRE("Au revoir !") SINON ECRIRE("Option invalide ou aucune note disponible") FIN SI JUSQU'A choix = "4" FIN
┌─────────────┐
│Début │
└──────┬──────┘
│
┌─────▼─────┐
│Menu │
│affiché │
└─────┬─────┘
│
┌─────▼─────┐
│LIRE(choix)│
└─────┬─────┘
│
┌─────▼─────┐
│choix = 1? │
├─Oui─┐ ┌─Non─┤
│ │ │ │
┌────▼──┐ │ │ ┌───▼─────────────┐
│Saisir │ │ │ │choix = 2? │
│note │ │ │ │ ├─Oui─┐ ┌─Non─┤
└─────▲─┘ │ │ │ │ │ │ │
│ │ │ │┌───▼─┐ │ │ ┌───▼─────────────┐
│ │ │ │Calc │ │ │ │choix = 3? │
│ │ │ │moyenne│ │ │ │ ├─Oui─┐ ┌─Non─┤
│ │ │ │ │ │ │ │ │ │ │ │
│ │ │ └───▲─┘ │ │ │┌───▼─┐ │ │ ┌───▼─────────────┐
│ │ │ │ │ │ ││Affi│ │ │ │choix = 4? │
│ │ │ │ │ │ ││cher│ │ │ │ ├─Oui─┐ ┌─Non─┤
│ │ │ │ │ │ ││notes│ │ │ │ │ │ │ │
│ │ │ │ │ │ │└───▲─┘ │ │ │┌───▼─┐ │ │ ┌───▼─────────────┐
│ │ │ │ │ │ │ │ │ │ ││Quit│ │ │ │Autres options │
│ │ │ │ │ │ │ │ │ │ ││ter │ │ │ │ ├─Oui─┐ ┌─Non─┤
│ │ │ │ │ │ │ │ │ │ │└───▲─┘ │ │ │ │ │ │ │
│ │ │ │ │ │ │ │ │ │ │ │ │ │ │┌───▼─┐ │ │ ┌───▼─────────────┐
│ │ │ │ │ │ │ │ │ │ │ │ │ │ ││Affi│ │ │ │Boucle │
│ │ │ │ │ │ │ │ │ │ │ │ │ │ ││cher│ │ │ │ ├─Oui─┐ ┌─Non─┤
│ │ │ │ │ │ │ │ │ │ │ │ │ │ ││erreur│ │ │ │ │ │ │ │
│ │ │ │ │ │ │ │ │ │ │ │ │ │ │└───▲─┘ │ │ │┌───▼─┐ │ │ ┌───▼─────────────┐
│ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ ││Retour│ │ │ │Fin programme │
│ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ ││menu │ │ │ │ ├─Oui─┐ ┌─Non─┤
│ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │└───▲─┘ │ │ │ │ │ │ │
└─┼─┼─┼─────┼─┼─┼─┼─────┼─┼─┼─┼─┼─┼─┼────┼─┼─┼─┼────┼─┼─┼────┼─┼─┼────┼─┼─┼─┼─┼────┼─┼─┼────┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼...... Pseudo-code lisible | Exercices corrigés | NSI 1ère
NSI 1ère

Pseudo-code lisible
Exercices corrigés

Maîtrisez le pseudo-code lisible : structure, variables, conditions, boucles et bonnes pratiques grâce à ces 5 exercices détaillés.

Concepts & Exercices
\(\text{Algorithme} \rightarrow \text{Pseudo-code} \rightarrow \text{Programme}\)
Transformation d'idée
Variable
VAR nom: type
Stockage
Condition
SI condition ALORS
Choix
Boucle
POUR i DE 1 À n
Répétition
📝
Clarté : Langage proche du français, syntaxe simple.
🎯
Universel : Compréhensible indépendamment du langage de programmation.
⚙️
Structuré : Respect des structures algorithmiques de base.
Exercice 1
Décrire un algorithme avec des variables et affectations
Exercice 2
Utiliser des structures conditionnelles dans le pseudo-code
Exercice 3
Implémenter des boucles dans le pseudo-code
Exercice 4
Structurer un algorithme complexe avec sous-programmes
Exercice 5
Optimiser la lisibilité du pseudo-code
Corrigé : Exercices 1 à 3
1 Variables et affectations
Définition :

Variable : Emplacement mémoire nommé qui stocke une valeur pouvant changer durant l'exécution de l'algorithme.

Convention de notation :
  1. Déclarer les variables avec VAR nom: type
  2. Utiliser ← pour l'affectation
  3. Donner des noms descriptifs aux variables
  4. Respecter les types de données
DEBUT VAR a: ENTIER VAR b: ENTIER VAR resultat: ENTIER ECRIRE("Entrez le premier nombre:") LIRE(a) ECRIRE("Entrez le second nombre:") LIRE(b) resultat ← a + b ECRIRE("La somme est:", resultat) FIN
┌─────────────┐
│Début │
└──────┬──────┘
│
┌─────▼─────┐
│Déclaration│
│variables │
└─────┬─────┘
│
┌─────▼─────┐
│Lire a, b │
└─────┬─────┘
│
┌─────▼─────┐
│resultat ← │
│a + b │
└─────┬─────┘
│
┌─────▼─────┐
│Afficher │
│resultat │
└─────┬─────┘
│
┌─────▼─────┐
│Fin │
└───────────┘
Étape 1 : Déclaration des variables

On déclare a, b et resultat comme des entiers

Étape 2 : Lecture des entrées

On lit les valeurs de a et b depuis l'utilisateur

Étape 3 : Calcul et affectation

On calcule la somme et on affecte le résultat à la variable resultat

Résultat :

L'algorithme lit deux nombres, calcule leur somme et affiche le résultat

Règles appliquées :

• Clarté : Utilisation de noms de variables descriptifs

• Structure : Respect de la syntaxe du pseudo-code

• Flux : Instructions exécutées dans l'ordre

2 Structures conditionnelles
Définition :

Structure conditionnelle : Permet d'exécuter des instructions différentes selon qu'une condition est vraie ou fausse.

Structure Syntaxe Usage Simple SI condition ALORS ... FIN SI Action unique Alternative SI ... ALORS ... SINON ... FIN SI Deux choix Multi-cas SELON ... FAIRE ... FIN SELON Plusieurs choix
DEBUT VAR note: REEL VAR mention: CHAINE ECRIRE("Entrez la note:") LIRE(note) SI note >= 16 ALORS mention ← "Très bien" SINON SI note >= 14 ALORS mention ← "Bien" SINON SI note >= 12 ALORS mention ← "Assez bien" SINON SI note >= 10 ALORS mention ← "Passable" SINON mention ← "Éliminé" FIN SI ECRIRE("Mention:", mention) FIN
Étape 1 : Lecture de la note

On lit la note de type réel depuis l'utilisateur

Étape 2 : Chaîne de conditions

On teste la note contre différents seuils

Étape 3 : Attribution de la mention

On affecte la mention appropriée selon la note

Résultat :

L'algorithme attribue une mention selon la note entrée

Règles appliquées :

• Hiérarchie : Les conditions sont testées dans l'ordre

• Exclusivité : Une seule branche est exécutée

• Structure : Chaque SI est terminé par FIN SI

3 Boucles
Définition :

Boucle : Structure qui répète un bloc d'instructions tant qu'une condition est remplie ou pour un nombre fixe d'itérations.

DEBUT VAR i: ENTIER VAR somme: ENTIER VAR n: ENTIER ECRIRE("Entrez la valeur de n:") LIRE(n) somme ← 0 POUR i DE 1 À n FAIRE somme ← somme + i FIN POUR ECRIRE("Somme des entiers de 1 à", n, ":", somme) // Autre exemple avec TANT QUE VAR nombre: ENTIER nombre ← 0 TANT QUE nombre <= 100 FAIRE ECRIRE("Nombre actuel:", nombre) nombre ← nombre + 10 FIN TANT QUE FIN
Étape 1 : Initialisation

On initialise les variables nécessaires (somme = 0)

Étape 2 : Boucle POUR

On répète n fois l'addition de i à somme

Étape 3 : Boucle TANT QUE

On répète tant que la condition est vraie

Résultat :

Calcul de la somme des entiers de 1 à n et affichage de nombres par intervalles

Règles appliquées :

• Initialisation : Variables correctement initialisées

• Contrôle : La boucle doit se terminer (condition de sortie)

• Structure : Chaque boucle est terminée par FIN

Corrigé : Exercices 4 à 5
4 Sous-programmes
Définition :

Sous-programme : Partie de l'algorithme qui effectue une tâche spécifique et peut être appelée depuis d'autres parties.

ALGORITHME CalculComplet DEBUT // Programme principal VAR a, b, resultat: ENTIER ECRIRE("Entrez deux nombres:") LIRE(a, b) resultat ← CalculerSomme(a, b) ECRIRE("Somme:", resultat) resultat ← CalculerProduit(a, b) ECRIRE("Produit:", resultat) FIN FONCTION CalculerSomme(x: ENTIER, y: ENTIER): ENTIER DEBUT RETOURNER x + y FIN FONCTION CalculerProduit(x: ENTIER, y: ENTIER): ENTIER DEBUT RETOURNER x * y FIN PROCEDURE AfficherCarre(nombre: ENTIER) DEBUT ECRIRE("Le carré de", nombre, "est", nombre * nombre) FIN
Type Retour Appel Usage FONCTION Oui Dans une expression Calcul et retour de valeur PROCEDURE Non Instruction autonome Actions sans valeur de retour
Étape 1 : Définition des sous-programmes

On définit des fonctions et procédures pour des tâches spécifiques

Étape 2 : Appel des sous-programmes

On appelle les sous-programmes depuis le programme principal

Étape 3 : Réutilisation

Les sous-programmes peuvent être réutilisés plusieurs fois

Résultat :

Structure modulaire avec programme principal et sous-programmes spécialisés

Règles appliquées :

• Modularité : Découpage en sous-programmes spécialisés

• Interface : Spécification claire des paramètres et retour

• Réutilisation : Les sous-programmes peuvent être appelés plusieurs fois

5 Lisibilité optimisée
Définition :

Lisibilité : Qualité d'un pseudo-code qui permet de le comprendre facilement et rapidement.

// Bon exemple de pseudo-code lisible ALGORITHME TriBulleOptimise DEBUT CONSTANTES: MAX_ELEMENTS = 100 VARIABLES: tableau[MAX_ELEMENTS]: ENTIER taille: ENTIER i, j: ENTIER temporaire: ENTIER echangementEffectue: BOOLEEN DEBUT_PROGRAMME: ECRIRE("Saisir la taille du tableau (max ", MAX_ELEMENTS, "):") LIRE(taille) ECRIRE("Saisir les éléments du tableau:") POUR i DE 0 À taille-1 FAIRE LIRE(tableau[i]) FIN POUR ECRIRE("Tableau avant tri:") AFFICHER_TABLEAU(tableau, taille) // Tri à bulles optimisé REPETER echangementEffectue ← FAUX POUR j DE 0 À taille-2 FAIRE SI tableau[j] > tableau[j+1] ALORS // Échange des éléments temporaire ← tableau[j] tableau[j] ← tableau[j+1] tableau[j+1] ← temporaire echangementEffectue ← VRAI FIN SI FIN POUR taille ← taille - 1 // Dernier élément est trié JUSQU'A (echangementEffectue = FAUX OU taille <= 1) ECRIRE("Tableau après tri:") AFFICHER_TABLEAU(tableau, taille) FIN
Étape 1 : Documentation

Commentaires pour expliquer le but de l'algorithme

Étape 2 : Structure claire

Sections bien délimitées (constantes, variables, programme)

Étape 3 : Espacement et indentation

Utilisation cohérente pour améliorer la lisibilité

Résultat :

Pseudo-code bien structuré, commenté et facile à comprendre

Règles appliquées :

• Commentaires : Explication des parties complexes

• Structure : Sections logiques bien séparées

• Consistance : Style uniforme dans tout le pseudo-code

Cours bien détaillé
\(\text{Pseudo-code} = \text{Algorithme} + \text{Clarté} + \text{Structuration}\)
Équation de lisibilité
🎯
Définition : Le pseudo-code est un langage intermédiaire entre le langage naturel et le langage de programmation.
📏
Objectif : Exprimer un algorithme de manière claire, structurée et indépendante d'un langage de programmation spécifique.
📐
Structure : Variables, affectations, structures conditionnelles, boucles, sous-programmes.
📝
Avantages : Facilité de compréhension, indépendance linguistique, support d'enseignement.
💡
Conseil : Utilisez des noms de variables descriptifs et des commentaires
🔍
Attention : Respectez la structure et la syntaxe du pseudo-code
⚡
Astuce : Indentez correctement pour montrer la structure
📋
Méthode : Divisez les algorithmes complexes en sous-parties
✅
Vérification : Relisez votre pseudo-code pour en vérifier la clarté
Éléments du pseudo-code :
  • Variables : VAR nom: type (ENTIER, REEL, CHAINE, BOOLEEN)
  • Affectation : variable ← valeur
  • Lecture/Écriture : LIRE(variable), ECRIRE(message)
  • Conditions : SI condition ALORS ... SINON ... FIN SI
  • Boucles : POUR, TANT QUE, REPETER JUSQU'A
  • Sous-programmes : FONCTION, PROCEDURE
Règles importantes :
  • Chaque structure doit avoir une ouverture et une fermeture claire
  • Les variables doivent être déclarées avant utilisation
  • Respectez la logique algorithmique et l'ordre d'exécution
  • Utilisez des noms cohérents et descriptifs
  • Documentez les parties complexes avec des commentaires
Pseudo-code lisible Notions de base d’algorithmique