Vous n'êtes pas identifié(e).
L'icône rouge permet de télécharger chaque page du wiki visitée au format PDF et la grise au format ODT →
Ci-dessous, les différences entre deux révisions de la page.
Les deux révisions précédentes Révision précédente Prochaine révision | Révision précédente | ||
utilisateurs:hypathie:tutos:algo-definition-et-langage [02/12/2014 07:22] Hypathie [Structure générale d'un algorithme] |
utilisateurs:hypathie:tutos:algo-definition-et-langage [13/12/2014 16:27] (Version actuelle) Hypathie [Les actions] |
||
---|---|---|---|
Ligne 18: | Ligne 18: | ||
=====Quatre sortes d'objets===== | =====Quatre sortes d'objets===== | ||
- | ===Les constantes=== | + | Il y a quatre sortes d'objets : les constantes, les variables, les fonctions et les procédures. |
+ | |||
+ | ====Les constantes==== | ||
* Syntaxe de déclaration d'une constante : | * Syntaxe de déclaration d'une constante : | ||
Ligne 31: | Ligne 33: | ||
</code> | </code> | ||
- | ===Les variables=== | + | ====Les variables==== |
Une variable est un emplacement mémoire qui change de valeur au cours d'un programme ou d'un d'un algorithme. | Une variable est un emplacement mémoire qui change de valeur au cours d'un programme ou d'un d'un algorithme. | ||
* **Syntaxe de déclaration d'une variable** | * **Syntaxe de déclaration d'une variable** | ||
- | <code c> | + | <code> |
nom_variable :type | nom_variable :type | ||
</code> | </code> | ||
Ligne 41: | Ligne 43: | ||
* Exemple : | * Exemple : | ||
- | <code c> | + | <code> |
Nbjeunes :entier // Nombre de jeunes interrogés | Nbjeunes :entier // Nombre de jeunes interrogés | ||
</code> | </code> | ||
Ligne 64: | Ligne 66: | ||
</code> | </code> | ||
+ | ====FONCTION ET PROCEDURE ==== | ||
+ | Fonction et procédure réalisent un travail, par exemple un calcul, et ne font rien d'autre que ce travail. | ||
- | ===Les Types=== | + | Elles sont utilisée par des programmes qui les appelle, et qui font d'autre chose, par exemple afficher le résultat calculé par une procédure ou une fonction. |
- | Il y a quatre types prédéfinis : entiers ; réels ; booléens ; caractères.\\ | + | |
- | Les tableaux sont des types de variables créés.\\ | + | |
- | Voir ci-dessous : [[utilisateurs:hypathie:tutos:algo-definition-et-langage#les-types1]]. | + | |
- | ===Les procédures et fonctions=== | + | |
- | * Syntaxe | + | Comparons une fonction et une procédure qui toute deux calculent le cube d'un nombre ; puis comment un programme utilise l'une ou l'autre. |
+ | |||
+ | Voir [[utilisateurs:hypathie:tutos:algo-definition-et-langage?&#structure-generale-d-un-algorithme|la structure générale d'un algorithme]] | ||
+ | |||
+ | |||
+ | ===Fonction cube === | ||
+ | * Explication : | ||
+ | On imagine un tableau où on place 2, le nombre dont calcule la puissance de 3 ;\\ | ||
+ | L'indice maximal de ce tableau est la puissance à laquelle on veut élever le nombre 2. | ||
<code> | <code> | ||
- | FONCTION <nom_fonction> ( <liste des paramètres> ) : <type de résultat> | + | Pour i de 1 à 3 on fait : |
- | < déclaration des objets locaux à la fonction> | + | | 2 | 2 | 2 | |
+ | | | | | ||
+ | 1 * 2 | | | ||
+ | = 2 | | | ||
+ | 2 * 2 | | ||
+ | = 4 | | ||
+ | 4 * 2 | ||
+ | = 8 | ||
- | DEBUT | + | </code> |
- | { corps de la fonction} | + | * Déclaration et mise en place de la fonction |
+ | <code> | ||
+ | Fonction fctcube (entrée x : entier):entier | ||
+ | //cette fonction calcul la puissance trois d'un nombre | ||
+ | // x est le nombre | ||
+ | // la fonction retourne le cube du nombre | ||
- | RETOURNER(résultat) | + | CONSTANTES |
- | FIN | + | constante puissance = 3 |
+ | |||
+ | VARIABLES | ||
+ | |||
+ | variable i : entier //comptage des puissances | ||
+ | variable y : entier // calcul intermédiaire | ||
+ | |||
+ | |||
+ | début | ||
+ | |||
+ | i := 1 | ||
+ | y := 1 | ||
+ | |||
+ | Tantque (i := puissance) FAIRE | ||
+ | |||
+ | y := y * x | ||
+ | i := i + 1 | ||
+ | FinTantque | ||
+ | |||
+ | retourner (y) | ||
+ | Fin | ||
+ | fin | ||
</code> | </code> | ||
- | ===FONCTION perimetre_rectangle (largeur, longueur : ENTIER) : ENTIER=== | + | ===Utilisation de la fonction dans un programme=== |
<code> | <code> | ||
- | DEBUT | + | //Programme cube |
+ | // Programme qui calcule le cube d'un nombre et affiche le résultat | ||
- | RETOURNER (2*(largeur+longueur)) | + | VARIABLES |
- | FIN | + | nombre : entier // nombre à élever au cube |
- | Syntaxe : SYNTAXE D'UNE PROCEDURE | + | |
- | PROCEDURE <nom_procedure>( <liste des paramètres> ) | + | FONCTIONS |
- | < déclaration des objets locaux de la procedure> | + | fonction fctcube (entrée x : entier):entier |
- | DEBUT | + | // cette procédure calcule le cube du nombre x et retourne le résultat |
- | {corps de la procedure} | + | Début |
+ | |||
+ | lire(nombre) | ||
+ | écrire ('le résultat est : ', fctcube(nombre)) // Appel de la fonction, elle rend la résultat qu'on affiche avec écrire | ||
+ | |||
+ | // utilisation du résultat | ||
+ | Fin | ||
+ | </code> | ||
- | FIN | + | ==== Procédure cube==== |
+ | La différence avec un programme est l'en-tête. | ||
+ | |||
+ | <code> | ||
+ | |||
+ | procédure proccube (entrée x : entier, sortie y : entier) | ||
+ | |||
+ | // Cette procédure calcule la puissance trois d'un nombre. | ||
+ | |||
+ | CONSTANTES | ||
+ | |||
+ | constante puissance = 3 | ||
+ | |||
+ | VARIABLES | ||
+ | |||
+ | variable i :entier // comptage des puissances | ||
+ | |||
+ | Début | ||
+ | |||
+ | i := 1 | ||
+ | j := 1 | ||
+ | |||
+ | Tantque (i := puissance) FAIRE | ||
+ | |||
+ | y := y * x | ||
+ | i := i + 1 | ||
+ | FinTanque | ||
+ | |||
+ | Fin | ||
</code> | </code> | ||
- | suite : [[http://www.est-usmba.ac.ma/ALGORITHME/co/module_ALGORITHME_40.html]] | + | ===Utilisation de procédure dans un programme === |
+ | <note tip> | ||
+ | La procédure fait le calcul du cube, le programme se moque de savoir comment,\\ il a pour travail de calculer le cube au moyen d'une procédure et d'afficher le résultat fait par la procédure. | ||
+ | </note> | ||
- | Voir aussi : [[utilisateurs:hypathie:tutos:algo-exo-constructions-d-algorithmes-de-procedure]] | ||
+ | <code> | ||
+ | // Programme qui calcule le cube d'un nombre | ||
+ | |||
+ | VARIABLES | ||
+ | variable nombre :entier //nombre à élever au cube | ||
+ | variable resultat :entier // cube du nombre | ||
+ | |||
+ | PROCEDURES | ||
+ | |||
+ | procédure proccube (entrée x : entier , sortie y : entier) | ||
+ | //Cette procédure calcule le cube du nombre x et met le résultat dans y | ||
+ | |||
+ | Début | ||
+ | lire(nombre) | ||
+ | |||
+ | proccube (nombre, resultat) // calcul du cube de nombre | ||
+ | |||
+ | écrire('Le résultat est : ', résultat) | ||
+ | // affichage du résultat du calcul | ||
+ | | ||
+ | Fin | ||
+ | |||
+ | |||
+ | </code> | ||
+ | |||
+ | |||
+ | |||
+ | Voir ci-dessous la structure en sous programme d'un algorithme complexe: [[utilisateurs:hypathie:tutos:algo-exo-constructions-d-algorithmes-de-procedure]] | ||
+ | |||
+ | Voir aussi : d'autres exemples simples d'algorithme de fonctions et de procédures : [[http://www.est-usmba.ac.ma/ALGORITHME/co/module_ALGORITHME_40.html]] | ||
+ | |||
+ | =====Les Types===== | ||
+ | Il y a quatre types prédéfinis : entiers ; réels ; booléens ; caractères.\\ | ||
+ | Les tableaux sont des types de variables créés.\\ | ||
- | ===== Les Types ===== | ||
- | Trois types pré-défini ; les tableaux sont des types créés. | ||
====Les entiers ==== | ====Les entiers ==== | ||
Ligne 241: | Ligne 352: | ||
<note tip> | <note tip> | ||
- | Le **ET** et le **OU** algorithmiques ne sont pas le ET et le OU de la logique de bool. | + | **Le ET et le OU algorithmiques ne sont pas le ET et le OU de la logique de bool.** |
- | En algo, on comprends **ET** comme un **ET-alors** et le **OU** comme **OU-sinon**. | + | * __En algo, on comprends **ET** comme un **ET-alors**__ : |
^ a ^ b ^ condition a ET b ^ | ^ a ^ b ^ condition a ET b ^ | ||
| FAUX| (non évalué)| FAUSSE (pas d'exécution du code) | | | FAUX| (non évalué)| FAUSSE (pas d'exécution du code) | | ||
- | | VRAI | alors b évalué | expression = b qui doit être calculable | | + | | VRAI | alors b évalué\\ b = VRAI\\ b = FAUX | expression = b qui doit être calculable\\ a ET B = VRAI (condition exécutée)\\ a ET b = FAUX (condition non exécutée)| |
+ | |||
+ | => Pour résumer, on tient compte de **b** seulement si a est vrai,\\ et la condition est exécutée si **a et b** sont vrais. | ||
+ | |||
+ | * __On comprends le **OU** comme **OU-sinon**__ : | ||
^ a ^ b ^ condition a OU b ^ | ^ a ^ b ^ condition a OU b ^ | ||
| VRAI| (non évalué)| VRAI | | | VRAI| (non évalué)| VRAI | | ||
- | | FAUX | (sinon) b évalué | expression = b qui doit être calculable | | + | | FAUX | (sinon) b évalué\\ b = FAUX\\ b = VRAI | expression = b qui doit être calculable\\ a OU b = FAUX (condition non exécutée)\\ a OU b = VRAI (condition exécutée) | |
+ | |||
+ | => Pour résumer, **b** est pris en compte seulement si a est FAUX,\\ et la condition est exécutée si **b** est vrai. | ||
</note> | </note> | ||
Ligne 469: | Ligne 586: | ||
variable i : entier | variable i : entier | ||
i := 1 | i := 1 | ||
- | TantQue ( i < 3 ) FAIRE // La boucle s'arrêtera quand i sera > à 3. | + | TantQue ( i < 3 ) FAIRE // La boucle s'arrêtera quand i sera >= à 3. |
// On met dans le commentaire la condition contraire | // On met dans le commentaire la condition contraire | ||
// c'est-à-dire la condition de terminaison. | // c'est-à-dire la condition de terminaison. | ||
Ligne 504: | Ligne 621: | ||
<code> | <code> | ||
variable i : entier | variable i : entier | ||
- | i := 5 | + | i := 1 |
Répéter | Répéter | ||
i := i + 1 | i := i + 1 | ||
écrire('coucou') | écrire('coucou') | ||
- | Jusqu'à ( i >= 3 ) // C'est une condition d'arrêt. | + | Jusqu'à ( i >= 3 ) // être égal à 3 est une condition d'arrêt. |
écrire('la variable i est égale à ', i) | écrire('la variable i est égale à ', i) | ||
</code> | </code> | ||
<code> | <code> | ||
coucou | coucou | ||
- | la variable i est égale à 6 | + | coucou |
+ | la variable i est égale à 3 | ||
</code> | </code> | ||
> ATTENTION la boucle s'effectue toujours une fois | > ATTENTION la boucle s'effectue toujours une fois | ||
- | <note> | + | <note tip> |
- | Si on avait mis i := 1 avant l'exécution du répéter, le retour serait : | + | Dans le schéma "Tant que" la condition de poursuite est avant le traitement, dans le schéma "Répéter", la condition de poursuite est après.\\ |
+ | |||
+ | La boucle répéter est donc exécutée au moins une fois.\\ | ||
+ | |||
+ | Avec une boucle répéter, on exécute l'instruction " tant que la condition est fausse. " | ||
<code> | <code> | ||
- | coucou | + | répéter |
- | coucou | + | Afficher "Saisir un nombre strictement positif " |
- | la variable i est égale à 3 | + | Saisir i |
+ | Si i (<= 0) alors | ||
+ | écrire("J'ai dit STRICTEMENT POSITIF !") | ||
+ | Sinon | ||
+ | écrire("Bravo") | ||
+ | Finsi | ||
+ | jusqu'à i > 0 | ||
</code> | </code> | ||
+ | |||
+ | => Si on entre -2 : on aura "J'ai dit STRICTEMENT POSITIF !" | ||
</note> | </note> | ||
Ligne 533: | Ligne 664: | ||
La solution consiste alors à découper l'algorithme en plusieurs parties plus petites. Ces parties sont appelées des sous-algorithmes. | La solution consiste alors à découper l'algorithme en plusieurs parties plus petites. Ces parties sont appelées des sous-algorithmes. | ||
- | Il ressemble à cela : | + | Voici le schéma de l'algorithme d'un programme complexe, l'algorithme principal (P0) appelle les algorithmes de sous-programmes (P1, P2, P3), qui eux-mêmes en appellent d'autres ... : |
<code> | <code> | ||
Ligne 560: | Ligne 691: | ||
====Structure d'un bloc ==== | ====Structure d'un bloc ==== | ||
+ | Quelque soit le niveau où l'on se trouve dans l'arborescence, tous les blocs, y compris l'algorithme du programme principal, se déclare comme ceci : | ||
+ | |||
<code> | <code> | ||
Interface de bloc // nom du programme, de la procédure ou de la fonction. | Interface de bloc // nom du programme, de la procédure ou de la fonction. | ||
Ligne 625: | Ligne 758: | ||
</code> | </code> | ||
- | ====Exemple de rapport hiérarchique entre une procédure et un algorithme ==== | + | ====Exemple simple d'un algorithme appelant un sous-algorithme ==== |
//Donnez l'algorithme qui affiche un carré d'étoile à l'écran.// | //Donnez l'algorithme qui affiche un carré d'étoile à l'écran.// | ||
Ligne 643: | Ligne 776: | ||
// ligne de 15 étoiles. | // ligne de 15 étoiles. | ||
DébutAlgo | DébutAlgo | ||
- | Pour i DE 1 à 15 FAIRE | + | Pour j DE 1 à 15 FAIRE |
- | // appel de la procédure --------------->| //Procédure Etoile | + | // appel de la procédure --------------->| Etoile(entrée i : entier , sortie i :entier) |
Etoile( ) | // Procédure qui affiche une ligne d'étoile | Etoile( ) | // Procédure qui affiche une ligne d'étoile | ||
| // Et qui va à la ligneFinProc | | // Et qui va à la ligneFinProc | ||
- | FinPour | | + | FinPour | |
- | FinAlgo | Variables i :entier | + | FinAlgo | |
- | | | + | | Variables i :entier |
| DébutProc | | DébutProc | ||
| Pour i DE 1 à 15 | | Pour i DE 1 à 15 | ||
Ligne 685: | Ligne 818: | ||
</code> | </code> | ||
- | =====FONCTION ET PROCEDURE ===== | ||
- | Fonction et procédure réalisent un travail, par exemple un calcul, et ne font rien d'autre que ce travail. | ||
- | Elles sont utilisée par des programmes qui les appelle, et qui font d'autre chose, par exemple afficher le résultat calculé par une procédure ou une fonction. | ||
- | |||
- | Comparons une fonction et une procédure qui toute deux calculent le cube d'un nombre ; puis comment un programme utilise l'une ou l'autre. | ||
- | |||
- | ====Fonction cube ==== | ||
- | |||
- | * Déclaration et mise en place de la fonction | ||
- | <code bash> | ||
- | Fonction fctcube (entrée x : entier):entier | ||
- | //cette fonction calcul la puissance trois d'un nombre | ||
- | // x est le nombre | ||
- | // la fonction retourne le cube du nombre | ||
- | |||
- | CONSTANTES | ||
- | |||
- | constante puissance = 3 | ||
- | |||
- | VARIABLES | ||
- | |||
- | variable i : entier //comptage des puissances | ||
- | variable y : entier // calcul intermédiaire | ||
- | |||
- | |||
- | début | ||
- | |||
- | i := 1 | ||
- | y := 1 | ||
- | | ||
- | Tantque i <= puissance FAIRE | ||
- | | ||
- | y := y * x | ||
- | i := i + 1 | ||
- | FinTantque | ||
- | | ||
- | retourner (y) | ||
- | Fin | ||
- | fin | ||
- | </code> | ||
- | |||
- | ===Utilisation de la fonction dans un programme=== | ||
- | |||
- | <code bash> | ||
- | //Programme cube | ||
- | // Programme qui calcule le cube d'un nombre et affiche le résultat | ||
- | |||
- | VARIABLES | ||
- | |||
- | nombre : entier // nombre à élever au cube | ||
- | |||
- | FONCTIONS | ||
- | |||
- | fonction fctcube (entrée x : entier):entier | ||
- | |||
- | // cette procédure calcule le cube du nombre x et retourne le résultat | ||
- | |||
- | Début | ||
- | | ||
- | lire(nombre) | ||
- | écrire ('le résultat est : ', fctcube(nombre)) | ||
- | |||
- | // utilisation du résultat | ||
- | Fin | ||
- | </code> | ||
- | |||
- | ==== Procédure cube==== | ||
- | La différence avec un programme est l'en-tête. | ||
- | |||
- | <code bash> | ||
- | |||
- | procédure proccube (entrée x : entier, sortie y : entier) | ||
- | |||
- | // Cette procédure calcule la puissance trois d'un nombre. | ||
- | | ||
- | CONSTANTES | ||
- | |||
- | constante puissance = 3 | ||
- | |||
- | VARIABLES | ||
- | |||
- | variable i :entier // comptage des puissances | ||
- | |||
- | Début | ||
- | |||
- | i := 1 | ||
- | j := 1 | ||
- | |||
- | Tantque i <= puissance FAIRE | ||
- | |||
- | y := y * x | ||
- | i := i + 1 | ||
- | FinTanque | ||
- | | ||
- | Fin | ||
- | </code> | ||
- | |||
- | ===Utilisation de procédure dans un programme === | ||
- | <note tip> | ||
- | La procédure fait le calcul du cube, le programme se moque de savoir comment,\\ il a pour travail de calculer le cube au moyen d'une procédure et d'afficher le résultat fait par la procédure. | ||
- | </note> | ||
- | |||
- | |||
- | <code bash> | ||
- | // Programme qui calcule le cube d'un nombre | ||
- | |||
- | VARIABLES | ||
- | variable nombre :entier //nombre à élever au cube | ||
- | variable resultat :entier // cube du nombre | ||
- | |||
- | PROCEDURES | ||
- | |||
- | procédure proccube (entrée x : entier , sortie y : entier) | ||
- | //Cette procédure calcule le cube du nombre x et met le résultat dans y | ||
- | |||
- | Début | ||
- | lire(nombre) | ||
- | |||
- | proccube (nombre, resultat) // calcul du cube de nombre | ||
- | |||
- | écrire('Le résultat est : ', résultat) | ||
- | // affichage du résultat du calcul | ||
- | | ||
- | Fin | ||
- | |||
- | |||
- | </code> | ||
- | |||
- | |