Programmation: Variables et Organigrammes

Partie 1: L'Algorithmique

• L'algorithmique est une introduction au concept d'algorithmes et à leur représentation graphique (organigramme).
• Les éléments couverts comprennent les instructions de contrôle et les instructions répétitives.
• Ce domaine d'étude est pertinent pour le développement de programmes informatiques.

Qu'est-ce qu'un algorithme ?

• Un algorithme est une séquence d'instructions (actions) logiquement ordonnées permettant de résoudre un problème donné.
• Il n'y a pas d'algorithme sans problème. Un algorithme est toujours lié à un problème précis.
• Un algorithme se traduit en un programme exécuté par un ordinateur.

Définition 02

• Un algorithme représente une séquence d'actions (instructions) logiquement ordonnées, transformant les entrées (inputs) en sorties (outputs). Ces dernières représentent la solution au problème posé.

Analyse et Résolution d'un problème

• Le processus comprend l'analyse du problème, la spécification du modèle, l'écriture de l'algorithme, la traduction en programme et l'exécution pour obtenir des résultats.

Définition et Objectif d'un algorithme

• Un algorithme est une description de la solution d'un problème, sous forme d'une suite finie d'opérations à effectuer sur les données du problème.
• Pour fonctionner, un algorithme doit contenir uniquement les instructions compréhensibles par celui qui devra l'exécuter.

Structure d'un algorithme (1/3)

• L'entête d'un algorithme permet de l'identifier avec un nom unique (Identificateur).
• La section Déclarations introduit les variables et constantes utilisées.
• Le corps (Instructions) spécifie les actions à effectuer (entrées, traitement, sorties).

Structure d'un algorithme (2/3)

• Des exemples d'entêtes d'algorithmes sont présentés, comme Algorithme exo1, Algorithme Equation1D, etc.
• Des exemples de déclarations de constantes (comme PI = 3.14) et de variables (comme nom = 'Université Zohr') sont illustrés.

Structure d'un algorithme (3/3)

• Les types de base de données incluent Entier, Réel, Caractère, Chaîne de Caractère et Booléen.
• Les nombres naturels sont un sous-ensemble du type Entier.
• Des exemples de déclarations de variables (comme a : entier, b : réel, x, y, z : entiers) sont donnés.

Instructions élémentaires en algorithmique

• Les trois instructions élémentaires de base sont l'affectation, l'entrée de données et la sortie de données.

Données: Variables & Constantes

• Une donnée représente une information liée à un élément du problème traité par l'algorithme.
• Une variable est un objet contenant une valeur pouvant être modifiée dans la mémoire vive d'un ordinateur.
• Une constante est un objet contenant une valeur fixe qui ne peut pas être modifiée.

Données: Identificateurs

• Chaque donnée (variable ou constante) manipulée par un algorithme est désignée par un nom unique, l'identificateur.
• L'identificateur est une chaîne de caractères alphanumériques.
• L'identificateur ne doit pas commencer par un chiffre.

Données: Types des variables

• Les types des variables définissent l'ensemble des valeurs possibles, la taille en mémoire et les opérations autorisées.
• Les types disponibles incluent les entiers, les réels, les caractères, les chaînes et les booléens.

Instruction élémentaire: Affectation

• L'affectation assigne une valeur à un objet.
• La syntaxe utilise le symbole ←.
• Le membre droit d'une affectation (valeur) peut être une variable, une constante ou une expression.

Instructions élémentaires: Affectations incorrectes

• Le membre gauche d'une affectation (lvalue) doit être une variable déclarée.
• Le membre droit d'une affectation doit représenter une quantité bien définie.

Instructions élémentaires: Affectation (Exemples)

• Les exemples d'affectations montrent comment les variables X et Y sont affectées.
• La structure de l'algorithme avec les affectations spécifiques est présentée.

Instructions élémentaires: Données Entrées et Sorties

• Les données d'entrée sont les données fournies par l'utilisateur.
• Les données de sortie sont les résultats générés et affichés par l'algorithme.
• Les données intermédiaires sont les données utilisées dans le traitement du problème par l'algorithme.

Instruction d'entrée

• L'instruction Lire est utilisée pour introduire des valeurs d'entrée à partir du clavier ou d'un fichier.
• Lire(maVar) permet d'affecter à maVar la valeur lue sur l'entrée.

Instruction de sortie

• L'instruction Écrire (ou Afficher) permet d'afficher des données à l'utilisateur (écran, fichier, etc.).
• Écrire(monRésultat) affiche la valeur de monRésultat.

Exercice: Analyse du périmètre d'un cercle

• L'exercice décrit comment calculer le périmètre d'un cercle en fonction du rayon et de valeur de π.
• L'analyse indique clairement les entrées (leRayon), les constantes (PI = 3.14) et la sortie (lePerimetre).

Algorithme A1

• L'algorithme A1 calcule (avec une constante π) le périmètre d'un cercle donné.
• La notation (Lire(leRayon)) permet de lire la valeur du rayon donnée.
• La notation (lePerimetre←2*PI*lerayon) permet de calculer le périmètre d'un cercle.
• La commande (Ecrire(lePerimetre)) affiche ce résultat.

Résumé

• Un algorithme décrit une solution sous forme d'une suite d'opérations.
• Les données peuvent être des variables ou des constantes.
• Un algorithme doit avoir une structure bien définie pour être traduit en programme.

Organigrammes

• Un organigramme est une représentation schématique d'un algorithme, qui met l'accent sur sa structure (les différents modules de traitement et la succession des opérations).
• Des symboles spécifiques (Début, Séquence, Tests et décisions) sont utilisés.

Organigrammes: Variante de l'alternative

• L'instruction selon permet de choisir une instruction en fonction de la valeur d'une variable (branchement vers différents blocs).

Organigramme: Calculer le périmètre d'un cercle (traduction de l'algorithme)

• Il s'agit d'une traduction visuelle (organigramme) de l'algorithme A1.
• L'organigramme représente graphiquement les étapes de l'algorithme, illustrant les données, les calculs, et les sorties.

Instructions composées

• Les algorithmes peuvent comporter des enchaînements d'instructions linéaires, mais aussi des sauts et des répétitions.
• Les instructions composées sont les instructions conditionnelles et les instructions itératives.

Instructions Conditionnelles

• La syntaxe des instructions conditionnelles permet de prendre des décisions en fonction d'une condition.
• Elles permettent d'exécuter des blocs d'instructions si une condition est vraie ou fausse.
• Les exemples illustrent différentes situations où des instructions conditionnelles sont utilisées.

Instructions Conditionnelles: Exemples

• Un exemple d'algorithme qui calcule la valeur absolue d'un nombre réel est fourni.

Instructions Conditionnelles: Syntaxe Détaillée

• La syntaxe de la structure globale Si...Alors...Sinon...FinSi est présentée, ainsi que comment utiliser le «Sinon»

Instructions Conditionnelles: Exemples d'utilisations

• La structure Si...Alors...Sinon...FinSi(pour les conditions) est montrée.
• Un exemple concret montre, à l'aide d'une structure conditionnelle, comment trouver la valeur absolue d'un nombre saisi.

Instructions Conditionnelles: Exercice

• Les exercices montrent comment utiliser la structure conditionnelle et comment traduire un algorithme qui calcule l'équation du premier degré en une structure conditionnelle.
• Des cas pour les variables a=0, b=0 sont définis.

La Primitive Selon

• L'instruction Selon offre une alternative claire pour gérer plusieurs cas possibles.
• Les commentaires et des exemples décrivent comment cette instruction peut simplifier la gestion de choix en fonction de valeurs de variables.
• L'exemple pratique d'un algorithme qui affiche un nombre en lettres (de 0 à 4), illustre parfaitement la puissance de la directive Selon.
• Une syntaxe détaillée est donnée, permettant aux étudiants de comprendre et d'utiliser cette instruction de manière efficace et sans ambiguïté.

Instructions répétitives (boucles)

• Les instructions répétitives permettent de réaliser la même tâche plusieurs fois.
• Il existe deux types principaux de boucles: les boucles "tant que" et les boucles "pour".

Boucles "Tant que"

• L'instruction "tant que" exécute un bloc d'instructions tant qu'une condition est vérifiée (condition est vraie).
• Le test de condition est effectué au début de la boucle.

Instructions "Tant que": Exemple

• L'exemple présente un algorithme pour calculer la somme de 1 à 100 inclusif, en utilisant une boucle "Tant que".
• Les étapes, et le déroulement schématique de la boucle sont présentés.

Instructions "Tant que": Scénario de test

• Pour l'exemple de calcul de S = 1+2+3+4+5 un scénario de test précisant les étapes et les résultats intermédiaires fournit une analyse du fonctionnement de la boucle.
• La démarche pour vérifier que l'algorithme fonctionne bien et identifier les conditions pour terminer.

Exercice: Simulation démographique

• L'exercice propose un cas pratique: calculer le nombre d'années nécessaires pour que la population des Sims Beta dépasse celle des Sims Alpha.
• L'algorithme met en œuvre une boucle "Tant que" pour suivre l'évolution des deux populations.

Instructions répétitives "Répéter...Tant que"

• L'instruction "Répéter...Tant que" exécute un bloc d'instruction tant qu'une condition n'est pas vérifiée.
• Le test de la condition est effectué à la fin de la boucle, garantissant que le bloc d'instruction soit exécuté au moins une fois.

Instructions répétitives "Répéter...Tant que": Exemple

• Un exemple d'algorithme est présenté; celui-ci calcule la somme des entiers saisis par l'utilisateur jusqu'à ce que 0 soit entré.

Instructions répétitives: Exercice inversant un entier

• L'exercice traite de l'inversion d'un entier, utilisant des opérations de modulo et de division.
• L'algorithme inversé le nombre saisi par l'utilisateur.

Instructions répétitives: Boucle Pour

• L'instruction "Pour" est une boucle où le nombre d'itérations (répétitions) est connu à l'avance.
• La syntaxe et le fonctionnement de cette boucle sont expliqués.

Instructions répétitives: Exemple avec la boucle Pour

• Un exemple concret illustre comment calculer la factorielle d'un nombre.
• Le scénario de test pour cet exemple montre son utilisation avec un tableau.

Exercice: Table de multiplication

• L'exercice illustre l'utilisation d'une boucle "Pour" pour générer la table de multiplication d'un nombre.

Résumé: Instructions itératives

• Différents types de boucles et leur utilisation sont résumés, comme la boucle pour et tant que.
• Leurs applications concrètes et les cas où elles sont utiles sont décrits.

Tableaux à une dimension

• Les tableaux à une dimension, aussi appelés vecteurs, sont des structures de données qui stockent des données de même type.
• Chaque élément est indexé, ce qui permet de l'identifier facilement.

Tableaux à deux dimensions

• Les tableaux à deux dimensions, ou matrices, sont des structures qui stocker des données organisées dans des lignes et des colonnes.
• Les éléments sont accessibles grâce à leurs indices de lignes et colonnes.

Fonctions et Procédures

• Les fonctions et procédures sont des blocs de code indépendants qui peuvent être utilisés dans différents parties d'un algorithme plus vaste.
• Les fonctions prennent des données en entrée (paramètres) et retournent un résultat.
• Les procédures ne retournent aucun résultat mais effectuent une tâche spécifique.

Fonctions: Syntaxe détaillée

• La syntaxe précise de la déclaration d'une fonction, avec ses paramètres et leur type, est expliquée.

Fonctions: Appel d'une fonction

• L'exemple de la fonction maximum décrit comment appeler une fonction avec des paramètres et comment récupérer son résultat.

Procédures : Syntaxe

• La section présente la syntaxe pour déclarer et utiliser des procédures.

Passage par valeur et par référence

• La documentation explique les différentes façons de transmettre des données (valeurs) à une fonction ou une procédure.

Portées des variables

• Les variables peuvent être locales à une fonction ou une procédure, ou globale dans l'algorithme principal.
• Leur portée détermine où et pendant combien de temps ces variables sont accessibles dans un programme.