Algorithme en Langage Naturel | Algorithmique Seconde

Le langage naturel est accessible à tous, même aux personnes qui ne connaissent pas la programmation.

Il permet de se concentrer sur la logique de l'algorithme plutôt que sur la syntaxe.

Idéal pour expliquer des concepts aux débutants.

Aucune contrainte de syntaxe stricte.

Liberté d'expression totale.

Adapté à la phase de conception d'un algorithme.

Le langage naturel peut prêter à confusion.

Moins de précision que le pseudo-code ou un langage de programmation.

Peut manquer de rigueur nécessaire à la programmation.

Impossible d'exécuter directement un algorithme écrit en langage naturel.

Nécessite une traduction en pseudo-code ou en langage de programmation.

On déclare les variables utilisées dans l'algorithme.

Exemple : "Soit x un nombre entier", "Soient a et b deux nombres réels".

On indique comment obtenir les données nécessaires.

Exemple : "Demander à l'utilisateur d'entrer un nombre", "Lire la valeur de x".

On décrit les opérations à effectuer.

Exemple : "Calculer la somme de a et b", "Multiplier x par 2".

On indique le résultat obtenu.

Exemple : "Afficher le résultat", "Retourner la valeur de y".

1. Début
2. Soit x un nombre
3. Demander à l'utilisateur d'entrer un nombre
4. Lire la valeur de x
5. Calculer le double de x en multipliant x par 2
6. Soit resultat le double de x
7. Afficher le resultat
8. Fin
                                        

• Étape 1-2 : Déclaration de la variable x
• Étape 3-4 : Saisie de la valeur par l'utilisateur
• Étape 5-6 : Calcul du double et stockage dans une variable
• Étape 7 : Affichage du résultat

Cet algorithme est simple mais illustre parfaitement l'utilisation du langage naturel.

1. Début
2. Soient a et b deux nombres
3. Demander à l'utilisateur d'entrer deux nombres
4. Lire la valeur de a
5. Lire la valeur de b
6. Si a est supérieur à b alors
7.    Stocker a dans la variable max
8. Sinon
9.    Stocker b dans la variable max
10. Fin Si
11. Afficher le maximum est max
12. Fin
                                        

L'instruction conditionnelle "Si...Alors...Sinon...Fin Si" permet de prendre une décision.

Elle teste une condition (a > b) et exécute des instructions différentes selon le résultat.

Les instructions indentées (lignes 7 et 9) sont exécutées seulement si la condition est vraie ou fausse.

1. Début
2. Soient n, i et somme des nombres entiers
3. Demander à l'utilisateur d'entrer un nombre n
4. Lire la valeur de n
5. Initialiser somme à 0
6. Initialiser i à 1
7. Tant que i est inférieur ou égal à n faire
8.    Ajouter i à somme
9.    Incrémenter i de 1
10. Fin Tant que
11. Afficher la somme des n premiers entiers est somme
12. Fin
                                        

La structure "Tant que...Faire...Fin Tant que" répète des instructions tant qu'une condition est vraie.

Ici, on ajoute chaque entier de 1 à n à la somme cumulative.

La variable i sert de compteur et assure que la boucle se termine après n itérations.

Choisir des mots qui expriment exactement ce que l'on veut dire.

Éviter les formulations ambigües ou vagues.

Exemples : "Calculer" plutôt que "Faire", "Afficher" plutôt que "Montrer".

Respecter la structure Entrée → Traitement → Sortie.

Numéroter les étapes pour une meilleure lisibilité.

Indenter les instructions imbriquées (conditions, boucles).

Utiliser des noms qui décrivent la fonction de la variable.

Exemples : "somme_totale" plutôt que "x", "note_eleve" plutôt que "n".

Assurer la cohérence des instructions.

Vérifier que toutes les variables sont correctement initialisées.

S'assurer que les boucles ont une condition d'arrêt.

• Donnée d'entrée : Le rayon du cercle
• Donnée de sortie : Le périmètre du cercle
• Opération : Appliquer la formule 2 × π × rayon

1. Début
2. Soit rayon un nombre réel
3. Soit perimetre un nombre réel
4. Soit pi le nombre 3.14159
5. Demander à l'utilisateur d'entrer le rayon du cercle
6. Lire la valeur de rayon
7. Calculer le perimetre en multipliant 2 par pi par rayon
8. Afficher le périmètre du cercle est perimetre
9. Fin
                                        

L'algorithme commence par déclarer les variables nécessaires.

La constante π est fixée à 3.14159.

La formule est appliquée pour calculer le périmètre.

Le résultat est ensuite affiché à l'utilisateur.

• Données d'entrée : Trois notes (n1, n2, n3)
• Données de sortie : La moyenne et le statut d'admission
• Opérations : Calcul de la moyenne, comparaison avec 10

1. Début
2. Soient note1, note2, note3 et moyenne des nombres réels
3. Demander à l'utilisateur d'entrer la première note
4. Lire la valeur de note1
5. Demander à l'utilisateur d'entrer la deuxième note
6. Lire la valeur de note2
7. Demander à l'utilisateur d'entrer la troisième note
8. Lire la valeur de note3
9. Calculer la moyenne en additionnant les trois notes et en divisant par 3
10. Si la moyenne est supérieure ou égale à 10 alors
11.    Afficher "L'élève est admis avec une moyenne de" suivi de la moyenne
12. Sinon
13.    Afficher "L'élève n'est pas admis avec une moyenne de" suivi de la moyenne
14. Fin Si
15. Fin
                                        

Langage naturel :

1. Soient a et b deux nombres
2. Demander à l'utilisateur d'entrer deux nombres
3. Lire a et b
4. Si a est supérieur à b alors
5.    Stocker a dans la variable max
6. Sinon
7.    Stocker b dans la variable max
8. Fin Si
9. Afficher le maximum est max
                                        

Pseudo-code :

ALGORITHME Maximum
    VARIABLES a, b, max : RÉEL
DEBUT
    AFFICHER "Entrez deux nombres"
    LIRE a, b
    SI a > b ALORS
        max ← a
    SINON
        max ← b
    FIN SI
    AFFICHER "Le maximum est", max
FIN
                                        

• Langage naturel : Meilleur pour expliquer aux débutants
• Pseudo-code : Plus proche de la programmation, syntaxe précise
• Langage de programmation : Directement exécutable

• Langage humain utilisé dans la vie courante
• Permet d'exprimer un algorithme de manière compréhensible
• Utilise des mots et phrases du langage courant

• Facilité de compréhension pour les débutants
• Liberté d'expression totale
• Adapté à la phase de conception d'un algorithme

• Possibilité d'ambiguïté
• Moins de précision que le pseudo-code
• Non exécutable directement