Guide d'Algorithmes en AlgoFX

Structure de Base d'un Algorithme

Tout algorithme suit une structure standard composée de trois parties principales :

Algorithme NomAlgorithme;
Var
    // Déclarations de variables
    nom: Type;
    a, b, c: entier;  // Déclaration multiple
Const
    p=3.1415; // Déclaration des constantes
Debut
    // Instructions
Fin

Types de Données

Variables et Constantes

Déclaration de Variables

var
    age: entier;
    nom: chaine de caractere;
    a, b, c: entier;  // Déclaration multiple
    estValide: booleen;

Déclaration de Constantes

const
    PI = 3.14159;
    TAUX_TVA = 20.0;
    MESSAGE_BIENVENUE = "Bonjour !";

Opérations et Expressions

Opérateurs Arithmétiques

Opérateurs Relationnels

Opérateurs Logiques

Instructions de Base

Affectation

variable <- valeur;

Exemple : somme <- a + b;

Lecture (Entrée)

lire(variable);
lire(a, b, c);  // Lecture multiple

Écriture (Sortie)

ecrire("Texte");
ecrire(a, b, "Résultat:", resultat);  // Sortie multiple

Structures de Contrôle

Condition Simple

si condition alors
    instructions
finsi

Condition avec Alternative

si condition alors
    instructions1
sinon
    instructions2
finsi

Conditions Imbriquées

si condition1 alors
    instructions1
sinon
    si condition2 alors
        instructions2
    sinon
        instructions3
    finsi
finsi

Boucle TANT QUE

tantque condition faire
    instructions
fintantque

Boucle POUR

pour variable de valeur1 a valeur2 faire
    instructions
finpour

// Avec un pas spécifique
pour variable de valeur1 a valeur2 pas n faire
    instructions
finpour

Instruction SORTIR

Permet de sortir d'une boucle prématurément :

tantque condition faire
    si autreCondition alors
        sortir;  // Quitte la boucle
    finsi
    instructions
fintantque

Fonctions Mathématiques

• racine(x) : Calcule la racine carrée de x
• puissance : Opérateur puissance (ex: 2 puissance 3 = 8)
• mod : Opérateur modulo (reste de la division)
• div : Division entière

Exemples Complets

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

Bonnes Pratiques

• Utilisez des noms de variables descriptifs.
• Indentez correctement votre code pour améliorer la lisibilité.
• Ajoutez des commentaires pour expliquer la logique complexe.
• Décomposez les problèmes complexes en étapes plus simples.
• Testez votre algorithme avec différents cas d'entrée.
• Utilisez des constantes pour les valeurs qui ne changent pas.