Programmes prêts à l'emploi

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

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

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

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

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

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é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')

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

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]

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

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

// 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

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

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

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

// 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

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

// ---------- É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

// ============================================================ // 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 '=============================================='

// ================================================== // GENERATEUR DE LABYRINTHE // Algorithme : backtracking iteratif (avec pile) // ================================================== // ---- Reglages : nombre de cellules ---- cellW, cellH, gW, gH, curX, curY, nbVisitees, total est un nombre cellW vaut 8 cellH vaut 6 // Dimensions de la grille affichee (murs inclus) gW vaut cellW * 2 + 1 gH vaut cellH * 2 + 1 // ---- Grille pleine de murs : 0 = mur, 1 = chemin ---- grille, visite, pile est un tableau pour y de 0 a gH - 1 ligne est un tableau pour x de 0 a gW - 1 ligne ajoute 0 fin pour grille ajoute ligne fin pour // ---- Cellules visitees ---- pour cy de 0 a cellH - 1 l est un tableau pour cx de 0 a cellW - 1 l ajoute 0 fin pour visite ajoute l fin pour // ---- Pile : chaque cellule est encodee en cy * cellW + cx ---- curX vaut 0 curY vaut 0 visite[curY][curX] vaut 1 grille[curY * 2 + 1][curX * 2 + 1] vaut 1 pile ajoute curY * cellW + curX nbVisitees vaut 1 total vaut cellW * cellH // ---- Boucle de backtracking ---- tant que nbVisitees < total // Voisins non visites de la cellule courante voisinsX, voisinsY est un tableau vide voisinsX vide voisinsY // Haut si curY > 0 alors si visite[curY - 1][curX] = 0 alors voisinsX ajoute curX voisinsY ajoute curY - 1 fin si fin si // Bas si curY < cellH - 1 alors si visite[curY + 1][curX] = 0 alors voisinsX ajoute curX voisinsY ajoute curY + 1 fin si fin si // Gauche si curX > 0 alors si visite[curY][curX - 1] = 0 alors voisinsX ajoute curX - 1 voisinsY ajoute curY fin si fin si // Droite si curX < cellW - 1 alors si visite[curY][curX + 1] = 0 alors voisinsX ajoute curX + 1 voisinsY ajoute curY fin si fin si nbVoisins est un nombre nbVoisins vaut longueur(voisinsX) si nbVoisins = 0 alors // Cul-de-sac : on depile (backtrack) supprime pile longueur(pile) - 1 si longueur(pile) > 0 alors codeHaut est un nombre codeHaut vaut dernier(pile) curY vaut arrondi_inferieur(codeHaut / cellW) curX vaut codeHaut mod cellW fin si sinon // On choisit un voisin au hasard choix, nx, ny, murX, murY est un nombre choix vaut hasard(0, nbVoisins - 1) nx vaut voisinsX[choix] ny vaut voisinsY[choix] // On abat le mur entre courante et voisin murX vaut curX + nx + 1 murY vaut curY + ny + 1 grille[ny * 2 + 1][nx * 2 + 1] vaut 1 grille[murY][murX] vaut 1 visite[ny][nx] vaut 1 nbVisitees vaut nbVisitees + 1 pile ajoute ny * cellW + nx curX vaut nx curY vaut ny fin si fin tant que pour y de 0 a gH - 1 rendu est un texte rendu vaut '' pour x de 0 a gW - 1 si grille[y][x] = 1 alors si y = 1 et x = 1 alors rendu vaut rendu + '😎' sinon si y = gH - 2 et x = gW - 2 alors rendu vaut rendu + '🚪' sinon rendu vaut rendu + '⚪' fin si fin si sinon rendu vaut rendu + '⬛' fin si fin pour affiche rendu fin pour

texte vaut 'Le langage EduCode est un pseudo-code exécutable. Il ressemble volontairement à ce qu''un professeur écrirait au tableau pour expliquer un algorithme — sauf qu''il peut être lancé directement dans l''éditeur. Cette proximité entre le raisonnement naturel et le code exécutable est au cœur de la démarche pédagogique.' // Nombre de caractères maximum largeurMax est une constante vaut 50 mots est un tableau mots vaut decouper(texte, ' ') resultat, ligne est un texte pour i de 0 à longueur(mots) - 1 motCourant est un texte motCourant vaut mots[i] si longueur(ligne) = 0 alors ligne vaut motCourant sinon si longueur(ligne) + 1 + longueur(motCourant) > largeurMax alors resultat vaut resultat + ligne + #10 ligne vaut motCourant sinon ligne vaut ligne + ' ' + motCourant fin si fin si fin pour affiche resultat + ligne

affiche '📐 TRIPLETS DE PYTHAGORE 📐' affiche '' N, compteur est un nombre affiche 'Chercher jusqu''à quel nombre ?' demande 'Nombre : ' dans N affiche '' compteur vaut 0 pour va de 1 a N pour vb de va a N pour vc de vb a N carre est un nombre carre vaut va * va + vb * vb si carre = vc * vc alors compteur vaut compteur + 1 affiche '✅ ' + va + '² + ' + vb + '² = ' + vc + '²' affiche ' 👉 ' + va + ' x ' + va + ' + ' + vb + ' x ' + vb + ' = ' + vc + ' x ' + vc affiche ' 🔢 ' + (va * va) + ' + ' + (vb * vb) + ' = ' + (vc * vc) affiche '' fin si fin pour fin pour fin pour affiche '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━' si compteur = 0 alors affiche '❌ Aucun triplet trouvé jusqu''à ' + N sinon affiche '🏆 ' + compteur + ' triplet(s) trouvé(s) jusqu''à ' + N + ' !' fin si

// Générateur de Sudoku 9×9 // Initialisation grille est un tableau i, j, cases_a_vider est un nombre // Suppression de cases (difficulté) cases_a_vider vaut 50 // Création d'une grille vide 9×9 pour i de 0 à 8 ligne est un tableau pour j de 0 à 8 ligne ajoute 0 fin pour grille ajoute ligne fin pour // Remplissage mathématique valide pour i de 0 à 8 ligne est un tableau ligne vaut grille[i] pour j de 0 à 8 valeur est un nombre // Formule Sudoku valide (utilise un "div 3" reconstruit) valeur vaut ((i * 3 + arrondi((i - (i mod 3)) / 3) + j) mod 9) + 1 ligne[j] vaut valeur fin pour grille[i] vaut ligne fin pour tant que cases_a_vider > 0 x, y est un nombre x vaut hasard(0, 8) y vaut hasard(0, 8) ligne est un tableau ligne vaut grille[x] si ligne[y] <> 0 alors ligne[y] vaut 0 grille[x] vaut ligne cases_a_vider ajoute - 1 fin si fin tant que // Fonction d'affichage avec émojis fonction case_txt(v) si v = 0 alors retourne '⬛' sinon si v = 1 alors retourne '1️⃣' sinon si v = 2 alors retourne '2️⃣' sinon si v = 3 alors retourne '3️⃣' sinon si v = 4 alors retourne '4️⃣' sinon si v = 5 alors retourne '5️⃣' sinon si v = 6 alors retourne '6️⃣' sinon si v = 7 alors retourne '7️⃣' sinon si v = 8 alors retourne '8️⃣' sinon si v = 9 alors retourne '9️⃣' fin si fin fonction // Procédure d'affichage du Sudoku procédure afficher_sudoku(grille) i, j est un nombre affiche '╸╸╸╸╸╸╸╸╸╸╸╸╸╸╸╸╸╸╸╸╸╸╸╸╸╸╸' pour i de 0 à 8 ligne est un tableau ligne vaut grille[i] txt est un texte txt vaut '┃' pour j de 0 à 8 txt vaut txt + case_txt(ligne[j]) si (j mod 3) = 2 alors txt vaut txt + '┃' fin si fin pour affiche txt si (i mod 3) = 2 alors affiche '╸╸╸╸╸╸╸╸╸╸╸╸╸╸╸╸╸╸╸╸╸╸╸╸╸╸╸' fin si fin pour fin procédure // Affichage final affiche 'Sudoku généré :' appelle afficher_sudoku(grille)

// ============================================ // JEU DES ALLUMETTES - Joueur vs Bot // ============================================ // ============================================ // CONSTANTES // ============================================ tas_initial est une constante vaut 15 // ============================================ // FONCTIONS // ============================================ fonction afficherTas(nb) ligne est un texte ligne vaut ' ' i est un nombre pour i de 1 à nb ligne vaut ligne + '🔥' fin pour retourne ligne fin fonction fonction coupBot(nb) max_retrait est un nombre si nb >= 3 alors max_retrait vaut 3 sinon max_retrait vaut nb fin si retourne hasard(1, max_retrait) fin fonction fonction coupValide(coup, nb) retourne coup >= 1 et coup <= 3 et coup <= nb fin fonction // ============================================ // PROCEDURES // ============================================ procédure afficherEtat(nb, tour) affiche repeter_texte('─', 40) affiche ' 🔥 Allumettes restantes : ' + nb affiche afficherTas(nb) affiche repeter_texte('─', 40) fin procédure procédure afficherRegles() affiche ' 🔥 JEU DES ALLUMETTES 🔥' affiche repeter_texte('=', 40) affiche ' Règles :' affiche ' -> Tas initial : ' + tas_initial + ' allumettes' affiche ' -> À chaque tour : retirer 1, 2 ou 3 allumettes' affiche ' -> Celui qui prend la DERNIÈRE perd ! 💀' affiche repeter_texte('=', 40) affiche ' 👤 Joueur 1 : VOUS' affiche ' 🤖 Joueur 2 : BOT (aléatoire)' affiche repeter_texte('=', 40) affiche ' 💡 Astuce : la stratégie gagnante' affiche ' est de toujours laisser un multiple' affiche ' de 4 allumettes à votre adversaire !' affiche repeter_texte('=', 40) fin procédure // ============================================ // PROGRAMME PRINCIPAL // ============================================ appelle afficherRegles() tas est un nombre tas vaut tas_initial tour est un nombre tour vaut 1 gagnant est un texte gagnant vaut '' tant que tas > 1 et gagnant = '' appelle afficherEtat(tas, tour) si tour = 1 alors affiche ' 👤 VOTRE TOUR' affiche ' Combien d' + #39 + 'allumettes retirez-vous ? (1, 2 ou 3)' coup est un nombre demande 'Entrez 1, 2 ou 3 : ' dans coup tant que coupValide(coup, tas) = faux affiche ' ❌ Choix invalide !' si tas = 1 alors affiche ' Vous devez retirer 1 allumette.' sinon si tas = 2 alors affiche ' Vous devez retirer 1 ou 2 allumettes.' sinon affiche ' Entrez 1, 2 ou 3.' fin si demande 'Entrez 1, 2 ou 3 : ' dans coup fin tant que tas vaut tas - coup affiche ' 👤 Vous retirez ' + coup + ' allumette(s).' si tas = 0 alors gagnant vaut 'BOT' fin si tour vaut 2 sinon affiche ' 🤖 TOUR DU BOT' coup_bot est un nombre coup_bot vaut coupBot(tas) tas vaut tas - coup_bot affiche ' 🤖 Le bot retire ' + coup_bot + ' allumette(s).' si tas = 0 alors gagnant vaut 'JOUEUR' fin si tour vaut 1 fin si fin tant que appelle afficherEtat(tas, tour) affiche repeter_texte('=', 40) si gagnant = 'JOUEUR' alors affiche ' 🎉 VOUS AVEZ GAGNÉ ! 🎉' affiche ' Le bot a pris la dernière allumette !' sinon affiche ' 💀 VOUS AVEZ PERDU ! 💀' affiche ' Vous avez pris la dernière allumette !' fin si affiche repeter_texte('=', 40)

// ============================================ // MAINS DE POKER - Force Brute // Toutes les combinaisons de 5 cartes // ============================================ // ============================================ // CONSTANTES // ============================================ nb_cartes_jeu est une constante vaut 52 nb_cartes_main est une constante vaut 5 // ============================================ // FONCTIONS CARTES // ============================================ // Valeur de la carte (1-13 : As a Roi) fonction valeurCarte(carte) retourne (carte % 13) + 1 fin fonction // Couleur de la carte (0-3 : Pique, Coeur, Carreau, Trefle) fonction couleurCarte(carte) retourne carte / 13 fin fonction // Couleur entiere fonction couleurEntiere(carte) retourne (carte - (carte % 13)) / 13 fin fonction // Emoji de la couleur fonction emojiCouleur(clr) si clr = 0 alors retourne '♠️' sinon si clr = 1 alors retourne '♥️' sinon si clr = 2 alors retourne '♦️' sinon retourne '♣️' fin si fin fonction // Nom de la valeur fonction nomValeur(val) si val = 1 alors retourne 'A' sinon si val = 11 alors retourne 'V' sinon si val = 12 alors retourne 'D' sinon si val = 13 alors retourne 'R' sinon retourne '' + val fin si fin fonction // Affiche une carte fonction afficherCarte(carte) val est un nombre val vaut valeurCarte(carte) coul est un nombre coul vaut couleurEntiere(carte) retourne nomValeur(val) + emojiCouleur(coul) fin fonction // ============================================ // FONCTIONS ANALYSE DE MAIN // ============================================ // Compte les occurrences d une valeur dans la main fonction compterValeur(v, c0, c1, c2, c3, c4) nb est un nombre nb vaut 0 si valeurCarte(c0) = v alors nb ajoute 1 fin si si valeurCarte(c1) = v alors nb ajoute 1 fin si si valeurCarte(c2) = v alors nb ajoute 1 fin si si valeurCarte(c3) = v alors nb ajoute 1 fin si si valeurCarte(c4) = v alors nb ajoute 1 fin si retourne nb fin fonction // Verifie si toutes les cartes ont la meme couleur fonction estFlush(c0, c1, c2, c3, c4) coul est un nombre coul vaut couleurEntiere(c0) retourne couleurEntiere(c1) = coul et couleurEntiere(c2) = coul et couleurEntiere(c3) = coul et couleurEntiere(c4) = coul fin fonction // Valeur max de la main fonction valMax(c0, c1, c2, c3, c4) v0 est un nombre v0 vaut valeurCarte(c0) v1 est un nombre v1 vaut valeurCarte(c1) v2 est un nombre v2 vaut valeurCarte(c2) v3 est un nombre v3 vaut valeurCarte(c3) v4 est un nombre v4 vaut valeurCarte(c4) max est un nombre max vaut v0 si v1 > max alors max vaut v1 fin si si v2 > max alors max vaut v2 fin si si v3 > max alors max vaut v3 fin si si v4 > max alors max vaut v4 fin si retourne max fin fonction // Valeur min de la main fonction valMin(c0, c1, c2, c3, c4) v0 est un nombre v0 vaut valeurCarte(c0) v1 est un nombre v1 vaut valeurCarte(c1) v2 est un nombre v2 vaut valeurCarte(c2) v3 est un nombre v3 vaut valeurCarte(c3) v4 est un nombre v4 vaut valeurCarte(c4) min est un nombre min vaut v0 si v1 < min alors min vaut v1 fin si si v2 < min alors min vaut v2 fin si si v3 < min alors min vaut v3 fin si si v4 < min alors min vaut v4 fin si retourne min fin fonction // Verifie si la main est une suite fonction estSuite(c0, c1, c2, c3, c4) // Toutes les valeurs differentes et max - min = 4 v est un nombre nb_distincts est un nombre nb_distincts vaut 0 pour v de 1 à 13 si compterValeur(v, c0, c1, c2, c3, c4) = 1 alors nb_distincts ajoute 1 fin si fin pour retourne nb_distincts = 5 et valMax(c0, c1, c2, c3, c4) - valMin(c0, c1, c2, c3, c4) = 4 fin fonction // Nombre de paires dans la main fonction nbPaires(c0, c1, c2, c3, c4) nb est un nombre nb vaut 0 v est un nombre pour v de 1 à 13 si compterValeur(v, c0, c1, c2, c3, c4) = 2 alors nb ajoute 1 fin si fin pour retourne nb fin fonction // Verifie si la main contient un brelan fonction aBrelan(c0, c1, c2, c3, c4) v est un nombre pour v de 1 à 13 si compterValeur(v, c0, c1, c2, c3, c4) = 3 alors retourne vrai fin si fin pour retourne faux fin fonction // Verifie si la main contient un carre fonction aCarre(c0, c1, c2, c3, c4) v est un nombre pour v de 1 à 13 si compterValeur(v, c0, c1, c2, c3, c4) = 4 alors retourne vrai fin si fin pour retourne faux fin fonction // Retourne le nom de la main fonction nomMain(c0, c1, c2, c3, c4) // Quinte flush royale si estFlush(c0, c1, c2, c3, c4) et estSuite(c0, c1, c2, c3, c4) et valMax(c0, c1, c2, c3, c4) = 13 et valMin(c0, c1, c2, c3, c4) = 1 alors retourne 'QUINTE FLUSH ROYALE 👑' fin si // Quinte flush si estFlush(c0, c1, c2, c3, c4) et estSuite(c0, c1, c2, c3, c4) alors retourne 'Quinte Flush 🌟' fin si // Carre si aCarre(c0, c1, c2, c3, c4) alors retourne 'Carre 🎯' fin si // Full house si aBrelan(c0, c1, c2, c3, c4) et nbPaires(c0, c1, c2, c3, c4) = 1 alors retourne 'Full House 🏠' fin si // Flush si estFlush(c0, c1, c2, c3, c4) alors retourne 'Flush 🌊' fin si // Suite si estSuite(c0, c1, c2, c3, c4) alors retourne 'Suite 📈' fin si // Brelan si aBrelan(c0, c1, c2, c3, c4) alors retourne 'Brelan 🎲' fin si // Double paire si nbPaires(c0, c1, c2, c3, c4) = 2 alors retourne 'Double Paire ✌️' fin si // Paire si nbPaires(c0, c1, c2, c3, c4) = 1 alors retourne 'Paire 👫' fin si retourne 'Carte Haute 🃏' fin fonction // ============================================ // PROCEDURES // ============================================ procédure afficherMain(c0, c1, c2, c3, c4) affiche ' ' + afficherCarte(c0) + ' ' + afficherCarte(c1) + ' ' + afficherCarte(c2) + ' ' + afficherCarte(c3) + ' ' + afficherCarte(c4) fin procédure procédure afficherResultatMain(c0, c1, c2, c3, c4, num) affiche ' Main #' + num + ' : ' + afficherCarte(c0) + ' ' + afficherCarte(c1) + ' ' + afficherCarte(c2) + ' ' + afficherCarte(c3) + ' ' + afficherCarte(c4) + ' -> ' + nomMain(c0, c1, c2, c3, c4) fin procédure // Compte toutes les mains et leurs types procédure analyserToutesMains() affiche '' affiche repeter_texte('=', 52) affiche ' 🃏 ANALYSE DE TOUTES LES MAINS DE POKER' affiche repeter_texte('=', 52) affiche '' affiche ' Nombre de mains possibles : C(52,5)' affiche ' = 52! / (5! x 47!) = 2 598 960' affiche '' affiche ' On compte chaque type de main...' affiche '' nb_quinte_flush_royale est un nombre nb_quinte_flush_royale vaut 0 nb_quinte_flush est un nombre nb_quinte_flush vaut 0 nb_carre est un nombre nb_carre vaut 0 nb_full est un nombre nb_full vaut 0 nb_flush est un nombre nb_flush vaut 0 nb_suite est un nombre nb_suite vaut 0 nb_brelan est un nombre nb_brelan vaut 0 nb_double_paire est un nombre nb_double_paire vaut 0 nb_paire est un nombre nb_paire vaut 0 nb_carte_haute est un nombre nb_carte_haute vaut 0 nb_total est un nombre nb_total vaut 0 i0 est un nombre i1 est un nombre i2 est un nombre i3 est un nombre i4 est un nombre pour i0 de 0 à nb_cartes_jeu - 5 pour i1 de i0 + 1 à nb_cartes_jeu - 4 pour i2 de i1 + 1 à nb_cartes_jeu - 3 pour i3 de i2 + 1 à nb_cartes_jeu - 2 pour i4 de i3 + 1 à nb_cartes_jeu - 1 nb_total ajoute 1 nom est un texte nom vaut nomMain(i0, i1, i2, i3, i4) si nom = 'QUINTE FLUSH ROYALE 👑' alors nb_quinte_flush_royale ajoute 1 sinon si nom = 'Quinte Flush 🌟' alors nb_quinte_flush ajoute 1 sinon si nom = 'Carre 🎯' alors nb_carre ajoute 1 sinon si nom = 'Full House 🏠' alors nb_full ajoute 1 sinon si nom = 'Flush 🌊' alors nb_flush ajoute 1 sinon si nom = 'Suite 📈' alors nb_suite ajoute 1 sinon si nom = 'Brelan 🎲' alors nb_brelan ajoute 1 sinon si nom = 'Double Paire ✌️' alors nb_double_paire ajoute 1 sinon si nom = 'Paire 👫' alors nb_paire ajoute 1 sinon nb_carte_haute ajoute 1 fin si fin pour fin pour fin pour fin pour fin pour affiche repeter_texte('=', 52) affiche ' 📊 RESULTATS - ' + nb_total + ' mains analysees' affiche repeter_texte('=', 52) affiche '' affiche ' 👑 Quinte Flush Royale : ' + nb_quinte_flush_royale affiche ' 🌟 Quinte Flush : ' + nb_quinte_flush affiche ' 🎯 Carre : ' + nb_carre affiche ' 🏠 Full House : ' + nb_full affiche ' 🌊 Flush : ' + nb_flush affiche ' 📈 Suite : ' + nb_suite affiche ' 🎲 Brelan : ' + nb_brelan affiche ' ✌️ Double Paire : ' + nb_double_paire affiche ' 👫 Paire : ' + nb_paire affiche ' 🃏 Carte Haute : ' + nb_carte_haute affiche '' affiche repeter_texte('-', 52) affiche ' Total : ' + nb_total + ' mains' affiche repeter_texte('=', 52) fin procédure // Genere et affiche quelques mains aleatoires procédure mainAleatoire() affiche '' affiche ' 🎰 MAINS ALEATOIRES' affiche repeter_texte('=', 52) affiche '' // 5 mains aleatoires k est un nombre pour k de 1 à 5 // Tirer 5 cartes sans doublon m0 est un nombre m1 est un nombre m2 est un nombre m3 est un nombre m4 est un nombre m0 vaut hasard(0, 51) m1 vaut hasard(0, 51) tant que m1 = m0 m1 vaut hasard(0, 51) fin tant que m2 vaut hasard(0, 51) tant que m2 = m0 ou m2 = m1 m2 vaut hasard(0, 51) fin tant que m3 vaut hasard(0, 51) tant que m3 = m0 ou m3 = m1 ou m3 = m2 m3 vaut hasard(0, 51) fin tant que m4 vaut hasard(0, 51) tant que m4 = m0 ou m4 = m1 ou m4 = m2 ou m4 = m3 m4 vaut hasard(0, 51) fin tant que affiche ' Main ' + k + ' :' appelle afficherMain(m0, m1, m2, m3, m4) affiche ' -> ' + nomMain(m0, m1, m2, m3, m4) fin pour fin procédure // Affiche les probabilites theoriques procédure afficherProbabilites() affiche '' affiche ' 📐 PROBABILITES THEORIQUES' affiche repeter_texte('*', 52) affiche '' affiche ' Main | Nb exact | Proba' affiche repeter_texte('-', 52) affiche ' 👑 Quinte F. Roy. | 4 | 0.000154 %' affiche ' 🌟 Quinte Flush | 36 | 0.00139 %' affiche ' 🎯 Carre | 624 | 0.0240 %' affiche ' 🏠 Full House | 3 744 | 0.144 %' affiche ' 🌊 Flush | 5 108 | 0.197 %' affiche ' 📈 Suite | 10 200 | 0.392 %' affiche ' 🎲 Brelan | 54 912 | 2.11 %' affiche ' ✌️ Double Paire | 123 552 | 4.75 %' affiche ' 👫 Paire |1 098 240 | 42.3 %' affiche ' 🃏 Carte Haute |1 302 540 | 50.1 %' affiche repeter_texte('-', 52) affiche ' Total |2 598 960 | 100 %' affiche repeter_texte('*', 52) fin procédure // ============================================ // PROGRAMME PRINCIPAL // ============================================ affiche '' affiche ' 🃏 *** MAINS DE POKER - COMBINAISONS *** 🃏' affiche ' 52 cartes - Mains de 5 cartes' affiche ' C(52,5) = 2 598 960 mains possibles' affiche '' affiche ' Couleurs :' affiche ' ♠️ Pique ♥️ Coeur' affiche ' ♦️ Carreau ♣️ Trefle' affiche '' affiche ' Valeurs : A 2 3 4 5 6 7 8 9 10 V D R' appelle mainAleatoire() appelle afficherProbabilites()

// ============================================ // LE PROBLEME DU SAC A DOS - Force Brute // ============================================ nb_objets est une constante vaut 8 capacite est une constante vaut 10 // Emojis des objets emojis est un tableau emojis[0] vaut '💻' emojis[1] vaut '📷' emojis[2] vaut '📱' emojis[3] vaut '📖' emojis[4] vaut '🔌' emojis[5] vaut '🎧' emojis[6] vaut '🚁' emojis[7] vaut '🧥' noms est un tableau noms[0] vaut 'Ordinateur' noms[1] vaut 'Appareil photo' noms[2] vaut 'Tablette' noms[3] vaut 'Livre' noms[4] vaut 'Chargeur' noms[5] vaut 'Casque audio' noms[6] vaut 'Drone' noms[7] vaut 'Veste' poids est un tableau poids[0] vaut 4 poids[1] vaut 3 poids[2] vaut 2 poids[3] vaut 1 poids[4] vaut 1 poids[5] vaut 2 poids[6] vaut 5 poids[7] vaut 3 valeurs est un tableau valeurs[0] vaut 10 valeurs[1] vaut 8 valeurs[2] vaut 6 valeurs[3] vaut 3 valeurs[4] vaut 2 valeurs[5] vaut 5 valeurs[6] vaut 12 valeurs[7] vaut 6 // ============================================ // FONCTIONS // ============================================ fonction bitActif(masque, i) bit est un nombre bit vaut 1 j est un nombre pour j de 0 à i - 1 bit vaut bit * 2 fin pour retourne (masque / bit) % 2 >= 1 fin fonction fonction poidsMasque(masque) total est un nombre total vaut 0 i est un nombre pour i de 0 à nb_objets - 1 si bitActif(masque, i) alors total ajoute poids[i] fin si fin pour retourne total fin fonction fonction valeurMasque(masque) total est un nombre total vaut 0 i est un nombre pour i de 0 à nb_objets - 1 si bitActif(masque, i) alors total ajoute valeurs[i] fin si fin pour retourne total fin fonction fonction puissance2(n) res est un nombre res vaut 1 i est un nombre pour i de 0 à n - 1 res vaut res * 2 fin pour retourne res fin fonction // ============================================ // PROCEDURES // ============================================ procédure afficherObjets() affiche repeter_texte('=', 50) affiche ' 🎒 OBJETS DISPONIBLES | Capacite : ' + capacite + ' kg' affiche repeter_texte('=', 50) affiche ' N | Emoji | Objet | Poids | Valeur' affiche repeter_texte('-', 50) i est un nombre total_poids est un nombre total_poids vaut 0 total_valeur est un nombre total_valeur vaut 0 pour i de 0 à nb_objets - 1 r est un nombre r vaut arrondi(valeurs[i] * 10 / poids[i]) / 10 affiche ' ' + i + ' | ' + emojis[i] + ' | ' + noms[i] affiche ' Poids : ' + poids[i] + ' kg | Valeur : ' + valeurs[i] + ' | Ratio : ' + r total_poids ajoute poids[i] total_valeur ajoute valeurs[i] fin pour affiche repeter_texte('-', 50) affiche ' ⚖️ Total poids : ' + total_poids + ' kg' affiche ' 💎 Total valeur : ' + total_valeur affiche ' 🎒 Capacite sac : ' + capacite + ' kg' affiche ' ⚠️ On ne peut pas tout prendre !' affiche repeter_texte('=', 50) fin procédure procédure dessinerSac(masque, titre) p est un nombre p vaut poidsMasque(masque) v est un nombre v vaut valeurMasque(masque) affiche '' affiche ' ' + titre affiche ' +========================+' affiche ' | 🎒 SAC A DOS |' affiche ' +------------------------+' i est un nombre pour i de 0 à nb_objets - 1 si bitActif(masque, i) alors affiche ' | ' + emojis[i] + ' ' + noms[i] fin si fin pour affiche ' +------------------------+' affiche ' | ⚖️ Poids : ' + p + ' kg' affiche ' | 💎 Valeur : ' + v affiche ' +========================+' affiche '' fin procédure procédure afficherCombinaison(masque, num, total) p est un nombre p vaut poidsMasque(masque) v est un nombre v vaut valeurMasque(masque) objets est un texte objets vaut '' i est un nombre pour i de 0 à nb_objets - 1 si bitActif(masque, i) alors si longueur(objets) > 0 alors objets vaut objets + ' ' fin si objets vaut objets + emojis[i] fin si fin pour si longueur(objets) = 0 alors objets vaut '(vide)' fin si si p <= capacite alors affiche ' ✅ #' + num + '/' + total + ' | ' + p + 'kg | val=' + v + ' | ' + objets sinon affiche ' ❌ #' + num + '/' + total + ' | ' + p + 'kg | val=' + v + ' | ' + objets fin si fin procédure procédure forceBrute() affiche '' affiche repeter_texte('=', 50) affiche ' 🔍 FORCE BRUTE - Toutes les combinaisons' affiche repeter_texte('=', 50) affiche '' nb_combinaisons est un nombre nb_combinaisons vaut puissance2(nb_objets) affiche ' 📦 Nombre d objets : ' + nb_objets affiche ' 🔢 Combinaisons : 2^' + nb_objets + ' = ' + nb_combinaisons affiche ' ⚖️ Capacite du sac : ' + capacite + ' kg' affiche '' meilleur_masque est un nombre meilleur_masque vaut 0 meilleure_valeur est un nombre meilleure_valeur vaut 0 nb_valides est un nombre nb_valides vaut 0 nb_invalides est un nombre nb_invalides vaut 0 affiche repeter_texte('-', 50) affiche ' Detail de toutes les combinaisons :' affiche repeter_texte('-', 50) affiche '' masque est un nombre pour masque de 0 à nb_combinaisons - 1 p est un nombre p vaut poidsMasque(masque) v est un nombre v vaut valeurMasque(masque) appelle afficherCombinaison(masque, masque + 1, nb_combinaisons) si p <= capacite alors nb_valides ajoute 1 si v > meilleure_valeur alors meilleure_valeur vaut v meilleur_masque vaut masque fin si sinon nb_invalides ajoute 1 fin si fin pour affiche '' affiche repeter_texte('=', 50) affiche ' 📊 BILAN DE LA RECHERCHE' affiche repeter_texte('=', 50) affiche ' 🔢 Combinaisons testees : ' + nb_combinaisons affiche ' ✅ Combinaisons valides : ' + nb_valides affiche ' ❌ Combinaisons invalides : ' + nb_invalides affiche ' 🏆 Meilleure valeur : ' + meilleure_valeur affiche repeter_texte('=', 50) appelle dessinerSac(meilleur_masque, '🏆 SOLUTION OPTIMALE') nb_opt est un nombre nb_opt vaut 0 pour masque de 0 à nb_combinaisons - 1 si poidsMasque(masque) <= capacite et valeurMasque(masque) = meilleure_valeur alors nb_opt ajoute 1 fin si fin pour si nb_opt > 1 alors affiche ' 🔄 ' + nb_opt + ' solutions atteignent la valeur maximale !' affiche '' i est un nombre i vaut 0 pour masque de 0 à nb_combinaisons - 1 si poidsMasque(masque) <= capacite et valeurMasque(masque) = meilleure_valeur alors i ajoute 1 appelle dessinerSac(masque, '🏆 Solution ' + i + '/' + nb_opt) fin si fin pour fin si fin procédure // ============================================ // PROGRAMME PRINCIPAL // ============================================ affiche '' affiche ' 🎒 *** SAC A DOS - FORCE BRUTE *** 🎒' affiche ' Maximiser la valeur sans depasser ' + capacite + ' kg' affiche '' appelle afficherObjets() appelle forceBrute() affiche repeter_texte('*', 50) affiche ' 📝 CONCLUSION' affiche repeter_texte('*', 50) affiche '' affiche ' ✅ Force brute : solution GARANTIE optimale.' affiche ' ⚠️ Limite : 2^N combinaisons a tester.' affiche '' affiche ' 📊 Complexite :' affiche ' 8 objets -> 256 combinaisons ✅' affiche ' 10 objets -> 1 024 combinaisons ✅' affiche ' 20 objets -> 1 048 576 combinaisons 🐌' affiche ' 30 objets -> 1 milliard 🐢' affiche ' 50 objets -> 1 000 mrd de mrd 💀' affiche '' affiche ' Fin du programme. 🎒'

// ============================================ // LE PROBLEME DES 8 REINES - Backtracking // ============================================ // Un echiquier 8x8 // Placer 8 reines sans qu'aucune ne s'attaque // Algorithme : backtracking (retour arriere) // ============================================ // VARIABLES GLOBALES // ============================================ taille est une constante vaut 8 // reines[i] = colonne de la reine sur la ligne i reines est un tableau i est un nombre pour i de 0 à taille - 1 reines[i] vaut -1 fin pour nb_solutions est un nombre nb_solutions vaut 0 afficher_toutes est un booléen afficher_toutes vaut faux // ============================================ // FONCTIONS // ============================================ // Verifie si on peut placer une reine ligne l, colonne c fonction estValide(ligne, col) i est un nombre pour i de 0 à ligne - 1 // Meme colonne si reines[i] = col alors retourne faux fin si // Diagonale gauche si reines[i] = col - (ligne - i) alors retourne faux fin si // Diagonale droite si reines[i] = col + (ligne - i) alors retourne faux fin si fin pour retourne vrai fin fonction // ============================================ // PROCEDURES // ============================================ // Dessine l echiquier avec les reines placees procédure dessinerEchiquier(num) affiche '' affiche ' Solution n ' + num affiche ' +---+---+---+---+---+---+---+---+' ligne est un nombre col est un nombre pour ligne de 0 à taille - 1 lig est un texte lig vaut ' |' pour col de 0 à taille - 1 si reines[ligne] = col alors lig vaut lig + ' Q |' sinon si (ligne + col) % 2 = 0 alors lig vaut lig + ' |' sinon lig vaut lig + ' . |' fin si fin pour affiche lig affiche ' +---+---+---+---+---+---+---+---+' fin pour affiche ' a b c d e f g h' affiche '' // Affiche les positions des reines positions est un texte positions vaut ' Positions : ' pour ligne de 0 à taille - 1 col est un nombre col vaut reines[ligne] lettre est un texte si col = 0 alors lettre vaut 'a' sinon si col = 1 alors lettre vaut 'b' sinon si col = 2 alors lettre vaut 'c' sinon si col = 3 alors lettre vaut 'd' sinon si col = 4 alors lettre vaut 'e' sinon si col = 5 alors lettre vaut 'f' sinon si col = 6 alors lettre vaut 'g' sinon lettre vaut 'h' fin si positions vaut positions + lettre + (ligne + 1) + ' ' fin pour affiche positions affiche '' fin procédure // Algorithme de backtracking procédure resoudre(ligne) si ligne = taille alors // Toutes les reines sont placees : solution trouvee ! nb_solutions ajoute 1 si nb_solutions <= 3 ou afficher_toutes alors appelle dessinerEchiquier(nb_solutions) sinon si nb_solutions = 4 alors affiche ' ... (autres solutions non affichees) ...' affiche '' fin si sinon col est un nombre pour col de 0 à taille - 1 si estValide(ligne, col) alors reines[ligne] vaut col appelle resoudre(ligne + 1) reines[ligne] vaut -1 fin si fin pour fin si fin procédure // Affiche l echiquier vide avec une tentative procédure dessinerTentative(ligne, col, valide) affiche ' +---+---+---+---+---+---+---+---+' l est un nombre c est un nombre pour l de 0 à ligne lig est un texte lig vaut ' |' pour c de 0 à taille - 1 si l < ligne et reines[l] = c alors lig vaut lig + ' Q |' sinon si l = ligne et c = col alors si valide alors lig vaut lig + ' Q |' sinon lig vaut lig + ' X |' fin si sinon si (l + c) % 2 = 0 alors lig vaut lig + ' |' sinon lig vaut lig + ' . |' fin si fin pour affiche lig affiche ' +---+---+---+---+---+---+---+---+' fin pour si valide alors affiche ' -> Position valide ! On continue...' sinon affiche ' -> Position invalide (attaque). On recule.' fin si affiche '' fin procédure // Demonstration pas a pas des premiers coups procédure demonstrationPasAPas() affiche repeter_texte('=', 50) affiche ' DEMONSTRATION PAS A PAS - Ligne 1' affiche repeter_texte('=', 50) affiche '' affiche ' On essaie de placer la 1ere reine...' affiche '' // Essai ligne 0, col 0 : valide reines[0] vaut 0 affiche ' Essai : ligne 1, colonne a' appelle dessinerTentative(0, 0, vrai) // Essai ligne 1, col 0 : invalide (meme colonne) affiche ' Essai : ligne 2, colonne a' appelle dessinerTentative(1, 0, faux) // Essai ligne 1, col 1 : invalide (diagonale) affiche ' Essai : ligne 2, colonne b' appelle dessinerTentative(1, 1, faux) // Essai ligne 1, col 2 : valide reines[1] vaut 2 affiche ' Essai : ligne 2, colonne c -> OK !' appelle dessinerTentative(1, 2, vrai) // Reset reines[0] vaut -1 reines[1] vaut -1 fin procédure // ============================================ // PROGRAMME PRINCIPAL // ============================================ affiche '' affiche ' *** LE PROBLEME DES 8 REINES ***' affiche '' affiche ' Regles :' affiche ' -> Placer 8 reines sur un echiquier 8x8' affiche ' -> Aucune reine ne doit en attaquer une autre' affiche ' -> Ni sur la meme ligne, colonne ou diagonale' affiche '' affiche ' Algorithme : BACKTRACKING (retour arriere)' affiche ' On place, on teste, on recule si invalide.' affiche '' // Demonstration pas a pas appelle demonstrationPasAPas() // Resolution complete affiche repeter_texte('=', 50) affiche ' RESOLUTION COMPLETE' affiche repeter_texte('=', 50) affiche ' Recherche de toutes les solutions...' affiche '' appelle resoudre(0) affiche repeter_texte('*', 50) affiche ' BILAN FINAL' affiche repeter_texte('*', 50) affiche '' affiche ' Nombre total de solutions : ' + nb_solutions affiche '' affiche ' Pour un echiquier NxN :' affiche ' 4x4 -> 2 solutions' affiche ' 5x5 -> 10 solutions' affiche ' 6x6 -> 4 solutions' affiche ' 7x7 -> 40 solutions' affiche ' 8x8 -> 92 solutions' affiche ' 9x9 -> 352 solutions' affiche '' affiche ' Le backtracking explore toutes les' affiche ' possibilites en eliminant les branches' affiche ' invalides le plus tot possible.'

compteur est un nombre procédure combinaisons(text, debut) si longueur(text) = 0 alors compteur ajoute 1 affiche debut sinon i, j est un nombre c, reste est un texte pour i de 1 à longueur(text) c vaut copier(text, i, 1) reste vaut '' pour j de 1 à longueur(text) si j <> i alors reste vaut reste + copier(text, j, 1) fin si fin pour appelle combinaisons(reste, debut + c) fin pour fin si fin procédure // -------- Exemple -------- text est un texte text vaut 'abc' compteur vaut 0 appelle combinaisons(text, '') affiche 'Nombre de permutations : ' + convertir_texte(compteur)

// JEU DU PENDU - EduCode mot_secret est un texte mot_secret vaut 'INTERPRETEUR' lettres_trouvees est un tableau taille(lettres_trouvees, longueur(mot_secret)) erreurs, max_erreurs est un nombre erreurs vaut 0 max_erreurs vaut 6 gagne est un booleen gagne vaut faux // Initialiser le mot caché avec des tirets pour i de 0 à longueur(mot_secret) - 1 lettres_trouvees[i] vaut '-' fin pour tant que erreurs < max_erreurs et non gagne affiche '' affiche '+-------+' affiche '| |' si erreurs >= 1 alors affiche '| O' sinon affiche '|' fin si si erreurs >= 4 alors affiche '| ╱|╲' sinon si erreurs = 3 alors affiche '| ╱|' sinon si erreurs = 2 alors affiche '| |' sinon affiche '|' fin si si erreurs >= 6 alors affiche '| ╱ ╲' sinon si erreurs = 5 alors affiche '| ╱' sinon affiche '|' fin si affiche '|' affiche '=========' affiche '' // Construire l'affichage du mot ligne est un texte ligne vaut '' pour i de 0 à longueur(lettres_trouvees) - 1 ligne vaut ligne + lettres_trouvees[i] + ' ' fin pour affiche 'Mot : ' + ligne affiche 'Erreurs : ' + erreurs + ' / ' + max_erreurs affiche '' // Demander une lettre lettre est un texte demande 'Entrez une lettre : ' dans lettre lettre vaut majuscules(lettre) // Chercher la lettre dans le mot trouve est un booleen trouve vaut faux pour i de 0 à longueur(mot_secret) - 1 si copier(mot_secret, i + 1, 1) = lettre alors lettres_trouvees[i] vaut lettre trouve vaut vrai fin si fin pour // Si lettre absente, incrémenter les erreurs si non trouve alors erreurs vaut erreurs + 1 fin si // Vérifier si le mot est entièrement trouvé gagne vaut vrai pour i de 0 à longueur(lettres_trouvees) - 1 si lettres_trouvees[i] = '-' alors gagne vaut faux fin si fin pour fin tant que // Affichage final affiche '' si gagne alors affiche 'Bravo ! Vous avez trouve le mot : ' + mot_secret sinon affiche '+-------+' affiche '| |' affiche '| O' affiche '| ╱|╲' affiche '| ╱ ╲' affiche '|' affiche '=========' affiche 'Perdu ! Le mot etait : ' + mot_secret fin si

// ═══════════════════════════════════════════════════════════ // TRIANGLE DE PASCAL - EduCode // Coefficients binomiaux, proprietes, applications // ═══════════════════════════════════════════════════════════ // ───────── UTILITAIRES ───────── fonction pad(t, l) r est un texte r vaut t tant que longueur(r) < l r vaut r + ' ' fin tant que retourne r fin fonction fonction pad_gauche(t, l) r est un texte r vaut t tant que longueur(r) < l r vaut ' ' + r fin tant que retourne r fin fonction fonction repeter(c, n) r est un texte r vaut '' i est un nombre pour i de 1 à n r vaut r + c fin pour retourne r fin fonction // ───────── STOCKAGE DU TRIANGLE ───────── // Tableau 1D simulant une matrice 10x10 // valeur(ligne, col) = triangle[ligne * 10 + col] triangle est un tableau i est un nombre j est un nombre pour i de 0 à 99 triangle ajoute 0 fin pour // ───────── CONSTRUCTION DU TRIANGLE ───────── // C(n,0) = 1, C(n,n) = 1 // C(n,k) = C(n-1,k-1) + C(n-1,k) procédure construire(nb_lignes) pour i de 0 à nb_lignes - 1 triangle[i * 10 + 0] vaut 1 triangle[i * 10 + i] vaut 1 pour j de 1 à i - 1 triangle[i * 10 + j] vaut triangle[(i-1) * 10 + (j-1)] + triangle[(i-1) * 10 + j] fin pour fin pour fin procédure // ───────── AFFICHAGE PYRAMIDAL ───────── procédure afficher_pyramide(nb_lignes) largeur est un nombre largeur vaut nb_lignes * 4 ligne_txt est un texte espaces est un nombre affiche '' affiche '+' + repeter('=', largeur + 4) + '+' affiche '|' + pad(' TRIANGLE DE PASCAL - ' + nb_lignes + ' lignes', largeur + 4) + '|' affiche '+' + repeter('=', largeur + 4) + '+' affiche '' pour i de 0 à nb_lignes - 1 espaces vaut (nb_lignes - i - 1) * 2 ligne_txt vaut repeter(' ', espaces) pour j de 0 à i ligne_txt vaut ligne_txt + pad_gauche(convertir_texte(triangle[i * 10 + j]), 4) fin pour affiche ligne_txt fin pour affiche '' fin procédure // ───────── PROPRIETE 1 : SOMME DES LIGNES ───────── // Somme de la ligne n = 2^n procédure afficher_sommes(nb_lignes) somme est un nombre puissance est un nombre affiche '+' + repeter('=', 44) + '+' affiche '| PROPRIETE 1 : Somme de chaque ligne |' affiche '| Somme(ligne n) = 2^n |' affiche '+' + repeter('=', 44) + '+' affiche ' +--------+----------+----------+-----------+' affiche ' | Ligne | Somme | 2^n | Egal ? |' affiche ' +--------+----------+----------+-----------+' puissance vaut 1 pour i de 0 à nb_lignes - 1 somme vaut 0 pour j de 0 à i somme vaut somme + triangle[i * 10 + j] fin pour egal est un texte si somme = puissance alors egal vaut 'OUI ✓ ' sinon egal vaut 'NON ✗ ' fin si affiche ' | ' + pad(convertir_texte(i), 6) + ' | ' + pad(convertir_texte(somme), 8) + ' | ' + pad(convertir_texte(puissance), 8) + ' | ' + egal + ' |' puissance vaut puissance * 2 fin pour affiche ' +--------+----------+----------+-----------+' fin procédure // ───────── PROPRIETE 2 : DIAGONALES ───────── // Diagonale 0 : que des 1 // Diagonale 1 : nombres naturels 1,2,3,4... // Diagonale 2 : nombres triangulaires 1,3,6,10... procédure afficher_diagonales(nb_lignes) affiche '' affiche '+' + repeter('=', 44) + '+' affiche '| PROPRIETE 2 : Les diagonales |' affiche '+' + repeter('=', 44) + '+' affiche '' affiche ' Diagonale 0 (colonne 0) - Que des 1 :' ligne_txt est un texte ligne_txt vaut ' -> ' pour i de 0 à nb_lignes - 1 ligne_txt vaut ligne_txt + convertir_texte(triangle[i * 10 + 0]) + ' ' fin pour affiche ligne_txt affiche '' affiche ' Diagonale 1 - Nombres naturels :' ligne_txt vaut ' -> ' pour i de 1 à nb_lignes - 1 ligne_txt vaut ligne_txt + convertir_texte(triangle[i * 10 + 1]) + ' ' fin pour affiche ligne_txt affiche '' affiche ' Diagonale 2 - Nombres triangulaires :' ligne_txt vaut ' -> ' pour i de 2 à nb_lignes - 1 ligne_txt vaut ligne_txt + convertir_texte(triangle[i * 10 + 2]) + ' ' fin pour affiche ligne_txt affiche '' affiche ' Verification : 1 + 2 = 3 | 3 + 3 = 6 | 6 + 4 = 10 | 10 + 5 = 15' affiche ' Chaque terme = somme des nombres naturels precedents' fin procédure // ───────── PROPRIETE 3 : SYMETRIE ───────── // C(n,k) = C(n, n-k) procédure afficher_symetrie(nb_lignes) affiche '' affiche '+' + repeter('=', 44) + '+' affiche '| PROPRIETE 3 : Symetrie |' affiche '| C(n,k) = C(n, n-k) |' affiche '+' + repeter('=', 44) + '+' affiche ' +-------+-------+--------+--------+--------+' affiche ' | n | k | C(n,k) |C(n,n-k)| Egal ? |' affiche ' +-------+-------+--------+--------+--------+' pour i de 2 à nb_lignes - 1 pour j de 0 à (i - i mod 2) / 2 val1 est un nombre val2 est un nombre egal est un texte val1 vaut triangle[i * 10 + j] val2 vaut triangle[i * 10 + (i - j)] si val1 = val2 alors egal vaut 'OUI ✓ ' sinon egal vaut 'NON ✗ ' fin si affiche ' | ' + pad(convertir_texte(i), 5) + ' | ' + pad(convertir_texte(j), 5) + ' | ' + pad(convertir_texte(val1), 6) + ' | ' + pad(convertir_texte(val2), 6) + ' | ' + egal + ' |' fin pour fin pour affiche ' +-------+-------+--------+--------+--------+' fin procédure // ───────── PROPRIETE 4 : PUISSANCES DE 11 ───────── // Ligne 0 : 11^0 = 1 // Ligne 1 : 11^1 = 11 // Ligne 2 : 11^2 = 121 // Ligne 3 : 11^3 = 1331 // Ligne 4 : 11^4 = 14641 procédure afficher_puissances_11 affiche '' affiche '+' + repeter('=', 44) + '+' affiche '| PROPRIETE 4 : Puissances de 11 |' affiche '| Ligne n = chiffres de 11^n |' affiche '+' + repeter('=', 44) + '+' affiche '' puissance est un nombre puissance vaut 1 pour i de 0 à 4 ligne_txt vaut ' 11^' + i + ' = ' + pad(convertir_texte(puissance), 8) + ' <- Ligne ' + i + ' : ' pour j de 0 à i ligne_txt vaut ligne_txt + convertir_texte(triangle[i * 10 + j]) fin pour affiche ligne_txt puissance vaut puissance * 11 fin pour affiche '' affiche ' Note : valable pour les 5 premieres lignes' affiche ' (retenues necessaires a partir de la ligne 5)' fin procédure // ───────── PROPRIETE 5 : COEFFICIENTS BINOMIAUX ───────── // (a+b)^n -> les coefficients sont la ligne n du triangle procédure afficher_binome(n) affiche '' affiche '+' + repeter('=', 44) + '+' affiche '| PROPRIETE 5 : Developpement du binome |' affiche '| (a+b)^n -> coefficients = ligne n |' affiche '+' + repeter('=', 44) + '+' affiche '' exposant est un texte pour i de 0 à n coeff est un nombre coeff vaut triangle[n * 10 + i] exposant_a est un nombre exposant_b est un nombre exposant_a vaut n - i exposant_b vaut i terme est un texte si coeff = 1 alors terme vaut '' sinon terme vaut convertir_texte(coeff) fin si si exposant_a = 0 alors terme vaut terme + '' sinon si exposant_a = 1 alors terme vaut terme + 'a' sinon terme vaut terme + 'a^' + convertir_texte(exposant_a) fin si si exposant_b = 0 alors terme vaut terme + '' sinon si exposant_b = 1 alors terme vaut terme + 'b' sinon terme vaut terme + 'b^' + convertir_texte(exposant_b) fin si si i = 0 alors exposant vaut terme sinon exposant vaut exposant + ' + ' + terme fin si fin pour affiche ' (a+b)^' + n + ' = ' + exposant fin procédure // ───────── BILAN FINAL ───────── procédure afficher_bilan(nb_lignes) total est un nombre total vaut 0 max_val est un nombre max_val vaut 0 max_ligne est un nombre max_col est un nombre max_ligne vaut 0 max_col vaut 0 pour i de 0 à nb_lignes - 1 pour j de 0 à i total vaut total + triangle[i * 10 + j] si triangle[i * 10 + j] > max_val alors max_val vaut triangle[i * 10 + j] max_ligne vaut i max_col vaut j fin si fin pour fin pour affiche '' affiche '+' + repeter('=', 44) + '+' affiche '| BILAN GLOBAL |' affiche '+' + repeter('=', 44) + '+' affiche ' Lignes calculees : ' + nb_lignes affiche ' Total coefficients : ' + (nb_lignes * (nb_lignes + 1) - nb_lignes * (nb_lignes + 1) mod 2) / 2 affiche ' Somme de tous les C : ' + total affiche ' Valeur maximale : ' + max_val + ' en C(' + max_ligne + ',' + max_col + ')' affiche ' Tous symetriques : OUI ✓' affiche ' Sommes = puissances 2: OUI ✓' affiche '+' + repeter('=', 44) + '+' fin procédure // ══════════ PROGRAMME PRINCIPAL ══════════ nb est un nombre nb vaut 10 affiche '+' + repeter('=', 48) + '+' affiche '| TRIANGLE DE PASCAL - EduCode |' affiche '| Coefficients binomiaux et 5 proprietes |' affiche '+' + repeter('=', 48) + '+' appelle construire(nb) appelle afficher_pyramide(nb) appelle afficher_sommes(nb) appelle afficher_diagonales(nb) appelle afficher_symetrie(nb) appelle afficher_puissances_11 appelle afficher_binome(5) appelle afficher_binome(6) appelle afficher_bilan(nb) affiche '' affiche ' Programme termine.' affiche '+' + repeter('=', 48) + '+'

// ============================================ // TOURS DE HANOI // ============================================ // 3 piles representant les 3 tiges tA est un tableau tB est un tableau tC est un tableau sA est un nombre sA vaut 0 sB est un nombre sB vaut 0 sC est un nombre sC vaut 0 nb_disques est une constante vaut 10 nb_mouvements est un nombre nb_mouvements vaut 0 // ============================================ // FONCTIONS // ============================================ fonction nomTige(t) si t = 0 alors retourne 'A' sinon si t = 1 alors retourne 'B' sinon retourne 'C' fin si fin fonction fonction sommetTige(t) si t = 0 alors si sA = 0 alors retourne 0 fin si retourne tA[sA - 1] sinon si t = 1 alors si sB = 0 alors retourne 0 fin si retourne tB[sB - 1] sinon si sC = 0 alors retourne 0 fin si retourne tC[sC - 1] fin si fin fonction fonction getDisque(t, ligne) si t = 0 alors si ligne < sA alors retourne tA[ligne] fin si sinon si t = 1 alors si ligne < sB alors retourne tB[ligne] fin si sinon si ligne < sC alors retourne tC[ligne] fin si fin si retourne 0 fin fonction fonction dessinerDisque(d) si d = 0 alors retourne ' | ' fin si si d = 1 alors retourne ' [1] ' fin si si d = 2 alors retourne ' [222] ' fin si si d = 3 alors retourne ' [33333] ' fin si retourne '[4444444]' fin fonction // ============================================ // PROCEDURES // ============================================ procédure empilerTige(t, val) si t = 0 alors tA[sA] vaut val sA ajoute 1 sinon si t = 1 alors tB[sB] vaut val sB ajoute 1 sinon tC[sC] vaut val sC ajoute 1 fin si fin procédure procédure desempilerTige(t) si t = 0 alors sA vaut sA - 1 sinon si t = 1 alors sB vaut sB - 1 sinon sC vaut sC - 1 fin si fin procédure procédure afficherTours() affiche '' affiche ' Tige A Tige B Tige C' affiche repeter_texte('-', 42) ligne est un nombre pour ligne de nb_disques - 1 à 0 pas - 1 dA est un nombre dB est un nombre dC est un nombre dA vaut getDisque(0, ligne) dB vaut getDisque(1, ligne) dC vaut getDisque(2, ligne) affiche dessinerDisque(dA) + ' ' + dessinerDisque(dB) + ' ' + dessinerDisque(dC) fin pour affiche repeter_texte('=', 42) affiche ' Mouvements : ' + nb_mouvements affiche '' fin procédure procédure deplacer(source, destination) disque est un nombre disque vaut sommetTige(source) nb_mouvements ajoute 1 affiche ' Mouvement ' + nb_mouvements + ' : disque ' + disque + ' de ' + nomTige(source) + ' -> ' + nomTige(destination) desempilerTige(source) empilerTige(destination, disque) appelle afficherTours() fin procédure procédure hanoi(n, source, destination, auxiliaire) si n = 1 alors appelle deplacer(source, destination) sinon appelle hanoi(n - 1, source, auxiliaire, destination) appelle deplacer(source, destination) appelle hanoi(n - 1, auxiliaire, destination, source) fin si fin procédure // ============================================ // PROGRAMME PRINCIPAL // ============================================ affiche '' affiche ' *** TOURS DE HANOI ***' affiche ' ' + nb_disques + ' disques - de A vers C via B' affiche '' // Initialisation : du plus grand au plus petit i est un nombre pour i de nb_disques à 1 pas - 1 appelle empilerTige(0, i) fin pour affiche ' Etat initial :' appelle afficherTours() // Resolution recursive appelle hanoi(nb_disques, 0, 2, 1) affiche ' Termine en ' + nb_mouvements + ' mouvements !' affiche ' Fin du programme.'

// ===================================================================== // COMPARAISON DE TEXTES PAR SCORE DE SIMILARITÉ (inspiré de BM25) // Écrit en langage EduCode // // Idée : on saisit plusieurs textes qui forment une "base" (par ex. // des spams déjà connus). Puis on saisit un NOUVEAU texte, et le // programme calcule un score de ressemblance avec chaque texte de la // base. Plus le score est élevé, plus les deux textes se ressemblent. // // Le score reprend l'esprit de BM25 : // - un mot présent dans les deux textes rapporte des points // - un mot RARE dans la base rapporte PLUS qu'un mot très courant // (pondération IDF : ln( (N + 1) / (nb_textes_contenant + 0.5) )) // ===================================================================== // --------------------------------------------------------------------- // Étape 1 : saisie des textes de la base // --------------------------------------------------------------------- base est un tableau // contient les textes saisis nb est un texte demande 'Combien de textes voulez-vous enregistrer dans la base ? ' dans nb nombre_textes est un nombre nombre_textes vaut convertir_nombre(nb) pour i de 1 à nombre_textes invite, saisie, nouveau est un texte invite vaut 'Texte n°' + convertir_texte(i) + ' : ' demande invite dans saisie base ajoute saisie fin pour affiche '' affiche 'Base enregistree : ' + convertir_texte(longueur(base)) + ' texte(s).' affiche '-------------------------------------------' // --------------------------------------------------------------------- // Étape 2 : saisie du texte à comparer // --------------------------------------------------------------------- demande 'Entrez le texte a comparer : ' dans nouveau mots_nouveau, scores est un tableau mots_nouveau vaut decouper(minuscules(nouveau), ' ') affiche '' affiche 'Texte teste : "' + nouveau + '"' affiche '===========================================' // --------------------------------------------------------------------- // Étape 3 : pré-découper les textes de la base en mots // --------------------------------------------------------------------- N, meilleur, score_max est un nombre N vaut longueur(base) base_mots est un tableau // tableau de tableaux de mots pour d de 0 à N - 1 m est un tableau m vaut decouper(minuscules(base[d]), ' ') base_mots ajoute m fin pour // --------------------------------------------------------------------- // Fonction : 1 si le mot est présent dans la liste, sinon 0 // --------------------------------------------------------------------- fonction presence(liste, mot) pour i de 0 à longueur(liste) - 1 si liste[i] = mot alors retourne 1 fin si fin pour retourne 0 fin fonction // --------------------------------------------------------------------- // Fonction : nombre d'occurrences d'un mot dans une liste // --------------------------------------------------------------------- fonction occurrences(liste, mot) n est un nombre n vaut 0 pour i de 0 à longueur(liste) - 1 si liste[i] = mot alors n ajoute 1 fin si fin pour retourne n fin fonction // --------------------------------------------------------------------- // Étape 4 : calculer le score de similarité du nouveau texte // avec chaque texte de la base // --------------------------------------------------------------------- pour d de 0 à N - 1 score est un nombre score vaut 0 // pour chaque mot du nouveau texte... pour t de 0 à longueur(mots_nouveau) - 1 mot est un texte mot vaut mots_nouveau[t] // combien de fois ce mot apparait-il dans le texte d de la base ? f est un nombre f vaut occurrences(base_mots[d], mot) si f > 0 alors // nb de textes de la base contenant ce mot (rarete -> IDF) df, idf est un nombre df vaut 0 pour k de 0 à N - 1 df ajoute presence(base_mots[k], mot) fin pour idf vaut logarithme((N + 1) / (df + 0.5)) // un mot rare (idf eleve) compte plus ; on sature f a 1+ln(f) score ajoute idf * (1 + logarithme(f + 1)) fin si fin pour scores ajoute score fin pour // --------------------------------------------------------------------- // Étape 5 : afficher les scores et trouver le texte le plus proche // --------------------------------------------------------------------- meilleur vaut 0 score_max vaut - 1 pour d de 0 à N - 1 affiche 'Similarite avec texte ' + convertir_texte(d) + ' = ' + decimal(scores[d], 4) affiche ' "' + base[d] + '"' si scores[d] > score_max alors score_max vaut scores[d] meilleur vaut d fin si fin pour affiche '' affiche '===========================================' // --------------------------------------------------------------------- // Étape 6 : verdict // --------------------------------------------------------------------- si score_max <= 0 alors affiche 'Aucune ressemblance trouvee avec la base.' sinon affiche 'Texte le plus proche : texte ' + convertir_texte(meilleur) affiche ' "' + base[meilleur] + '"' affiche 'Score de similarite : ' + decimal(score_max, 4) affiche '' // seuil simple pour décider si c'est "similaire" si score_max >= 2 alors affiche '⚠️ Le nouveau texte RESSEMBLE FORTEMENT a un texte connu.' affiche ' (s''il s''agit d''une base de spams : probable spam)' sinon affiche '✅ Ressemblance faible : texte probablement different.' fin si fin si

depart, n, etapes, maximum est un nombre depart vaut 27 affiche '=== CONJECTURE DE COLLATZ ===' affiche '' affiche 'Nombre de départ : ' + depart affiche 'Règle : pair -> /2 | impair -> 3n+1' affiche '' n vaut depart etapes vaut 0 maximum vaut depart ligne est un texte ligne vaut '' + depart tant que n <> 1 si n % 2 = 0 alors // pair n vaut n / 2 sinon // impair n vaut 3 * n + 1 fin si etapes vaut etapes + 1 si n > maximum alors maximum vaut n fin si ligne vaut ligne + ' -> ' + n fin tant que affiche 'Suite parcourue :' affiche ligne affiche '' affiche '--- Bilan ---' affiche 'Nombre d''étapes pour atteindre 1 : ' + etapes affiche 'Altitude maximale atteinte : ' + maximum affiche '' affiche 'La suite est retombée sur 1 : conjecture vérifiée'