Aide – AlgoFX

1. Introduction

Qu'est-ce que AlgoFX ?

AlgoFX est un outil pédagogique qui vous permet d'écrire et d'exécuter des algorithmes. Cela signifie que vous pouvez taper des instructions dans l'éditeur, puis cliquer sur "Exécuter" pour voir ce qui se passe.

AlgoFX vous aide à apprendre la logique algorithmique. À ce moment-là, vous ne programmez pas dans un vrai langage comme Python ou Java. Vous apprenez à penser comme un ordinateur.

Ce que AlgoFX n'est PAS

Pourquoi apprendre les algorithmes ?

Imaginez que vous voulez expliquer à quelqu'un comment préparer un gâteau. Vous devez donner des étapes précises : mélanger les ingrédients, chauffer le four, cuire pendant 30 minutes. C'est exactement ce qu'est un algorithme : une suite d'instructions claires pour accomplir une tâche.

Les algorithmes sont partout : dans les calculatrices, les jeux vidéo, les réseaux sociaux, les GPS. Apprendre à écrire des algorithmes, c'est apprendre à résoudre des problèmes de manière logique et structurée.

2. Comment lire un algorithme

Structure de base

Tous les algorithmes dans AlgoFX suivent la même structure. Voici un exemple très simple :

Algorithme MonPremierAlgo;
Var
    nombre: entier;
Debut
    ecrire("Bonjour !");
Fin

Regardons chaque partie :

La déclaration de l'algorithme

La première ligne commence toujours par le mot Algorithme suivi du nom que vous donnez à votre programme. Cela signifie simplement : "Voici le début de mon algorithme et il s'appelle MonPremierAlgo".

La section Var

Le mot Var introduit la zone où vous déclarez vos variables. Ne vous inquiétez pas, nous expliquerons les variables juste après. Pour l'instant, retenez que c'est ici que vous dites à l'algorithme : "J'aurai besoin de ces espaces mémoire".

La section Debut et Fin

Entre Debut et Fin, vous écrivez les instructions que l'algorithme doit exécuter. À ce moment-là, l'ordinateur lit chaque ligne dans l'ordre, de haut en bas, comme vous lisez un livre.

L'ordre d'exécution

Imaginez que vous suivez une recette de cuisine. Vous ne commencez pas par la cuisson si la recette dit de d'abord mélanger les ingrédients. L'algorithme fonctionne exactement de la même manière.

L'importance de chaque ligne

Chaque instruction dans un algorithme a un rôle précis. Si vous oubliez une ligne ou si vous la placez au mauvais endroit, l'algorithme ne fonctionnera pas correctement. C'est comme oublier d'allumer le four avant de mettre le gâteau à cuire.

3. Les variables

Qu'est-ce qu'une variable ?

Une variable est comme une boîte avec une étiquette. Dans cette boîte, vous pouvez mettre une valeur. Imaginez que vous avez une boîte étiquetée "âge" et vous y mettez le nombre 15. Plus tard, vous pouvez regarder dans cette boîte pour savoir quel âge est stocké, ou vous pouvez changer la valeur à 16.

Déclaration des variables

Avant d'utiliser une variable, vous devez la déclarer. Cela signifie que vous dites à l'algorithme : "Je vais utiliser une boîte qui s'appelle X et elle contiendra tel type de valeur".

Voici comment déclarer des variables dans AlgoFX :

Var
    age: entier;
    nom: chaine;
    taille: reel;

Dans cet exemple :

• age est une variable de type entier (un nombre sans virgule comme 5, 10, 100)
• nom est une variable de type chaine (du texte comme "Marie", "Paris")
• taille est une variable de type reel (un nombre avec virgule comme 1.75, 3.14)

Les types de données dans AlgoFX

Affectation de valeurs

Une fois qu'une variable est déclarée, vous pouvez lui donner une valeur. On utilise la flèche <- pour dire "mettre dans". Lisez toujours cette flèche comme "reçoit la valeur".

Debut
    age <- 15;
    nom <- "Marie";
    taille <- 1.65;
Fin

À ce moment-là, la variable age contient 15, nom contient "Marie", et taille contient 1.65.

Changement de valeur

Une variable peut changer de valeur pendant l'exécution de l'algorithme. C'est pour cela qu'on l'appelle "variable" : sa valeur varie.

Debut
    age <- 15;
    ecrire(age);
    age <- 16;
    ecrire(age);
Fin

Ici, l'algorithme affiche d'abord 15, puis 16. La valeur d'age a changé entre les deux affichages.

Visualisation des variables dans AlgoFX

Les constantes

Une constante est comme une variable, mais sa valeur ne peut jamais changer. Imaginez une étiquette collée sur une boîte qui dit "NE PAS MODIFIER". Les constantes sont utiles pour les valeurs fixes comme le nombre Pi.

Const
    PI = 3.14159;
Debut
    ecrire(PI);
Fin

Une fois définie, vous ne pouvez plus modifier PI. Si vous essayez, AlgoFX affichera une erreur.

4. Entrées et sorties

Écrire (afficher des informations)

Pour afficher quelque chose à l'écran, on utilise l'instruction ecrire(). Cela signifie : "Montre ce message à l'utilisateur".

Debut
    ecrire("Bonjour le monde !");
Fin

Vous pouvez afficher du texte (entre guillemets) ou des variables :

Var
    age: entier;
Debut
    age <- 20;
    ecrire("Votre âge est :", age);
Fin

Ce programme affichera : Votre âge est : 20

Lire (recevoir des informations de l'utilisateur)

Pour demander à l'utilisateur d'entrer une valeur, on utilise lire(). Cela signifie : "Attends que l'utilisateur tape quelque chose, puis stocke cette valeur dans la variable".

Var
    nom: chaine;
Debut
    ecrire("Quel est votre nom ?");
    lire(nom);
    ecrire("Bonjour", nom);
Fin

Quand l'algorithme arrive à lire(nom), il s'arrête et attend. L'utilisateur tape son nom, puis l'algorithme continue et affiche "Bonjour" suivi du nom entré.

Interaction complète avec l'utilisateur

Voici un exemple qui combine lecture et écriture :

Var
    nombre1, nombre2, somme: entier;
Debut
    ecrire("Entrez le premier nombre :");
    lire(nombre1);
    ecrire("Entrez le deuxième nombre :");
    lire(nombre2);
    
    somme <- nombre1 + nombre2;
    
    ecrire("La somme est :", somme);
Fin

L'algorithme demande deux nombres, calcule leur somme, puis affiche le résultat. À ce moment-là, l'utilisateur participe activement au déroulement du programme.

5. Les conditions

Pourquoi utiliser des conditions ?

Imaginez que vous sortez de chez vous. Si il pleut, vous prenez un parapluie. Sinon, vous n'en prenez pas. C'est exactement ce qu'est une condition : faire quelque chose seulement si une situation est vraie.

La structure Si / Alors

Dans AlgoFX, on écrit les conditions avec si, alors, et finsi :

Var
    age: entier;
Debut
    ecrire("Quel est votre âge ?");
    lire(age);
    
    si age >= 18 alors
        ecrire("Vous êtes majeur");
    finsi
Fin

Ici, le message "Vous êtes majeur" s'affiche seulement si l'âge est supérieur ou égal à 18. Sinon, l'algorithme ne fait rien et passe directement à la fin.

Si / Sinon

Souvent, on veut faire une chose si la condition est vraie, et une autre chose si elle est fausse :

Var
    age: entier;
Debut
    ecrire("Quel est votre âge ?");
    lire(age);
    
    si age >= 18 alors
        ecrire("Vous êtes majeur");
    sinon
        ecrire("Vous êtes mineur");
    finsi
Fin

Maintenant, l'algorithme affiche toujours un message : soit "majeur" si l'âge est 18 ou plus, soit "mineur" dans le cas contraire.

Les opérateurs de comparaison

Conditions composées

Vous pouvez combiner plusieurs conditions avec et et ou :

si age >= 18 et age < 65 alors
    ecrire("Vous êtes en âge de travailler");
finsi

Le mot et signifie que les deux conditions doivent être vraies. Le mot ou signifie qu'au moins une des conditions doit être vraie.

Vrai et Faux (booléens)

Dans AlgoFX, vrai et faux sont des valeurs spéciales. Une variable de type booleen peut seulement contenir l'une de ces deux valeurs :

Var
    estMajeur: booleen;
    age: entier;
Debut
    lire(age);
    estMajeur <- age >= 18;
    
    si estMajeur = vrai alors
        ecrire("Majeur");
    finsi
Fin

6. Les boucles

Pourquoi répéter une action ?

Imaginez que vous devez écrire les nombres de 1 à 100. Vous ne voulez pas écrire 100 instructions ecrire() ! Les boucles permettent de répéter automatiquement une action plusieurs fois.

La boucle POUR

La boucle pour est utilisée quand vous savez exactement combien de fois vous voulez répéter quelque chose.

Var
    i: entier;
Debut
    pour i de 1 a 5 faire
        ecrire(i);
    finpour
Fin

Ce programme affiche les nombres 1, 2, 3, 4, 5. À ce moment-là, la variable i prend chaque valeur de 1 à 5, une par une. C'est comme compter sur vos doigts : premier doigt, deuxième doigt, etc.

Boucle avec un pas différent

Vous pouvez changer la vitesse de comptage avec le mot pas :

pour i de 0 a 10 pas 2 faire
    ecrire(i);
finpour

Ici, l'algorithme affiche 0, 2, 4, 6, 8, 10. Il saute de 2 en 2.

La boucle TANT QUE

La boucle tantque répète tant qu'une condition est vraie. Vous ne savez pas forcément combien de fois la boucle va tourner.

Var
    nombre: entier;
Debut
    nombre <- 1;
    
    tantque nombre <= 5 faire
        ecrire(nombre);
        nombre <- nombre + 1;
    fintantque
Fin

Ce programme affiche aussi 1, 2, 3, 4, 5. Mais cette fois, la boucle continue tant que nombre est inférieur ou égal à 5. À chaque tour, on ajoute 1 à nombre.

Quand utiliser POUR ou TANT QUE ?

• Utilisez pour quand vous savez combien de fois répéter (par exemple : afficher les 10 premiers nombres)
• Utilisez tantque quand vous ne savez pas à l'avance (par exemple : demander un mot de passe jusqu'à ce qu'il soit correct)

L'instruction SORTIR

Parfois, vous voulez arrêter une boucle avant la fin normale. L'instruction sortir permet de quitter immédiatement une boucle :

Var
    i: entier;
Debut
    pour i de 1 a 100 faire
        ecrire(i);
        
        si i = 10 alors
            sortir;
        finsi
    finpour
    
    ecrire("Boucle terminée");
Fin

Ce programme affiche les nombres de 1 à 10, puis sort de la boucle même si elle devait aller jusqu'à 100.

8. Exécution pas à pas dans AlgoFX

Qu'est-ce que le mode pas à pas ?

Le mode "Pas à Pas" est une fonctionnalité unique d'AlgoFX qui vous permet d'exécuter votre algorithme ligne par ligne. Au lieu de tout exécuter d'un coup, vous avancez instruction par instruction. Cela signifie que vous pouvez observer exactement ce qui se passe à chaque étape.

Comment utiliser le mode pas à pas

1. Écrivez votre algorithme dans l'éditeur
2. Cliquez sur le bouton "⏯ Pas à Pas"
3. L'algorithme se prépare mais ne démarre pas encore
4. Cliquez sur "➡ Suivant" pour exécuter la ligne suivante
5. Continuez à cliquer sur "Suivant" pour avancer ligne par ligne
6. Cliquez sur "⏹ Arrêter" si vous voulez arrêter avant la fin

Le tableau de visualisation des variables

Pendant l'exécution pas à pas, AlgoFX affiche un panneau spécial à droite de l'écran. Ce panneau montre toutes vos variables et leurs valeurs actuelles. À chaque fois que vous cliquez sur "Suivant", les valeurs se mettent à jour automatiquement.

Comprendre les erreurs avec le mode pas à pas

Si votre algorithme ne fonctionne pas comme prévu, le mode pas à pas est votre meilleur ami. Vous pouvez voir exactement à quelle ligne le problème apparaît et quelle valeur inattendue apparaît dans une variable.

Par exemple, si vous calculez une moyenne et obtenez un résultat bizarre, utilisez le pas à pas pour vérifier que vos variables contiennent bien les bonnes valeurs avant le calcul.

9. Erreurs fréquentes

Erreurs de syntaxe

Les erreurs de syntaxe sont comme des fautes d'orthographe dans votre algorithme. AlgoFX ne comprend pas ce que vous voulez dire et refuse d'exécuter le programme.

Oubli du point-virgule

age <- 15    // ERREUR : il manque le point-virgule
age <- 15;   // CORRECT

Mauvaise utilisation de la flèche d'affectation

age = 15;     // ERREUR : il faut <-
age <- 15;    // CORRECT

Variable non déclarée

Debut
    age <- 15;  // ERREUR : age n'est pas déclaré dans Var
Fin

Vous devez toujours déclarer vos variables dans la section Var avant de les utiliser.

Oubli de finsi, finpour, ou fintantque

si age >= 18 alors
    ecrire("Majeur");
// ERREUR : il manque finsi

Erreurs de logique

Les erreurs de logique sont plus difficiles à détecter. L'algorithme s'exécute sans erreur, mais le résultat n'est pas celui attendu.

Condition inversée

si age < 18 alors
    ecrire("Vous êtes majeur");  // ERREUR : la logique est inversée
finsi

Boucle infinie

nombre <- 1;
tantque nombre <= 10 faire
    ecrire(nombre);
    // ERREUR : on oublie d'augmenter nombre
fintantque

Mauvais ordre d'opérations

somme <- somme + nombre;  // Si utilisé avant d'initialiser somme
// Il faut d'abord : somme <- 0;

Erreurs des débutants

Confondre affectation et comparaison

• <- signifie "donner une valeur" (affectation)
• = signifie "comparer" (égalité)

Oublier les guillemets pour le texte

ecrire(Bonjour);   // ERREUR
ecrire("Bonjour"); // CORRECT

Type incompatible

Var
    age: entier;
Debut
    age <- "quinze";  // ERREUR : "quinze" est du texte, pas un entier
Fin

10. Exemples expliqués

Algorithme SurfaceCarre;
Var
    cote, surface: reel;
Debut
    ecrire("Entrez le côté du carré:");
    lire(cote);
    
    surface <- cote * cote;
    
    ecrire("La surface du carré est:", surface);
Fin

Algorithme RectangleSurfacePerimetre;
Var
    longueur, largeur, surface, perimetre: reel;
Debut
    ecrire("Entrez la longueur du rectangle:");
    lire(longueur);
    ecrire("Entrez la largeur du rectangle:");
    lire(largeur);
    
    surface <- longueur * largeur;
    perimetre <- 2 * (longueur + largeur);
    
    ecrire("Surface du rectangle:", surface);
    ecrire("Périmètre du rectangle:", perimetre);
Fin

Algorithme CalculMoyenne;
Var
    note1, note2, note3, moyenne: reel;
Debut
    ecrire("Entrez trois notes:");
    lire(note1, note2, note3);
    
    moyenne <- (note1 + note2 + note3) / 3;
    
    ecrire("La moyenne est:", moyenne);
    
    si moyenne >= 10 alors
        ecrire("Félicitations, vous avez réussi!");
    sinon
        ecrire("Vous devez vous améliorer.");
    finsi
Fin

Algorithme ConversionTemperature;
Var
    choix: entier;
    celsius, fahrenheit: reel;
Debut
    ecrire("Conversion de température");
    ecrire("1- Celsius vers Fahrenheit");
    ecrire("2- Fahrenheit vers Celsius");
    ecrire("Entrez votre choix (1 ou 2):");
    
    lire(choix);
    
    si choix = 1 alors
        ecrire("Entrez la température en Celsius:");
        lire(celsius);
        fahrenheit <- (celsius * 9/5) + 32;
        ecrire(celsius, "°C équivaut à", fahrenheit, "°F");
    sinon
        si choix = 2 alors
            ecrire("Entrez la température en Fahrenheit:");
            lire(fahrenheit);
            celsius <- (fahrenheit - 32) * 5/9;
            ecrire(fahrenheit, "°F équivaut à", celsius, "°C");
        sinon
            ecrire("Choix invalide");
        finsi
    finsi
Fin

Algorithme CalculCercle;
Var
    rayon, surface, circonference: reel;
Const
    PI = 3.14159;
Debut
    ecrire("Entrez le rayon du cercle:");
    lire(rayon);
    
    surface <- PI * rayon * rayon;
    circonference <- 2 * PI * rayon;
    
    ecrire("Surface du cercle:", surface);
    ecrire("Circonférence du cercle:", circonference);
Fin

Algorithme EquationPremierDegre;
Var
    a, b, x: reel;
Debut
    ecrire("Résolution de l'équation ax + b = 0");
    ecrire("Entrez la valeur de a:");
    lire(a);
    ecrire("Entrez la valeur de b:");
    lire(b);
    
    si a = 0 alors
        si b = 0 alors
            ecrire("L'équation admet une infinité de solutions");
        sinon
            ecrire("L'équation n'admet pas de solution");
        finsi
    sinon
        x <- -b / a;
        ecrire("La solution est x =", x);
    finsi
Fin

Algorithme AfficherNombres;
Var
    nbLimite, i: entier;
Debut
    ecrire("Entrer un nombre limite:");
    lire(nbLimite);
    
    pour i de 1 a nbLimite faire
        ecrire(i);
    finpour
Fin

Algorithme NombresPairs;
Var
    n, i: entier;
Debut
    ecrire("Entrez la valeur limite n:");
    lire(n);
    
    ecrire("Nombres pairs de 0 à", n, ":");
    
    pour i de 0 a n pas 2 faire
        ecrire(i);
    finpour
Fin

Algorithme NombresImpairs;
Var
    n, i: entier;
Debut
    ecrire("Entrez la valeur limite n:");
    lire(n);
    
    ecrire("Nombres impairs de 1 à", n, ":");
    
    pour i de 1 a n pas 2 faire
        ecrire(i);
    finpour
Fin

Algorithme TableMultiplication;
Var
    nombre, i, resultat: entier;
Debut
    ecrire("Quelle table voulez-vous afficher?");
    lire(nombre);
    
    pour i de 1 a 10 faire
        resultat <- nombre * i;
        ecrire(nombre, "x", i, "=", resultat);
    finpour
Fin

Algorithme Somme10;
Var
    i, valeurEntree, somme: entier;
Debut
    somme <- 0;
    
    pour i de 1 a 10 faire
        ecrire("Entrer un nombre:");
        lire(valeurEntree);
        somme <- somme + valeurEntree;
    finpour
    
    ecrire("La somme est:", somme);
Fin

Algorithme SommeN;
Var
    n, i, nombre, somme: entier;
Debut
    ecrire("Combien de nombres voulez-vous additionner?");
    lire(n);
    
    somme <- 0;
    pour i de 1 a n faire
        ecrire("Entrez le nombre", i, ":");
        lire(nombre);
        somme <- somme + nombre;
    finpour
    
    ecrire("La somme des", n, "nombres est:", somme);
Fin

Algorithme MotDePasse;
Var
    mot : chaine;
Debut
    Ecrire("Veuillez saisir le mot de passe :");
    lire(mot);

    tantque mot != "0000" faire
        Ecrire("Mot de passe incorrect. Veuillez réessayer :");
        lire(mot);
    fintantque

    Ecrire("Mot de passe correct. Bienvenue !");
Fin

Algorithme Factoriel;
Var
    n, fact, i: entier;
Debut
    ecrire("Entrez un nombre pour calculer sa factorielle:");
    lire(n);
    
    fact <- 1;
    
    pour i de 1 a n faire
        fact <- fact * i;
    finpour
    
    ecrire("La factorielle de", n, "est", fact);
Fin

Algorithme RechercheMaximum;
Var
    n, nombre, maximum, i: entier;
Debut
    ecrire("Combien de nombres voulez-vous comparer?");
    lire(n);
    
    ecrire("Entrez le nombre 1:");
    lire(nombre);
    maximum <- nombre;
    i <- 2;
    
    tantque i <= n faire
        ecrire("Entrez le nombre", i, ":");
        lire(nombre);
        
        si nombre > maximum alors
            maximum <- nombre;
        finsi
        
        i <- i + 1;
    fintantque
    
    ecrire("Le maximum est:", maximum);
Fin

Algorithme VerificationPalindrome;
Var
    nombre, copie, inverse, chiffre: entier;
Debut
    ecrire("Entrez un nombre:");
    lire(nombre);
    
    copie <- nombre;
    inverse <- 0;
    
    tantque copie > 0 faire
        chiffre <- copie mod 10;
        inverse <- inverse * 10 + chiffre;
        copie <- copie div 10;
    fintantque
    
    si nombre = inverse alors
        ecrire(nombre, "est un palindrome");
    sinon
        ecrire(nombre, "n'est pas un palindrome");
    finsi
Fin

Algorithme DecimalVersBinaire;
Var
    nombreDecimal, binaire, reste, multiplicateur: entier;
Debut
    ecrire("Entrez un nombre entier en base décimale:");
    lire(nombreDecimal);
    
    binaire <- 0;
    multiplicateur <- 1;
    
    tantque nombreDecimal <> 0 faire
        reste <- nombreDecimal mod 2;
        binaire <- binaire + (reste * multiplicateur);
        nombreDecimal <- nombreDecimal div 2;
        multiplicateur <- multiplicateur * 10;
    fintantque
    
    ecrire("Représentation binaire:", binaire);
Fin

Algorithme MotDePasse;
Var
    mot : chaine;
    essai : entier;
Debut
    essai <- 1;

    tantque essai <= 3 et mot != "0000" faire
        Ecrire("Entrez le mot de passe :");
        lire(mot);

        si mot != "0000" alors
            Ecrire("Mot de passe incorrect.");
        finsi

        essai <- essai + 1;
    fintantque

    si mot = "0000" alors
        Ecrire("Accès autorisé.");
    sinon
        Ecrire("Accès refusé.");
    finsi
Fin

Algorithme SuiteFibonacci;
Var
    n, i, a, b, c: entier;
Debut
    ecrire("Combien de termes de la suite de Fibonacci voulez-vous?");
    lire(n);
    
    ecrire("Suite de Fibonacci:");
    
    si n >= 1 alors
        ecrire(0);
    finsi
    
    si n >= 2 alors
        ecrire(1);
    finsi
    
    a <- 0;
    b <- 1;
    
    pour i de 3 a n faire
        c <- a + b;
        ecrire(c);
        a <- b;
        b <- c;
    finpour
Fin

Algorithme CalculPGCD;
Var
    a, b, r: entier;
Debut
    ecrire("Entrez le premier nombre:");
    lire(a);
    ecrire("Entrez le deuxième nombre:");
    lire(b);
    
    si a < b alors
        r <- a;
        a <- b;
        b <- r;
    finsi
    
    tantque b <> 0 faire
        r <- a mod b;
        a <- b;
        b <- r;
    fintantque
    
    ecrire("Le PGCD est:", a);
Fin

Algorithme EquationSecondDegre;
Var
    a, b, c, delta, x1, x2: reel;
Debut
    ecrire("Résolution de l'équation ax² + bx + c = 0");
    ecrire("Entrez la valeur de a:");
    lire(a);
    ecrire("Entrez la valeur de b:");
    lire(b);
    ecrire("Entrez la valeur de c:");
    lire(c);
    
    si a = 0 alors
        si b = 0 alors
            si c = 0 alors
                ecrire("L'équation admet une infinité de solutions");
            sinon
                ecrire("L'équation n'admet pas de solution");
            finsi
        sinon
            x1 <- -c / b;
            ecrire("L'équation est du premier degré, la solution est x =", x1);
        finsi
    sinon
        delta <- b * b - 4 * a * c;
        
        si delta < 0 alors
            ecrire("L'équation n'admet pas de solution réelle");
        sinon
            si delta = 0 alors
                x1 <- -b / (2 * a);
                ecrire("L'équation admet une solution double: x =", x1);
            sinon
                x1 <- (-b - racine(delta)) / (2 * a);
                x2 <- (-b + racine(delta)) / (2 * a);
                ecrire("L'équation admet deux solutions:");
                ecrire("x1 =", x1);
                ecrire("x2 =", x2);
            finsi
        finsi
    finsi
Fin

Algorithme CalculPPCM;
Var
    a, b, pgcd, ppcm: entier;
    temp_a, temp_b, r: entier;
Debut
    ecrire("Entrez le premier nombre:");
    lire(a);
    ecrire("Entrez le deuxième nombre:");
    lire(b);
    
    temp_a <- a;
    temp_b <- b;
    
    si a < b alors
        r <- a;
        a <- b;
        b <- r;
    finsi
    
    tantque b <> 0 faire
        r <- a mod b;
        a <- b;
        b <- r;
    fintantque
    
    pgcd <- a;
    ppcm <- (temp_a * temp_b) / pgcd;
    
    ecrire("Le PPCM est:", ppcm);
Fin

Algorithme NombresPremiers;
var
    n, i, j, temp: entier;
    estPremier: booleen;
debut
    ecrire("Entrez la limite N:");
    lire(n);
    
    ecrire("Nombres premiers jusqu'à", n, ":");
    
    pour i de 2 a n faire
        estPremier <- vrai;
        
        pour j de 2 a i-1 faire
            temp <- i mod j;
            si temp = 0 alors
                estPremier <- faux;
                sortir;
            finsi
        finpour
        
        si estPremier = vrai alors
            ecrire(i);
        finsi
    finpour
Fin

10. Conseils pour progresser

Comment s'entraîner efficacement

1. Commencez petit

Ne cherchez pas à écrire des algorithmes complexes dès le début. Commencez par des choses simples : afficher du texte, faire une addition, demander un nom. Une fois que vous maîtrisez les bases, passez à des problèmes plus difficiles.

2. Tapez vous-même les exemples

Ne vous contentez pas de lire les exemples. Tapez-les dans AlgoFX, exécutez-les, modifiez-les. Changez les valeurs, ajoutez des instructions, cassez le code et réparez-le. C'est en faisant qu'on apprend vraiment.

3. Utilisez le mode pas à pas

Pour chaque exemple, exécutez-le en mode pas à pas au moins une fois. Observez comment les variables changent. Essayez de prédire ce qui va se passer à la prochaine ligne avant de cliquer sur "Suivant".

4. Modifiez les exemples

Prenez un exemple qui fonctionne et posez-vous des questions : "Et si je voulais afficher aussi le périmètre ?", "Et si je voulais demander 5 nombres au lieu de 3 ?", "Et si je voulais que la boucle compte à l'envers ?". Puis essayez de le faire.

5. Résolvez vos propres problèmes

Inventez vos propres exercices. Par exemple :

• Calculer le prix TTC d'un produit (prix HT + TVA)
• Convertir des kilomètres en miles
• Afficher votre âge dans 10 ans
• Calculer combien de jours il y a dans n semaines

Comment corriger ses erreurs

Lisez le message d'erreur

AlgoFX vous dit toujours où est le problème. Lisez attentivement le message. Il vous indique souvent la ligne exacte et ce qui ne va pas.

Utilisez le bouton Compiler

Avant d'exécuter, cliquez sur "⚙️ Compiler" pour vérifier qu'il n'y a pas d'erreurs de syntaxe. C'est plus rapide que d'exécuter pour découvrir une faute de frappe.

Comparez avec un exemple qui fonctionne

Si votre algorithme ne marche pas, comparez-le avec un exemple similaire dans cette aide. Regardez les différences : avez-vous oublié un finsi ? Avez-vous mis = au lieu de <- ?

Simplifiez pour isoler le problème

Si votre algorithme est compliqué et ne fonctionne pas, commentez (avec //) la moitié du code pour voir quelle partie pose problème. Ou créez une version plus simple qui teste juste la partie suspecte.

Vérifiez vos variables

Utilisez le tableau des variables en mode pas à pas. Souvent, une erreur vient d'une variable qui contient une valeur inattendue. Si vous voyez que somme vaut 0 alors qu'elle devrait valoir 15, vous savez où chercher.

Comment penser comme un algorithme

Décomposez le problème

Avant d'écrire une seule ligne de code, décrivez le problème en français simple. Par exemple, pour calculer une moyenne :

1. Demander combien de notes
2. Demander chaque note et les additionner
3. Diviser la somme par le nombre de notes
4. Afficher le résultat

Une fois que vous avez ces étapes, transformez chacune en code.

Soyez précis

L'ordinateur fait exactement ce que vous lui dites, pas ce que vous voulez. Si vous écrivez si age > 18, cela exclut 18. Si vous voulez inclure 18, écrivez si age >= 18. Chaque détail compte.

Testez avec des exemples

Avant d'exécuter votre algorithme, testez-le mentalement avec des valeurs simples. Si vous calculez une moyenne de 10, 20, 30, vous savez que le résultat doit être 20. Si votre algorithme affiche 60, vous savez qu'il y a un problème.

Une chose à la fois

N'essayez pas de tout faire en même temps. Écrivez d'abord l'algorithme qui lit les valeurs et les affiche. Une fois que ça marche, ajoutez le calcul. Une fois que ça marche, ajoutez les conditions. Construisez progressivement.

Derniers conseils

Prochaines étapes

Une fois que vous maîtrisez bien AlgoFX, vous serez prêt à apprendre un vrai langage de programmation comme Python, JavaScript, ou Java. Vous verrez que la logique est exactement la même. Tout ce que vous apprenez maintenant avec AlgoFX vous servira pour toute votre vie de programmeur.

Bon courage, et surtout, prenez plaisir à créer vos premiers algorithmes !