Conventions Algorithmiques (Tunisie 2024/2025)

Maîtrisez l’écriture des algorithmes selon les conventions officielles du Ministère de l’Éducation tunisien. Préparez-vous efficacement pour le bac !

Voir les vidéos explicatives Pratiquer avec des exercices

Conventions Algorithmiques

Un algorithme suit la structure suivante :

                        ALGORITHME Nom

                        DEBUT

                          Traitements

                        FIN

                        Déclaration des objets

                            Objet
                            Type / Nature

Recommandations : Respectez l’indentation et utilisez des noms significatifs pour les objets.

Type	Description
Entier	Nombre entier (ex. : 5, -10)
Réel	Nombre à virgule (ex. : 3.14)
Booléen	Vrai ou Faux
Caractère	Un seul caractère (ex. : 'A')
Chaîne de caractères	Séquence de caractères (ex. : "Bonjour")

Exemple :

                            nombre : Entier

                            prix : Réel

                            estValide : Booléen

                            lettre : Caractère

                            message : Chaîne

Tableaux

Objet	Type / Nature	Accès
Tableau unidimensionnel	`Tableau de N Type_élément`	`T[i]`
Tableau bidimensionnel	`Tableau de N lignes * M colonnes Type_élément`	`M[i,j]`

Enregistrements

Objet	Type / Nature	Accès
Enregistrement	`Enregistrement Nom_champ1 : Type_champ1; Nom_champ2 : Type_champ2; ... Fin`	`E.Nom_champ`

Fichiers

Objet	Type / Nature
Fichier texte	`Fichier Texte`
Fichier de données	`Fichier de Type_élément`

Exemple :

                            T : Tableau de 10 Entier

                            M : Tableau de 5 lignes * 3 colonnes Réel

                            Etudiant : Enregistrement

                              nom : Chaîne

                              note : Réel

                            Fin

                            F : Fichier de Entier

Opération	Syntaxe
Entrée	`Lire (Objet)`
Sortie	`Écrire ("Message", Objet, Expression)` `Écrire_nl ("Message", Objet, Expression)`
Affectation	`Objet ← Expression`

                            Lire (nombre)

                            Écrire ("Le résultat est : ", nombre * 2)

                            resultat ← nombre + 5

Type	Syntaxe
Simple	`Si Condition Alors Traitement FinSi`
Complète	`Si Condition Alors Traitement1 Sinon Traitement2 FinSi`
Généralisée	`Si Condition1 Alors Traitement1 Sinon Si Condition2 Alors Traitement2 ... [Sinon TraitementN] FinSi`
Choix multiples	`Selon Sélecteur Valeur1: Traitement1 ... [Sinon TraitementN] Fin Selon`

                            Si note >= 10 Alors

                              Écrire ("Réussi")

                            Sinon

                              Écrire ("Échoué")

                            FinSi

Type	Syntaxe
Pour	`Pour Compteur de Début à Fin [Pas = valeur_pas] Faire Traitement Fin Pour`
Tant que	`Tant que Condition Faire Traitement Fin Tant que`
Répéter	`Répéter Traitement Jusqu'à Condition`

                            Pour i de 1 à 5 Faire

                              Écrire (i)

                            Fin Pour

Type	Syntaxe	Remarque
Fonction	`Fonction Nom_fonction (pf1: type1, ...): Type_résultat DEBUT Traitement Retourner Résultat FIN`	Retourne un résultat simple
Procédure	`Procédure Nom_procédure (pf1: type1, ...) DEBUT Traitement FIN`	Pas de résultat retourné
Passage par référence	`@param`	Modifie la variable passée

                            Fonction Factorielle (n: Entier): Entier

                            DEBUT

                              Si n = 0 Alors

                                Retourner 1

                              Sinon

                                Retourner n * Factorielle(n-1)

                              FinSi

                            FIN

Arithmétiques

Opération	Opérateur
Somme	`+`
Soustraction	`-`
Multiplication	`*`
Division	`/`
Division entière	`Div`
Reste	`Mod`

Comparaison

Opération	Opérateur
Égal	`=`
Différent	`≠`
Strictement supérieur	`>`
Supérieur ou égal	`≥`
Strictement inférieur	`<`
Inférieur ou égal	`≤`
Appartient	`∈`

Logiques

Opération	Opérateur
Négation	`Non`
Conjonction	`Et`
Disjonction	`Ou`

Ensembles : {v1,v2,...}, [vi..vf]

Numériques

Fonction	Rôle
`Arrondi(x)`	Entier le plus proche
`RacineCarré(x)`	Racine carrée de x
`Aléa(vi, vf)`	Entier aléatoire dans [vi, vf]
`Ent(x)`	Partie entière de x
`Abs(x)`	Valeur absolue de x

Caractères

Fonction	Rôle
`Ord(c)`	Code ASCII de c
`Chr(d)`	Caractère du code ASCII d

Chaînes

Fonction	Rôle
`Long(ch)`	Longueur de ch
`Pos(ch1, ch2)`	Position de ch1 dans ch2
`Convch(x)`	Nombre en chaîne
`Estnum(ch)`	Vérifie si ch est numérique
`Valeur(ch)`	Chaîne en nombre
`Sous_chaine(ch, d, f)`	Extrait de d à f
`Effacer(ch, d, f)`	Supprime de d à f
`Majus(ch)`	Chaîne en majuscules

Fichiers de données

Fonction	Rôle
`Ouvrir("Chemin\Nom", Nom_logique, "Mode")`	Ouvre un fichier ("rb", "wb", "ab")
`Lire(Nom_logique, Objet)`	Lit un objet
`Ecrire(Nom_logique, Objet)`	Écrit un objet
`Fin_fichier(Nom_logique)`	Vérifie la fin du fichier
`Fermer(Nom_logique)`	Ferme le fichier

Fichiers textes

Fonction	Rôle
`Ouvrir("Chemin\Nom", Nom_logique, "Mode")`	Ouvre un fichier ("r", "w", "a")
`Lire(Nom_logique, ch)`	Lit tout le fichier
`Lire_ligne(Nom_logique, ch)`	Lit une ligne
`Ecrire(Nom_logique, ch)`	Écrit une chaîne
`Ecrire_nl(Nom_logique, ch)`	Écrit avec retour à la ligne
`Fin_fichier(Nom_logique)`	Vérifie la fin du fichier
`Fermer(Nom_logique)`	Ferme le fichier

Conventions Algorithmiques (Tunisie 2024/2025)

Conventions Algorithmiques

1. Forme générale d’un algorithme

2. Types de données simples

3. Structures de données

Tableaux

Enregistrements

Fichiers

4. Opérations élémentaires

5. Structures de contrôle conditionnelles

6. Structures de contrôle itératives

7. Modules (Fonctions et Procédures)

8. Opérateurs arithmétiques et logiques