Galerie d'exemples

Programmes prêts à l'emploi

Une collection de programmes EduCode pensée pour apprendre par la pratique. Copie le code, colle-le dans l'éditeur, exécute, modifie : c'est comme ça qu'on apprend.

Bonjour monde

Le programme traditionnel de tout débutant. Montre comment utiliser affiche avec du texte littéral.

affiche 'Bonjour le monde !'
                     affiche 'Bienvenue dans EduCode.'
                  

Pair ou impair

Utilisation de l'opérateur mod et d'une structure conditionnelle à deux branches.

n est un nombre
                     n vaut 7
                     si n mod 2 = 0 alors
                     affiche 'Pair'
                     sinon
                     affiche 'Impair'
                     fin si
                  

Tableau dynamique

Création, remplissage et parcours d'un tableau avec longueur.

t est un tableau
                     t ajoute 10
                     t ajoute 20
                     t ajoute 30
                     affiche 'Taille : ' + longueur(t)
                     pour i de 0 à longueur(t) - 1
                     affiche t[i]
                     fin pour
                  

Suite de Fibonacci

Illustre l'utilisation d'une variable temporaire pour permuter deux valeurs — un pattern courant en algorithmique.

x, b, temp est un nombre
                     x vaut 0
                     b vaut 1
                     affiche x
                     affiche b
                     répète 8 fois
                     temp vaut x + b
                     x vaut b
                     b vaut temp
                     affiche b
                     fin répète
                  

Table de multiplication (saisie)

Combine saisie utilisateur, boucle pour et concaténation de texte pour produire un affichage formaté.

n est un nombre
                     demande 'Quelle table ? (1-10)' dans n
                     affiche '--- Table de ' + n + ' ---'
                     pour i de 1 à 10
                     affiche n + ' × ' + i + ' = ' + n * i
                     fin pour
                  

Calcul de moyenne (saisie)

Programme interactif complet : boucle de saisie, accumulation dans une variable, calcul final. Montre comment utiliser convertir_texte pour construire un message d'invite dynamique.

somme, i, note est un nombre
                     titre est un texte
                     somme vaut 0
                     pour i de 1 à 5
                     titre vaut 'Note ' + convertir_texte(i)
                     demande titre dans note
                     somme vaut somme + note
                     fin pour
                     affiche 'Moyenne = ' + (somme / 5)
                  

Procédures & Encadrement

Exemple de composition de procédures : encadre appelle ligne. Illustre comment découper un programme en sous-tâches réutilisables.

procédure ligne(car)
                     affiche repeter_texte(car, 12)
                     fin procédure
                     procédure encadre(texte)
                     appelle ligne('═')
                     affiche '  ' + texte
                     appelle ligne('═')
                     fin procédure
                     appelle encadre('Bienvenue !')
                     appelle encadre('EduCode')
                  

Saisie utilisateur + Conditions

Programme interactif qui combine saisie de différents types (texte et nombre) et structure conditionnelle. Un bon exercice d'introduction pour les débutants.

prénom est un texte
                     age est un nombre
                     demande 'Quel est ton prénom ?' dans prenom
                     demande 'Quel est ton âge ?' dans age
                     affiche 'Bonjour, ' + prénom + ' !'
                     si age >= 18 alors
                     affiche 'Tu es majeur.'
                     sinon
                     affiche 'Tu es mineur. Il te reste ' + (18 - age) + ' an(s).'
                     fin si
                  

Tri à bulles

L'un des algorithmes de tri les plus pédagogiques. Combine procédure, boucles imbriquées, accès aux tableaux par index, et échange de valeurs via variable temporaire.

procédure tri_bulles(t)
                     n est un nombre
                     n vaut longueur(t)
                     pour i de 0 à n - 2
                     pour j de 0 à n - i - 2
                     si t[j] > t[j + 1] alors
                     tmp est un nombre
                     tmp vaut t[j]
                     t[j] vaut t[j + 1]
                     t[j + 1] vaut tmp
                     fin si
                     fin pour
                     fin pour
                     fin procédure
                     nombres est un tableau
                     nombres ajoute 5
                     nombres ajoute 2
                     nombres ajoute 8
                     nombres ajoute 1
                     appelle tri_bulles(nombres)
                     affiche nombres  // → [1, 2, 5, 8]
                  

Générateur de mots de passe

Boucles, concaténation texte, hasard, copier, longueur.

alphabet est un texte
                     alphabet vaut 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#'
                     fonction caractere_aleatoire()
                     // position aléatoire 1..longueur
                     i est un nombre
                     i vaut hasard(longueur(alphabet) - 1) + 1
                     retourne copier(alphabet, i, 1)
                     fin fonction
                     mdp est un texte
                     mdp vaut ''
                     n est un nombre
                     n vaut 12
                     pour k de 1 a n
                     mdp vaut mdp + caractere_aleatoire()
                     fin pour
                     affiche 'Mot de passe : ' + mdp
                  

Quizz

Programme de quiz à 5 questions avec score final. Utilise une fonction utilitaire normalise pour comparer les réponses sans tenir compte des espaces ni de la casse — une bonne pratique pour la robustesse.

score est un nombre
                     rep est un texte
                     score vaut 0
                     // Normalise : supprime espaces + met en minuscules
                     fonction normalise(t)
                     retourne supprime_espace(minuscules(t))
                     fin fonction
                     demande 'Capitale de la France ?' dans rep
                     si normalise(rep) = 'paris' alors
                     score vaut score + 1
                     fin si
                     demande 'Combien font 7 + 5 ?' dans rep
                     si normalise(rep) = '12' alors
                     score vaut score + 1
                     fin si
                     demande 'Mot-clé pour afficher ?' dans rep
                     si normalise(rep) = 'affiche' alors
                     score vaut score + 1
                     fin si
                     affiche 'Score : ' + convertir_texte(score) + ' / 3'
                     si score = 3 alors
                     affiche '🏆 Parfait !'
                     sinon
                     affiche 'Continue à t' + caractère(39) + 'entraîner !'
                     fin si
                  

Pyramide (1, 3, 5, … étoiles)

Affiche une pyramide d'étoiles avec des boucles imbriquées : une boucle pour les lignes et repeter_texte pour générer le nombre d'étoiles croissant à chaque ligne.

// i servira de compteur pour la boucle (ligne courante)
                     i est un nombre
                     // variable texte qui contiendra les espaces pour centrer les étoiles
                     espaces est un texte
                     // boucle de 1 à 5 pour créer une pyramide de hauteur 5
                     pour i de 1 a 5
                     // crée (5 - i) espaces pour centrer la ligne
                     espaces vaut repeter_texte(' ', 5 - i)
                     // affiche les espaces puis (2 * i - 1) étoiles pour former la pyramide
                     affiche espaces + repeter_texte('*', 2 * i - 1)
                     fin pour
                  

Convertir un entier en hexadécimal

Convertit un nombre entier en base 16 par divisions successives. Illustre l'opérateur mod, la division entière et la construction d'un résultat caractère par caractère.

n, reste est un nombre
                     hexa, chiffre est un texte
                     demande 'Entier à convertir (>= 0) : ' dans n
                     si n = 0 alors
                     affiche '0'
                     sinon
                     hexa vaut ''
                     tant que n > 0
                     reste vaut n mod 16
                     selon reste
                     cas 0: chiffre vaut '0'
                     cas 1: chiffre vaut '1'
                     cas 2: chiffre vaut '2'
                     cas 3: chiffre vaut '3'
                     cas 4: chiffre vaut '4'
                     cas 5: chiffre vaut '5'
                     cas 6: chiffre vaut '6'
                     cas 7: chiffre vaut '7'
                     cas 8: chiffre vaut '8'
                     cas 9: chiffre vaut '9'
                     cas 10: chiffre vaut 'A'
                     cas 11: chiffre vaut 'B'
                     cas 12: chiffre vaut 'C'
                     cas 13: chiffre vaut 'D'
                     cas 14: chiffre vaut 'E'
                     cas 15: chiffre vaut 'F'
                     fin selon
                     hexa vaut chiffre + hexa
                     n vaut (n - reste) / 16
                     fin tant que
                     affiche hexa
                     fin si
                  

Conversion en chiffres romains

Transforme un nombre en chiffres romains à l'aide d'une approche gloutonne : on soustrait la plus grande valeur possible tant que c'est possible. Un bon exercice de conditions multiples et de boucles.

n est un nombre
                     res est un texte
                     demande 'Entrer un nombre (1 à 3999) : ' dans n
                     si n < 1 ou n > 3999 alors
                     affiche 'Erreur : nombre hors limites'
                     terminer
                     fin si
                     res vaut ''
                     // ───── milliers ─────
                     tant que n >= 1000
                     res vaut res + 'M'
                     n vaut n - 1000
                     fin tant que
                     // ───── centaines ─────
                     si n >= 900 alors
                     res vaut res + 'CM'
                     n vaut n - 900
                     sinon
                     si n >= 500 alors
                     res vaut res + 'D'
                     n vaut n - 500
                     tant que n >= 100
                     res vaut res + 'C'
                     n vaut n - 100
                     fin tant que
                     sinon
                     si n >= 400 alors
                     res vaut res + 'CD'
                     n vaut n - 400
                     sinon
                     tant que n >= 100
                     res vaut res + 'C'
                     n vaut n - 100
                     fin tant que
                     fin si
                     fin si
                     fin si
                     // ───── dizaines ─────
                     si n >= 90 alors
                     res vaut res + 'XC'
                     n vaut n - 90
                     sinon
                     si n >= 50 alors
                     res vaut res + 'L'
                     n vaut n - 50
                     tant que n >= 10
                     res vaut res + 'X'
                     n vaut n - 10
                     fin tant que
                     sinon
                     si n >= 40 alors
                     res vaut res + 'XL'
                     n vaut n - 40
                     sinon
                     tant que n >= 10
                     res vaut res + 'X'
                     n vaut n - 10
                     fin tant que
                     fin si
                     fin si
                     fin si
                     // ───── unités ─────
                     si n = 9 alors
                     res vaut res + 'IX'
                     sinon
                     si n >= 5 alors
                     res vaut res + 'V'
                     n vaut n - 5
                     tant que n > 0
                     res vaut res + 'I'
                     n vaut n - 1
                     fin tant que
                     sinon
                     si n = 4 alors
                     res vaut res + 'IV'
                     sinon
                     tant que n > 0
                     res vaut res + 'I'
                     n vaut n - 1
                     fin tant que
                     fin si
                     fin si
                     fin si
                     affiche 'Chiffre romain : ' + res
                  

Conversion chiffres en lettres

Écrit un nombre en toutes lettres en décomposant centaines, dizaines et unités. Exemple avancé de gestion des cas particuliers du français (soixante-dix, quatre-vingts, etc.).

n, reste, cent, diz, uni est un nombre
                     res, part est un texte
                     // ── Fonction : mot pour 0..9
                     fonction mot_unite(x)
                     selon x
                     cas 0: retourne 'zéro'
                     cas 1: retourne 'un'
                     cas 2: retourne 'deux'
                     cas 3: retourne 'trois'
                     cas 4: retourne 'quatre'
                     cas 5: retourne 'cinq'
                     cas 6: retourne 'six'
                     cas 7: retourne 'sept'
                     cas 8: retourne 'huit'
                     cas 9: retourne 'neuf'
                     fin selon
                     retourne '' // sécurité
                     fin fonction
                     // ── Fonction : mot pour 0..19
                     fonction mot_0_19(x)
                     selon x
                     cas 0: retourne 'zéro'
                     cas 1: retourne 'un'
                     cas 2: retourne 'deux'
                     cas 3: retourne 'trois'
                     cas 4: retourne 'quatre'
                     cas 5: retourne 'cinq'
                     cas 6: retourne 'six'
                     cas 7: retourne 'sept'
                     cas 8: retourne 'huit'
                     cas 9: retourne 'neuf'
                     cas 10: retourne 'dix'
                     cas 11: retourne 'onze'
                     cas 12: retourne 'douze'
                     cas 13: retourne 'treize'
                     cas 14: retourne 'quatorze'
                     cas 15: retourne 'quinze'
                     cas 16: retourne 'seize'
                     cas 17: retourne 'dix-sept'
                     cas 18: retourne 'dix-huit'
                     cas 19: retourne 'dix-neuf'
                     fin selon
                     retourne '' // sécurité
                     fin fonction
                     // ── Procédure : ajoute une partie au résultat avec des tirets
                     procédure ajouter(p)
                     si res = '' alors
                     res vaut p
                     sinon
                     res vaut res + '-' + p
                     fin si
                     fin procédure
                     // ── Lecture
                     demande 'Entrer un nombre (0 à 999) : ' dans n
                     affiche convertir_nombre(n)
                     // ── Validation simple
                     si n < 0 ou n > 999 alors
                     affiche 'Erreur : hors limite'
                     terminer
                     fin si
                     // ── Cas 0 direct
                     si n = 0 alors
                     affiche 'zéro'
                     terminer
                     fin si
                     res vaut ''
                     // 1) Centaines
                     cent vaut (n - (n mod 100)) / 100
                     reste vaut n mod 100
                     si cent > 0 alors
                     si cent = 1 alors
                     appelle ajouter('cent')
                     sinon
                     // ex: deux-cent, trois-cent, ...
                     part vaut mot_unite(cent) + '-cent'
                     appelle ajouter(part)
                     fin si
                     fin si
                     // 2) Reste (0..99)
                     si reste = 0 alors
                     affiche res
                     terminer
                     fin si
                     // 0..19
                     si reste < 20 alors
                     appelle ajouter(mot_0_19(reste))
                     affiche res
                     terminer
                     fin si
                     // 20..99
                     diz vaut (reste - (reste mod 10)) / 10
                     uni vaut reste mod 10
                     // Base de dizaine (sans gérer encore 70/90)
                     selon diz
                     cas 2: part vaut 'vingt'
                     cas 3: part vaut 'trente'
                     cas 4: part vaut 'quarante'
                     cas 5: part vaut 'cinquante'
                     cas 6: part vaut 'soixante'
                     cas 7: part vaut 'soixante'       // 70..79 = 60 + (10..19)
                     cas 8: part vaut 'quatre-vingt'
                     cas 9: part vaut 'quatre-vingt'   // 90..99 = 80 + (10..19)
                     fin selon
                     // Cas 70 et 90 : on transforme l’unité en 10..19
                     si diz = 7 ou diz = 9 alors
                     uni vaut uni + 10
                     fin si
                     // Si on est dans 20..69 et unité = 1, on peut faire "vingt-et-un", etc.
                     // Cas du "et-un" (21, 31, 41, 51, 61)
                     si uni = 1 alors
                     si diz >= 2 et diz <= 6 alors
                     appelle ajouter(part + '-et-un')
                     affiche res
                     terminer
                     fin si
                     fin si
                     // Unité = 0 : ex 20, 30, 40, 80...
                     si uni = 0 alors
                     appelle ajouter(part)
                     affiche res
                     terminer
                     fin si
                     // Unité 1..9 (cas normal hors 70/90)
                     si uni < 10 alors
                     appelle ajouter(part + '-' + mot_unite(uni))
                     affiche res
                     terminer
                     fin si
                     // Unité 10..19 (70/90, ou 71..79 / 91..99)
                     appelle ajouter(part + '-' + mot_0_19(uni))
                     affiche res
                  

Jeu du morpoin avec bot

Le morpion (tic-tac-toe) jouable contre un bot. Combine tableau pour la grille, saisie utilisateur, détection des conditions de victoire et logique de l'adversaire automatique.

// Joueur X : humain
                     // Joueur O : bot
                     grille est un tableau
                     i, ligne, colonne, tour est un nombre
                     joueur est un texte
                     gagne est un booléen
                     // Initialisation
                     i vaut 0
                     tant que i < 9
                     grille ajoute ' '
                     i vaut i + 1
                     fin tant que
                     joueur vaut 'X'
                     tour vaut 0
                     gagne vaut faux
                     // Affichage
                     procédure afficher_grille
                     affiche grille[0] + ' | ' + grille[1] + ' | ' + grille[2]
                     affiche '---------'
                     affiche grille[3] + ' | ' + grille[4] + ' | ' + grille[5]
                     affiche '---------'
                     affiche grille[6] + ' | ' + grille[7] + ' | ' + grille[8]
                     fin procédure
                     // Victoire ─────
                     fonction victoire(j)
                     si grille[0] = j et grille[1] = j et grille[2] = j alors
                     retourne vrai
                     fin si
                     si grille[3] = j et grille[4] = j et grille[5] = j alors
                     retourne vrai
                     fin si
                     si grille[6] = j et grille[7] = j et grille[8] = j alors
                     retourne vrai
                     fin si
                     si grille[0] = j et grille[3] = j et grille[6] = j alors
                     retourne vrai
                     fin si
                     si grille[1] = j et grille[4] = j et grille[7] = j alors
                     retourne vrai
                     fin si
                     si grille[2] = j et grille[5] = j et grille[8] = j alors
                     retourne vrai
                     fin si
                     si grille[0] = j et grille[4] = j et grille[8] = j alors
                     retourne vrai
                     fin si
                     si grille[2] = j et grille[4] = j et grille[6] = j alors
                     retourne vrai
                     fin si
                     retourne faux
                     fin fonction
                     // Bot : joue une seule case
                     fonction bot_joue()
                     i vaut 0
                     tant que i < 9
                     si grille[i] = ' ' alors
                     grille[i] vaut 'O'
                     retourne vrai
                     fin si
                     i vaut i + 1
                     fin tant que
                     retourne faux
                     fin fonction
                     // Boucle principale
                     tant que tour < 9 et gagne = faux
                     appelle afficher_grille
                     si joueur = 'X' alors
                     affiche 'Joueur X (ligne 1-3, colonne 1-3)'
                     demande 'Ligne : ' dans ligne
                     demande 'Colonne : ' dans colonne
                     ligne vaut ligne - 1
                     colonne vaut colonne - 1
                     i vaut ligne * 3 + colonne
                     si i < 0 ou i > 8 alors
                     affiche 'Position invalide'
                     sinon
                     si grille[i] <> ' ' alors
                     affiche 'Case déjà occupée'
                     sinon
                     grille[i] vaut 'X'
                     tour vaut tour + 1
                     si victoire('X') alors
                     appelle afficher_grille
                     affiche '🎉 Joueur X a gagné !'
                     gagne vaut vrai
                     sinon
                     joueur vaut 'O'
                     fin si
                     fin si
                     fin si
                     sinon
                     affiche '🤖 Le bot joue...'
                     si bot_joue() alors
                     tour vaut tour + 1
                     si victoire('O') alors
                     appelle afficher_grille
                     affiche '🤖 Le bot a gagné !'
                     gagne vaut vrai
                     sinon
                     joueur vaut 'X'
                     fin si
                     sinon
                     // sécurité
                     tour vaut 9
                     fin si
                     fin si
                     fin tant que
                     si gagne = faux alors
                     appelle afficher_grille
                     affiche 'Match nul 🤝'
                     fin si
                  

Lancer de dé

Simule le lancer d'un dé à six faces avec hasard, puis affiche le résultat. Une introduction simple à l'aléatoire et aux conditions.

face est un nombre
                     face vaut hasard(1, 6)
                     selon face
                     cas 1:
                     affiche '+-----+'
                     affiche '|     |'
                     affiche '|  o  |'
                     affiche '|     |'
                     affiche '+-----+'
                     cas 2:
                     affiche '+-----+'
                     affiche '| o   |'
                     affiche '|     |'
                     affiche '|   o |'
                     affiche '+-----+'
                     cas 3:
                     affiche '+-----+'
                     affiche '| o   |'
                     affiche '|  o  |'
                     affiche '|   o |'
                     affiche '+-----+'
                     cas 4:
                     affiche '+-----+'
                     affiche '| o o |'
                     affiche '|     |'
                     affiche '| o o |'
                     affiche '+-----+'
                     cas 5:
                     affiche '+-----+'
                     affiche '| o o |'
                     affiche '|  o  |'
                     affiche '| o o |'
                     affiche '+-----+'
                     cas 6:
                     affiche '+-----+'
                     affiche '| o o |'
                     affiche '| o o |'
                     affiche '| o o |'
                     affiche '+-----+'
                     fin selon
                  

Escape Game

Un jeu d'évasion textuel complet : le joueur explore des salles, ramasse des objets et résout des énigmes. Projet ambitieux mêlant état du jeu, boucle principale, conditions et inventaire.

// ---------- ÉTAT DU JEU ----------
                     lieu est un nombre
                     lieu vaut 0 // 0 = cellule, 1 = bureau, 2 = couloir, 3 = sortie
                     inventaire est un tableau
                     cle_pris, code_trouve est un booléen
                     cle_pris vaut faux
                     porte_ouverte vaut faux
                     code_trouve vaut faux
                     // ---------- OUTILS ----------
                     fonction a_objet(obj)
                     retourne contient(inventaire, obj)
                     fin fonction
                     procédure ajouter_objet(obj)
                     si a_objet(obj) = faux alors
                     inventaire ajoute obj
                     affiche 'Objet ajouté : ' + obj
                     fin si
                     fin procédure
                     procédure afficher_inventaire()
                     affiche 'Inventaire :'
                     si longueur(inventaire) = 0 alors
                     affiche '(vide)'
                     sinon
                     pour i de 0 a longueur(inventaire) - 1
                     affiche '- ' + inventaire[i]
                     fin pour
                     fin si
                     fin procédure
                     // ---------- SCÈNES ----------
                     procédure scene_cellule()
                     affiche ''
                     affiche 'Tu es enfermé dans une cellule.'
                     affiche '1: Examiner la porte'
                     affiche '2: Regarder sous le lit'
                     affiche '3: Inventaire'
                     choix est un nombre
                     demande 'Ton choix (1, 2 ou 3)' dans choix
                     selon choix
                     cas 1 :
                     si cle_pris alors
                     porte_ouverte vaut vrai
                     affiche 'Tu ouvres la porte avec la clé.'
                     lieu vaut 2
                     sinon
                     affiche 'La porte est verrouillée.'
                     fin si
                     cas 2 :
                     si cle_pris = faux alors
                     affiche 'Tu trouves une petite clé.'
                     cle_pris vaut vrai
                     appelle ajouter_objet('clé')
                     sinon
                     affiche 'Il n''y a plus rien.'
                     fin si
                     cas 3 :
                     appelle afficher_inventaire()
                     sinon selon :
                     affiche 'Choix invalide.'
                     fin selon
                     fin procédure
                     procédure scene_bureau()
                     affiche ''
                     affiche 'Tu es dans un bureau abandonné.'
                     affiche '1: Fouiller le bureau'
                     affiche '2: Lire un papier'
                     affiche '3: Retourner au couloir'
                     choix est un nombre
                     demande 'Ton choix (1, 2 ou 3)' dans choix
                     selon choix
                     cas 1 :
                     affiche 'Tu ne trouves rien d'+ caractère(39) +'utile.'
                     cas 2 :
                     si code_trouve = faux alors
                     affiche 'Le papier indique : CODE = 1234'
                     code_trouve vaut vrai
                     appelle ajouter_objet('code')
                     sinon
                     affiche 'Tu connais déjà le code.'
                     fin si
                     cas 3 :
                     lieu vaut 2
                     sinon selon :
                     affiche 'Choix invalide.'
                     fin selon
                     fin procédure
                     procédure scene_couloir()
                     affiche ''
                     affiche 'Tu es dans le couloir.'
                     affiche '1: Aller au bureau'
                     affiche '2: Aller à la sortie'
                     affiche '3: Inventaire'
                     choix est un nombre
                     demande 'Ton choix (1, 2 ou 3)' dans choix
                     selon choix
                     cas 1 :
                     lieu vaut 1
                     cas 2 :
                     lieu vaut 3
                     cas 3 :
                     appelle afficher_inventaire()
                     sinon selon :
                     affiche 'Choix invalide.'
                     fin selon
                     fin procédure
                     procédure scene_sortie()
                     affiche ''
                     affiche 'Une porte blindée bloque la sortie.'
                     affiche '1: Entrer un code'
                     affiche '2: Retourner au couloir'
                     choix est un nombre
                     demande 'Ton choix (1 ou 2)' dans choix
                     selon choix
                     cas 1 :
                     si code_trouve alors
                     affiche 'TU ES LIBRE !'
                     arrete
                     sinon
                     affiche 'Tu ne connais pas le code.'
                     fin si
                     cas 2 :
                     lieu vaut 2
                     sinon selon :
                     affiche 'Choix invalide.'
                     fin selon
                     fin procédure
                     // ---------- BOUCLE PRINCIPALE ----------
                     tant que vrai
                     selon lieu
                     cas 0 :
                     appelle scene_cellule()
                     cas 1 :
                     appelle scene_bureau()
                     cas 2 :
                     appelle scene_couloir()
                     cas 3 :
                     appelle scene_sortie()
                     sinon selon :
                     affiche 'Erreur inconnue.'
                     arrete
                     fin selon
                     fin tant que
                  

Quiz sur la syntaxe et les règles d'EduCode

Un quiz pour tester sa connaissance de la syntaxe EduCode elle-même. Met en pratique les questions à choix, la vérification des réponses et le calcul d'un score final.

// ============================================================
                     //  QCM : CONNAIS-TU LE LANGAGE EDUCODE ? 🎓
                     //  Un quiz sur la syntaxe et les règles d'EduCode.
                     // ============================================================
                     affiche '=============================================='
                     affiche '   🎓 QCM SPÉCIAL LANGAGE EDUCODE'
                     affiche '=============================================='
                     affiche ''
                     affiche 'Teste tes connaissances sur EduCode !'
                     affiche 'Choisis la bonne réponse pour chaque question.'
                     affiche ''
                     score est un nombre
                     score vaut 0
                     choix est un nombre
                     choix vaut 0
                     // ---------------------------------------------------------
                     //  Q1 — déclaration de variable  (réponse : option 2)
                     // ---------------------------------------------------------
                     affiche '----------------------------------------------'
                     affiche 'Q1. Comment déclare-t-on une variable nombre ?'
                     choisir ['x = 5', 'x est un nombre', 'nombre x', 'var x'] dans choix
                     si choix = 2 alors
                     affiche '✅ Correct ! On écrit : x est un nombre'
                     score vaut score + 1
                     sinon
                     affiche '❌ Raté. La bonne forme est : x est un nombre'
                     fin si
                     affiche ''
                     // ---------------------------------------------------------
                     //  Q2 — délimiteur de texte  (réponse : option 3)
                     // ---------------------------------------------------------
                     affiche '----------------------------------------------'
                     affiche 'Q2. Comment écrit-on une chaîne de texte ?'
                     choisir ['"bonjour"', '`bonjour`', '''bonjour''', '<bonjour>'] dans choix
                     si choix = 3 alors
                     affiche '✅ Correct ! Le texte s''écrit entre apostrophes.'
                     score vaut score + 1
                     sinon
                     affiche '❌ Raté. En EduCode, le texte est entre apostrophes.'
                     fin si
                     affiche ''
                     // ---------------------------------------------------------
                     //  Q3 — affectation  (réponse : option 1)
                     // ---------------------------------------------------------
                     affiche '----------------------------------------------'
                     affiche 'Q3. Quel mot-clé donne une valeur à une variable ?'
                     choisir ['vaut', 'égal', 'devient', 'prend'] dans choix
                     si choix = 1 alors
                     affiche '✅ Correct ! Exemple : x vaut 10'
                     score vaut score + 1
                     sinon
                     affiche '❌ Raté. On utilise "vaut" : x vaut 10'
                     fin si
                     affiche ''
                     // ---------------------------------------------------------
                     //  Q4 — fermeture de boucle pour  (réponse : option 2)
                     // ---------------------------------------------------------
                     affiche '----------------------------------------------'
                     affiche 'Q4. Comment ferme-t-on une boucle "pour" ?'
                     choisir ['fin', 'fin pour', 'finpour', 'pour fin'] dans choix
                     si choix = 2 alors
                     affiche '✅ Correct ! Une boucle pour se ferme par "fin pour".'
                     score vaut score + 1
                     sinon
                     affiche '❌ Raté. On écrit "fin pour".'
                     fin si
                     affiche ''
                     // ---------------------------------------------------------
                     //  Q5 — premier index d'un tableau  (réponse : option 1)
                     // ---------------------------------------------------------
                     affiche '----------------------------------------------'
                     affiche 'Q5. Quel est l''index du PREMIER élément d''un tableau ?'
                     choisir ['0', '1', '-1', 'le dernier'] dans choix
                     si choix = 1 alors
                     affiche '✅ Correct ! Les tableaux commencent à l''index 0.'
                     score vaut score + 1
                     sinon
                     affiche '❌ Raté. Le premier élément est à l''index 0.'
                     fin si
                     affiche ''
                     // ---------------------------------------------------------
                     //  Q6 — ajouter à un tableau  (réponse : option 3)
                     // ---------------------------------------------------------
                     affiche '----------------------------------------------'
                     affiche 'Q6. Quel mot-clé ajoute un élément à un tableau ?'
                     choisir ['insère', 'pousse', 'ajoute', 'plus'] dans choix
                     si choix = 3 alors
                     affiche '✅ Correct ! Exemple : maListe ajoute 42'
                     score vaut score + 1
                     sinon
                     affiche '❌ Raté. Le mot-clé est "ajoute".'
                     fin si
                     affiche ''
                     // ---------------------------------------------------------
                     //  Q7 — fonction de longueur  (réponse : option 2)
                     // ---------------------------------------------------------
                     affiche '----------------------------------------------'
                     affiche 'Q7. Quelle fonction donne la taille d''un tableau ?'
                     choisir ['taille_de()', 'longueur()', 'size()', 'compte()'] dans choix
                     si choix = 2 alors
                     affiche '✅ Correct ! longueur(monTableau) renvoie sa taille.'
                     score vaut score + 1
                     sinon
                     affiche '❌ Raté. La fonction est longueur().'
                     fin si
                     affiche ''
                     // ---------------------------------------------------------
                     //  Q8 — pourquoi "a" pose problème  (réponse : option 2)
                     // ---------------------------------------------------------
                     affiche '----------------------------------------------'
                     affiche 'Q8. Pourquoi ne peut-on PAS nommer une variable "a" ?'
                     choisir ['Trop court', 'C''est un mot réservé', 'Interdit par la loi', 'Ça ralentit le code'] dans choix
                     si choix = 2 alors
                     affiche '✅ Correct ! "a" est réservé (pour : pour i de 1 à n).'
                     score vaut score + 1
                     sinon
                     affiche '❌ Raté. "a" est un mot-clé réservé du langage.'
                     fin si
                     affiche ''
                     // ---------------------------------------------------------
                     //  Résultat final
                     // ---------------------------------------------------------
                     affiche '=============================================='
                     affiche '   🏁 RÉSULTAT FINAL'
                     affiche '=============================================='
                     ligneScore est un texte
                     ligneScore vaut 'Ton score : '
                     ligneScore ajoute score
                     ligneScore ajoute ' / 8'
                     affiche ligneScore
                     pourcent est un nombre
                     pourcent vaut arrondi(score * 100 / 8)
                     lignePct est un texte
                     lignePct vaut 'Soit '
                     lignePct ajoute pourcent
                     lignePct ajoute ' % de bonnes réponses.'
                     affiche lignePct
                     affiche ''
                     si score = 8 alors
                     affiche '🏆 Sans faute ! Tu maîtrises EduCode à fond !'
                     sinon
                     si score >= 5 alors
                     affiche '👍 Bien joué ! Tu connais bien le langage.'
                     sinon
                     si score >= 3 alors
                     affiche '📘 Pas mal, mais révise encore un peu la syntaxe.'
                     sinon
                     affiche '📚 Il faut reprendre les bases d''EduCode !'
                     fin si
                     fin si
                     fin si
                     affiche '=============================================='
                  

Sokoban

Le célèbre jeu de pousse-caisses. Projet complet illustrant la représentation d'une grille en tableau, les fonctions de coordonnées, la détection de collisions et la condition de victoire.

                        map_lignes, grille, cibles est un tableau
                        largeur, hauteur est un nombre
                        px, py est un nombre
                        fonction idx_de(x, y)
                        retourne y * largeur + x
                        fin fonction
                        fonction cellule(x, y)
                        retourne grille[idx_de(x, y)]
                        fin fonction
                        // Convertit un caractère interne en emoji pour l'affichage
                        fonction emoji_de(c)
                        si c = '#' alors
                        retourne '🟫'
                        fin si
                        si c = '.' alors
                        retourne '🎯'
                        fin si
                        si c = '$' alors
                        retourne '📦'
                        fin si
                        si c = '*' alors
                        retourne '✅'
                        fin si
                        si c = '@' alors
                        retourne '🙂'
                        fin si
                        si c = '+' alors
                        retourne '😎'
                        fin si
                        retourne '🟩'
                        fin fonction
                        procédure affiche_grille()
                        y, x est un nombre
                        ligne, c est un texte
                        ind est un nombre
                        affiche ''
                        pour y de 0 à hauteur - 1
                        ligne vaut ''
                        pour x de 0 à largeur - 1
                        ind vaut idx_de(x, y)
                        c vaut grille[ind]
                        ligne vaut ligne + emoji_de(c)
                        fin pour
                        affiche ligne
                        fin pour
                        fin procédure
                        fonction victoire()
                        ind, total est un nombre
                        total vaut largeur * hauteur
                        pour ind de 0 à total - 1
                        si cibles[ind] = vrai alors
                        si grille[ind] <> '*' alors
                        retourne faux
                        fin si
                        fin si
                        fin pour
                        retourne vrai
                        fin fonction
                        procédure charger_niveau()
                        vide map_lignes
                        map_lignes[0] vaut '##########'
                        map_lignes[1] vaut '#   .    #'
                        map_lignes[2] vaut '#   $    #'
                        map_lignes[3] vaut '#  $$    #'
                        map_lignes[4] vaut '#   @    #'
                        map_lignes[5] vaut '#   .    #'
                        map_lignes[6] vaut '#   .    #'
                        map_lignes[7] vaut '##########'
                        largeur vaut longueur(map_lignes[0])
                        hauteur vaut longueur(map_lignes)
                        vide grille
                        vide cibles
                        y, x est un nombre
                        ind est un nombre
                        ligneTexte, ch est un texte
                        px vaut 0
                        py vaut 0
                        pour y de 0 à hauteur - 1
                        ligneTexte vaut map_lignes[y]
                        pour x de 0 à largeur - 1
                        ch vaut copier(ligneTexte, x + 1, 1)
                        ind vaut idx_de(x, y)
                        grille[ind] vaut ch
                        si ch = '.' ou ch = '*' ou ch = '+' alors
                        cibles[ind] vaut vrai
                        sinon
                        cibles[ind] vaut faux
                        fin si
                        si ch = '@' ou ch = '+' alors
                        px vaut x
                        py vaut y
                        fin si
                        fin pour
                        fin pour
                        fin procédure
                        procédure tente_deplacer(dx, dy)
                        tx, ty, bx, by est un nombre
                        ici, cible, derriere est un texte
                        indIci, indCible, indDerriere est un nombre
                        tx vaut px + dx
                        ty vaut py + dy
                        si tx < 0 ou tx >= largeur ou ty < 0 ou ty >= hauteur alors
                        retourne 0
                        fin si
                        ici vaut cellule(px, py)
                        cible vaut cellule(tx, ty)
                        si cible = '#' alors
                        retourne 0
                        fin si
                        si cible = ' ' ou cible = '.' alors
                        indIci vaut idx_de(px, py)
                        si ici = '+' alors
                        grille[indIci] vaut '.'
                        sinon
                        grille[indIci] vaut ' '
                        fin si
                        indCible vaut idx_de(tx, ty)
                        si cible = '.' alors
                        grille[indCible] vaut '+'
                        sinon
                        grille[indCible] vaut '@'
                        fin si
                        px vaut tx
                        py vaut ty
                        retourne 0
                        fin si
                        si cible = '$' ou cible = '*' alors
                        bx vaut tx + dx
                        by vaut ty + dy
                        si bx < 0 ou bx >= largeur ou by < 0 ou by >= hauteur alors
                        retourne 0
                        fin si
                        derriere vaut cellule(bx, by)
                        si derriere <> ' ' et derriere <> '.' alors
                        retourne 0
                        fin si
                        indDerriere vaut idx_de(bx, by)
                        si derriere = '.' alors
                        grille[indDerriere] vaut '*'
                        sinon
                        grille[indDerriere] vaut '$'
                        fin si
                        indCible vaut idx_de(tx, ty)
                        si cible = '*' alors
                        grille[indCible] vaut '+'
                        sinon
                        grille[indCible] vaut '@'
                        fin si
                        indIci vaut idx_de(px, py)
                        si ici = '+' alors
                        grille[indIci] vaut '.'
                        sinon
                        grille[indIci] vaut ' '
                        fin si
                        px vaut tx
                        py vaut ty
                        fin si
                        fin procédure
                        // ---------- MAIN ----------
                        appelle charger_niveau()
                        continuer est un booléen
                        continuer vaut vrai
                        choix est un nombre
                        choix vaut 1
                        dx, dy est un nombre
                        lib est un texte
                        ancienX, ancienY est un nombre
                        cibleX, cibleY est un nombre
                        tant que continuer
                        affiche_grille()
                        si victoire() alors
                        affiche ''
                        affiche '✅ BRAVO ! Toutes les caisses sont sur les cibles !'
                        affiche 'Choisis 🔄 Recommencer ou ❌ Quitter.'
                        fin si
                        affiche ''
                        choisir ['⬆️ Haut', '⬇️ Bas', '⬅️ Gauche', '➡️ Droite', '🔄 Recommencer', '❌ Quitter'] dans choix
                        si choix = 6 alors
                        continuer vaut faux
                        sinon
                        si choix = 5 alors
                        appelle charger_niveau()
                        sinon
                        dx vaut 0
                        dy vaut 0
                        lib vaut ''
                        selon choix
                        cas 1:
                        dx vaut 0
                        dy vaut - 1
                        lib vaut 'vers le haut'
                        cas 2:
                        dx vaut 0
                        dy vaut 1
                        lib vaut 'vers le bas'
                        cas 3:
                        dx vaut - 1
                        dy vaut 0
                        lib vaut 'vers la gauche'
                        cas 4:
                        dx vaut 1
                        dy vaut 0
                        lib vaut 'vers la droite'
                        sinon selon:
                        lib vaut ''
                        fin selon
                        si lib <> '' alors
                        ancienX vaut px
                        ancienY vaut py
                        cibleX vaut px + dx
                        cibleY vaut py + dy
                        affiche ''
                        affiche 'Tu m' + caractère(39) + 'as demandé d' + caractère(39) + 'aller ' + lib + ' (cible : ' + cibleX + ',' + cibleY + ')'
                        appelle tente_deplacer(dx, dy)
                        affiche 'Voici ta nouvelle position : (' + px + ',' + py + ')'
                        si px = ancienX et py = ancienY alors
                        affiche 'Déplacement impossible (mur ou caisse bloquée).'
                        fin si
                        fin si
                        fin si
                        fin si
                        fin tant que
                        affiche 'Au revoir !'
                     

Chi-Fou-Mi

Pierre-feuille-ciseaux contre l'ordinateur. Combine le choix du joueur, un coup aléatoire du bot via hasard et une série de conditions pour déterminer le gagnant.

                           // Jeu : Chi-Fou-Mi
                           my, bot est un nombre
                           choisir ['✊ Pierre', '✋ Feuille', '✌️ Ciseaux'] dans my
                           bot vaut hasard(1, 3)
                           si my = 1 alors
                           affiche '🤪 Joueur : ✊ Pierre'
                           sinon
                           si my = 2 alors
                           affiche '🤪 Joueur : ✋ Feuille'
                           sinon
                           si my = 3 alors
                           affiche '🤪 Joueur : ✌️ Ciseaux'
                           fin si
                           fin si
                           fin si
                           si bot = 1 alors
                           affiche '🤖 Bot : ✊ Pierre'
                           sinon
                           si bot = 2 alors
                           affiche '🤖 Bot : ✋ Feuille'
                           sinon
                           affiche '🤖 Bot : ✌️ Ciseaux'
                           fin si
                           fin si
                           si my = bot alors
                           affiche '🤓 Égalité !'
                           sinon
                           si (my = 1 et bot = 3) ou (my = 2 et bot = 1) ou (my = 3 et bot = 2) alors
                           affiche '🤪 Bravo, tu gagnes !'
                           sinon
                           affiche '😭 Perdu… le bot gagne.'
                           fin si
                           fin si
                        

Prêt à coder ?

Copie l'un des exemples ci-dessus, lance EduCode, colle le code dans l'éditeur et appuie sur Exécuter. Modifie ensuite une valeur, ajoute une condition, change un message — c'est en transformant le code qu'on l'apprend vraiment.

Télécharger EduCode v1.9