L'icône rouge permet de télécharger chaque page du wiki visitée au format PDF et la grise au format ODT →

Différences

Ci-dessous, les différences entre deux révisions de la page.

--- utilisateurs:hypathie:tutos:algo-definition-et-langage [30/11/2014 23:39]
Hypathie [Quatre sortes d'objets]
+++ 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=====
-===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 :
@@ Ligne 31: / Ligne 33: @@
 </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.
   * **Syntaxe de déclaration d'une variable**
-<code c>
+<code>
 nom_variable :type
 </code>
@@ Ligne 41: / Ligne 43: @@
   * Exemple :
-<code c>
+<code>
 Nbjeunes :entier // Nombre de jeunes interrogés
 </code>
@@ Ligne 64: / Ligne 66: @@
 </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>
-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   |
+       |       |        |
+* 2      |        |
+    = 2        |        |
+* 2      |
+             = 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>
-===FONCTION perimetre_rectangle (largeur, longueur : ENTIER) : ENTIER===
+===Utilisation de la fonction dans un programme===
 <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>
-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 ====
@@ Ligne 241: / Ligne 352: @@
 <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 ^
 | 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 ^
 | 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>
@@ Ligne 469: / Ligne 586: @@
 variable i : entier
 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
                             // c'est-à-dire la condition de terminaison.
@@ Ligne 504: / Ligne 621: @@
 <code>
 variable i : entier
-i := 5
+i := 1
   Répéter
         i := i + 1
         é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)
 </code>
 <code>
 coucou
-la variable i est égale à 6
+coucou
+la variable i est égale à 3
 </code>
 > 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>
-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>
+=> Si on entre -2 : on aura "J'ai dit STRICTEMENT POSITIF !"
 </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.
-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>
@@ Ligne 551: / Ligne 682: @@
 Les différentes parties d'un algorithme (sous-algorithmes) sont appelées des blocs.
-Il existe deux sortes de sous-algorithmes : les procédures et les fonctions.
+Il existe deux sortes de **sous-algorithmes** : **les procédures et les fonctions**.
 <note tip>
@@ Ligne 560: / Ligne 691: @@
 ====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>
 Interface de bloc // nom du programme, de la procédure ou de la fonction.
@@ Ligne 570: / Ligne 703: @@
 VARIABLES // Définitions des variables
-procédures ... // Définitions des sous-procédures appelées par le bloc, ce bloc
+PROCEDURES ... // Définitions des sous-procédures appelées par le bloc, ce bloc
                // est alors un algorithme plus globale
-fonctions ... // Définitions des fonctions appelées par le bloc
+FONCTIONS ... // Définitions des fonctions appelées par le bloc
@@ Ligne 625: / Ligne 758: @@
 </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.//
@@ Ligne 643: / Ligne 776: @@
                      // ligne de 15 étoiles.
  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
                                                        |  // Et qui va à la ligneFinProc
        FinPour                                         |
- FinAlgo                                               | Variables i :entier
+ FinAlgo                                               |
-                                                       |
+                                                       | Variables i :entier
                                                        |   DébutProc
                                                        |       Pour i DE 1 à 15
@@ Ligne 662: / Ligne 795: @@
 Lors de problème plus complexes, on le divise en procédures et l'on cherche un algorithme\\ pour chaque procédure.
 </note>
+=====Les entrée sortie et entrée sortie =====
+<code>
+                +
+ entrée     |       | sortie
+variables   |       | c = 3
+a = 1
+b = 2
+</code>
+<code>
+               entrée sortie
+          |                       |
+          | modifier une variable |
+          |  qui est donnée       |
+          | en entrée et qui sort |
+          | avec une autre valeur |
+</code>

utilisateurs/hypathie/tutos/algo-definition-et-langage.1417387157.txt.gz · Dernière modification: 30/11/2014 23:39 par Hypathie

Debian-facile

Différences

Pied de page des forums