Partager
Affiche les résultats de 1 à 8 sur 8

Sujet : Algorithmique , Raisonner pour concevoir

  1. #1
    Inscrit
    juin 2012
    Lieu
    Not Available
    Messages
    537
    Remerciements
    15
    Remercié(e) 188 fois dans 140 messages
    Pouvoir de réputation
    8

    Lightbulb Algorithmique , Raisonner pour concevoir

    Bienvenue a tous et a toutes (quoi que pour "toutes" on n'on voient pas beaucoup ) pour ce cours complet autour du monde de l’algorithmique.

    Qu’est ce que l’algorithmique ?
    On s’intéresse à l’activité de programmation d’un ordinateur qui permet de résoudre des problèmes d’une façon automatique. On se place à un niveau conceptuel dans lequel un problème quelconque, informatique ou non, est caractérisé par un ensemble de données d’entrée et des résultats attendus.

    Exemple :
    On donne les ingrédients suivants :
    - Thym laurier
    - persil
    - ail
    - huile
    - vinaigre
    - sel
    - poivre
    - citron
    - et un brochet de trois livres. Préparer une marinade de brochet.
    Dans cet exemple, le problème est représenté par les données : le thym, le laurier, ..., le brochet dont on connaît le poids et par le résultat attendu qui est un plat cuisiné : une marinade de brochet. Ce n’est pas (pas encore) un problème qui se pose habituellement en informatique, mais il se pose dans les mêmes termes.(sinon bein mon PC santerai l3ossbane)

    Aller un autre exemple : (car s'est toujours bon)
    On demande de calculer, pour une année dont on donne le millésime, le jour de la semaine où tombe le premier mai.
    Ici, les données sont constituées d’un millésime, comme 2012 par exemple(car a la fin de celle ci on sera mort... d’après mon oncle qui était Maya , mais un Maya Générale ). Le résultat attendu est un jour de la semaine, comme dimanche par exemple.
    Dans ces exemples, le problème est constitué d’un jeu de données. Le résultat attendu doit être obtenu par des transformations à faire subir aux données .
    Les problèmes auxquels on s’intéresse dans ce livre sont résolus à l’aide d’un ordinateur. Un ordinateur est constitué d’une machine matérielle complétée d’un ensemble de composants périphériques, comme un clavier, une souris, une table traçante... La machine matérielle est constituée, en première approximation, d’une unité centrale, chargée d’effectuer les calculs, complétée d’une mémoire, permettant d’enregistrer les données, les résultats des calculs intermédiaires et les résultats attendus. Pour résoudre un problème avec l’aide d’un ordinateur, il faut enregistrer dans sa mémoire, d’une part les données du problème, qu’il devra transformer pour obtenir le résultat attendu et, d’autre part, la suite des instructions que l’unité centrale du calculateur devra exécuter pour effectuer les transformations des données. Le résultat étant obtenu, il sera d’abord enregistré, comme les données, dans la mémoire.

    Un périphérique d’entrée permet de communiquer au programme les données à transformer. Un programme, constitué d’instructions en langage machine exécutées par l’unité centrale, les transforme et produit des résultats qui sont envoyés au périphérique de sortie.

    Un premier élément, remarquable ici, est l’architecture mise en oeuvre. Les instructions machine exécutées par l’unité centrale et les données sur lesquelles elles agissent sont rangées et cohabitent dans la même mémoire centrale. Une telle architecture est celle des ordinateurs depuis leur tout début, dans la première moitié du vingtième siècle. Elle a été inventée et théorisée par John VON NEUMANN et Alan THÜRING. Dans cette architecture, l’unité centrale n’exécute qu’une seule instruction à la fois et ces instructions sont exécutées séquentiellement, l’une après l’autre, dans un ordre préétabli et définitivement fixé. On dit qu’il s’agit d’une machine séquentielle pour caractériser un tel comportement. Il existe d’autres types de machines qui je ne vais pas expliqué pour des raisons ......euhh sentimentale (....???!!).

    Une deuxième propriété importante de telles machines est que les mêmes données, communiquées au même programme, produisent les mêmes résultats, indépendamment de l’environnement et du moment de l’exécution des instructions. On dit alors que ce type de machine est déterministe. Là encore, ce n’est pas la seule architecture matérielle possible, mais même chose les autres ne seront pas cités pour des raisons tactique (c'est tous ce que j'ai trouvé comme excuse).

    Pour obtenir un programme et les instructions qui le composent, on le prépare en utilisant un langage de programmation à l’aide duquel on écrit les instructions qui transforment les données. Il existe de nombreux langages de programmation de haut niveau, certains dédiés à des tâches spécifiques, comme les tableurs par exemple, d’autres destinés à écrire des programmes plus généraux, comme JAVA, PHP, C... .

    Pour passer des données d’un problème aux résultats attendus, on considère une machine fictive caractérisée par un comportement qui lui permet de réaliser les opérations. Cette machine fictive, comme son modèle, l’ordinateur de VON NEUMANN (on a pas idée de s’appelé ainsi), n’effectue qu’une seule opération à la fois pour réaliser un traitement précisément défini. Les opérations s’organisent en une suite ordonnées d’instructions qui opèrent sur de l’information symbolique, c’est à dire sur une suite de signes alphabétiques, numériques, lexicaux. Cette machine fictive est donc une machine séquentielle, comme son modèle. On appelle calcul une suite de traitements réalisés par cette machine, machine abstraite le calculateur fictif et programme abstrait la suite d’instructions préparées pour une telle machine. Cependant, alors que les programmes écrits dans un langage de programmation et destinés à un calculateur concret doivent respecter une syntaxe précise et rigide, les programmes abstraits ne sont contraints par aucune règle de " grammaire ", aucune syntaxe imposée. En ce sens, un programme abstrait n’est pas un programme et n’utilise pas un langage différent du langage naturel. On appelle algorithme un programme écrit pour la machine abstraite.

    Tout ordinateur et son langage sont donc la réalisation particulière d’une machine abstraite. Cependant, alors que le programme concret, destiné à un calculateur concret, appartient à l’espace de la solution du problème que nous voulons résoudre, la machine abstraite et son langage, l’algorithme, appartiennent à l’espace du problème à résoudre.
    L’algorithme est le " langage " de la machine fictive. On y reconnaît deux domaines indépendants et bien distincts :
    - la spécification du problème qui le définit entièrement et d’une façon non ambiguë. C’est le domaine des Mathématiques et de la logique.
    -Les instructions de la machine fictive est un domaine qui assure la transition vers les instructions en langage de haut niveau destinées à la machine effective.

    Dans l’espace de la solution, le langage de haut niveau et le langage machine réalisent les instructions de la machine effective. Pour être plus précis, il faudrait considérer que le langage de haut niveau introduit une machine fictive intermédiaire, mais cela ne sera pas fait ici pour simplifier.

    Exemple 1 :
    Dans un vieux livre de cuisine, je lis la recette suivante, en page 41(ééh mais c'est vrai hein) :

    " MARINADE
    Thym laurier , persil ,ail ,huile, vinaigre, sel, poivre.
    Mettez dans un plat 2 volumes d’huile, pour 1 de vinaigre, le thym, laurier, persil, l’ail haché finement, salez, poivrez et faites baigner dans cette préparation la viande que vous voulez faire mariner. Vous pouvez laisser mariner 2 à 6 jours, mais chaque jour ajouter de l’huile et du vinaigre. Pour le poisson, vous pouvez remplacer le vinaigre par du jus de citron. "
    Cette recette décrit un algorithme : comment réaliser une marinade ? À partir d’ingrédients précisés, il décrit une succession d’opérations qui les utilisent pour obtenir un résultat. Il pourrait énumérer les différentes opérations en les ordonnant :

    1. mélanger dans un plat 2 volumes d’huile à 1 volume de vinaigre ; pour du poisson, remplacer le vinaigre par du jus de citron ;
    2. hacher finement l’ail ;
    3. ajouter à la vinaigrette le thym, le laurier, le persil et l’ail haché ;
    4. saler et poivrer ;
    5. placer la viande à faire mariner dans cette préparation ;
    6. pendant 2 à 6 jours, ajouter chaque jour de l’huile et du vinaigre.

    PS :
    Les gens disent que j'ai beaucoup de talent , fin quand je dis les gens je parle de mon chat

    Exemple 2 :
    Tout élève apprend à additionner deux nombres entiers positifs en classe primaire. Pour calculer la somme de 127 et 35, il apprend à " poser " l’addition, en plaçant en colonnes les chiffres des deux nombres, les unités du second sous les unités du premier, les dizaines du second sous les dizaines du premier, etc. Ceci fait, il utilise un répertoire de connaissances acquises préalablement, pour additionner les deux nombres chiffre à chiffre. Il doit donc savoir que 7+5 font 12, 2+3 font 5, etc. Il apprend aussi à reporter la retenue lorsque l’addition de deux chiffres donne une somme supérieure à 9. Il est aussi possible de détailler les étapes du calcul de la façon suivante :

    1. poser 127 ;
    2. poser 35 sous 127, avec 5 sous 7, 3 sous 2 ;
    3. additionner 7 et 5 qui font 12 : poser 2 pour les unités du résultat et 1 de retenue pour les dizaines ;
    4. additionner 2 et 3 qui font 5 pour les dizaines et augmenter le résultat de la retenue précédente : poser 6 ;
    5. additionner les centaines 1 à 0 : poser 1 ;
    6. le résultat est 162.

    Cette description est comparable à la recette précédente. On considère les ingrédients que sont les nombres à additionner, 127 et 35. À partir des tables d’addition, dont la connaissance est un préalable, on applique un ensemble de règles qui transforme les données, pour obtenir un résultat, ici leur somme 162.(des chiffres et des ingrédients , ça rappel un jeu ça , en tous les cas un qu'il faut inventé )
    Dernière édition par TeamWorK; 25/07/2012 à 01h39
    Not Available

  2. [Les 2 membres suivants remercient TeamWorK pour cet excellent message :


  3. # ADS
    Inscrit
    Toujours
    Lieu
    Monde des annonces
    Messages
    Plusieurs






     
  4. #2
    Inscrit
    juin 2012
    Lieu
    Not Available
    Messages
    537
    Remerciements
    15
    Remercié(e) 188 fois dans 140 messages
    Pouvoir de réputation
    8

    Arrow Re: Algorithmique , Raisonner pour concevoir

    Exemple 3 : (pour les gestionnaires de stock)
    Le service du magasin d’une entreprise souhaite calculer automatiquement des propositions de réapprovisionnement pour les articles allant bientôt manquer. Pour cela, on dispose pour chaque article des informations suivantes :

    - la quantité actuelle en stock ;
    - le délai moyen de réapprovisionnement ;
    - des statistiques de vente sur les 12 derniers mois.

    On demande de décrire les calculs à effectuer pour déterminer dans quels cas le réapprovisionnement d’un produit doit être proposé.

    On appelle niveau de déclenchement la quantité d’un produit en deçà de laquelle le réapprovisionnement doit être proposé. C’est cette quantité qu’il s’agit de calculer à partir des données énumérées précédemment. Soient alors qs la quantité de produit actuellement en stock, v1, v2, ..., v12 les ventes réalisées sur ce produit lors des 12 derniers mois, dr le délai moyen de réapprovisionnement et qd le niveau de déclenchement à calculer. Ce calcul s’organise selon les étapes suivantes :

    1. récupérer les données qs, dr et v1, v2, ..., v12 ;
    2. calculer la moyenne arithmétique mv des ventes quotidiennes de ce produit ;
    3. calculer le niveau de déclenchement qd ;
    4. comparer qs à qd :
    - qs qd => proposer de réapprovisionner ;
    - qs > qd => ne rien faire.

    Les étapes précédentes décrivent le procédé de calcul de qd. Elles constituent un algorithme pour le calcul du niveau de déclenchement du réapprovisionnement. À partir des données du problème, ici qs, dr et v1, v2, ..., v12, des règles opératoires permettent d’obtenir un résultat défini. Mais pour accéder à ce résultat, il faut passer par un ensemble d’étapes intermédiaires : récupérer les données, calculer une moyenne... de la même façon qu’il fallait préparer d’abord une crème Chantilly pour réaliser un SaintHonoré.

    Ces étapes intermédiaires ne sont pas décrites : on ne dit pas comment calculer une moyenne, comment calculer le niveau de déclenchement qd à l’aide de cette moyenne, comment préparer une crème Chantilly... Ces calculs intermédiaires, indispensables à l’obtention du résultat, ne sont pas
    explicités. L’apprenti cuisinier sait préparer une crème Chantilly, car c’est un préalable à la réalisation d’un SaintHonoré ; alors, il dispose de tous les éléments pour réaliser la recette complète.

    L’informaticien, ou le chef magasinier, sait calculer la moyenne nécessaire et qd pour déterminer quand réapprovisionner. Dans le cas contraire, il faudra étudier l’algorithme de calcul de la moyenne.

    Le cuisinier se reportera à la page 267 du livre de cuisine qui donne la recette qu’il ne sait pas encore préparer. Dans tous les cas, le problème est résolu grâce à un sousalgorithme qui est
    une solution à un sous problème du problème initial.

    Exercice :
    Voila un peu d'exercice ne fais pas de mal (expression qui marche dans tous les cas)

    * Énumérer les étapes élémentaires ordonnées pour réaliser les tâches quotidiennes suivantes :
    1. préparer du café ;
    2. prendre l'ETUSA.
    Spécifications :
    Une tâche importante, quand on cherche à écrire un algorithme, consiste à le spécifier. Il s’agit de dire, de la façon la plus précise possible, ce que fait l’algorithme et, cela, sans exprimer comment il le fait.

    En ce sens, spécifier un algorithme, c’est poser formellement le problème qu’il résout, comme l’a montré le chapitre précédent. C’est une étape difficile, mais indispensable pour clairement définir l’algorithme et ses effets. Cette section introduit, par quelques exemples et exercices résolus, cette étape de spécification. Elle est complétée dans la suite du livre, à mesure que nous construirons les outils nécessaires.

    Exercice 1 : "Feux de circulation"
    On considère un feu qui règle la circulation à un carrefour.
    * Écrire l’algorithme qui détermine la couleur du feu lors du prochain changement.
    Solution :
    Un tel feu signale l’état de la circulation qu’il règle par trois couleurs : vert, orange et rouge. Les couleurs s’enchaînent dans cet ordre à une cadence fixée. Lorsque la couleur est rouge, le changement refait passer le feu au vert. On ne s’intéresse qu’au changement de couleur, autrement dit, à l’opération qui fait passer de l’une à l’autre, dans l’ordre précisé.

    Supposons que nous disposons d’une opération, désignée par "successeur", qui prend en entrée une couleur de l’ensemble C = {rouge ; vert ; orange} et qui retourne son successeur dans la suite ordonnée (vert ; orange ; rouge). (probabilités simple rappelez vous)

    Avec ces hypothèses, l’algorithme s’écrit :

    Algorithme 1 : Changement de la couleur d’un feu à un carrefour : version 0.1
    Code:
    algorithme : changer la couleur
    Entrée
              c : une COULEUR de l’ensemble {vert ; orange ; rouge}
    Effet
              c = successeur de ancienne valeur de c
    Analyse :
    Cette notation précise le nom de l’algorithme : changer la couleur. Elle indique aussi que cet algorithme utilise une donnée, dont le type est COULEUR et désignée par la lettre c, pour réaliser son calcul. C’est l’objet du paragraphe qui débute avec le mot Entrée que de donner cette précision. Le domaine des valeurs de c est clairement précisé : c’est l’ensemble {vert ; orange ; rouge}. Ce qui précède détaille les prérequis pour le fonctionnement de l’algorithme.

    Lorsque l’algorithme se termine et produit les résultats de son travail, on obtient un nouvel état du feu de circulation. Ce nouvel état est entièrement décrit, au moins pour cet exercice simplifié, par la couleur du feu ; c’est ce que dit le paragraphe Effet. On y lit que la nouvelle valeur de c, c’est à dire la nouvelle couleur du feu, est la valeur qui succède à l’ancienne valeur de cette couleur. La construction ancienne valeur de c est mise pour indiquer que la valeur de c avant modification par l’algorithme est utilisée. On voit donc que deux valeurs distinctes de c sont concernées : celle avant l’exécution de l’algorithme, représentée par la construction ancienne valeur de c, et la nouvelle valeur, celle calculée par l’algorithme, désignée par c. Il convient de noter que l’ancienne valeur de c disparaît lorsque l’algorithme se termine. Ainsi, cette valeur est modifiée par l’algorithme. C’est la responsabilité de changer la couleur de modifier cette valeur. Comme la valeur de c capture l’état du système logiciel, la modification de cette valeur modifie cet état.

    Pour spécifier l’effet de l’algorithme, on utilise la construction c = successeur de ancienne valeur de c. Il faut encore dire ce que fait successeur, autrement dit, le résultat que produit cet opérateur. Ce sera fait plus bas. Pour l’instant, restons en à l’idée intuitive sousjacente.

    Cette façon d’écrire l’algorithme n’est pas obligatoire. Ainsi, par exemple, on aurait pu utiliser d’autres notations pour exprimer la même idée. En voici une autre :

    Algorithme 2 : Changement de la couleur d’un feu à un carrefour : version 0.2
    Code:
    changer la couleur
    Donnée
         c : une COULEUR de l’ensemble {vert ; orange ; rouge}
    Effet
         (ancien c = vert => c = orange)
          ou sinon
        (ancien c = orange => c = rouge)
         ou sinon
        (ancien c = rouge => c = vert)
    Analyse :
    Les expressions utilisées expriment la même condition que précédemment : la couleur orange succède au vert, rouge succède à orange et vert succède à rouge. Accessoirement, il n’est plus indiqué sur la première ligne qu’il s’agit d’un algorithme : c’est évident. Entrée a été remplacé par Donnée. Toute autre méthode pour préciser les données sur lesquelles travaille l’algorithme aurait été légitime.

    Quelle est la différence entre les deux description ?
    La différence essentielle qui distingue cette description de la précédente est la façon dont elle exprime l’effet de l’algorithme. Au lieu de faire appel à un sous algorithme successeur qu’il faudra plus tard définir, ici l’algorithme précise, pour chacune des valeurs possibles de la donnée d’entrée, la valeur que prendra c en sortie. C’est une expression qui est une disjonction de clauses booléennes. La notation :

    Code:
    ancien c = vert => c = orange
    exprime que, lorsque la valeur de c en entrée est vert, elle est orange en sortie. Autrement dit, le calcul de l’algorithme consiste à remplacer la couleur vert par la couleur orange. Le symbole "=>" est le symbole de l’implication en Mathématique.

    A Venir : Amélioration de notre algorithme
    Dernière édition par TeamWorK; 19/07/2012 à 02h02
    Not Available

  5. [Les 2 membres suivants remercient TeamWorK pour cet excellent message :


  6. #3
    Inscrit
    juin 2012
    Lieu
    Not Available
    Messages
    537
    Remerciements
    15
    Remercié(e) 188 fois dans 140 messages
    Pouvoir de réputation
    8

    Re : Algorithmique , Raisonner pour concevoir

    Je vois des remerciements signe que ça marche pour certains donc CONTINUONS ........

    Précisons davantage. Au lieu d’utiliser des nombres, nous utilisons des données d’un type particulier : des COULEURs dont les valeurs sont assujetties à évoluer dans un ensemble donné. Cet ensemble est défini ici par énumération. Il est possible aussi de donner une définition de ce type, pour préciser entièrement les données qui en relèvent.

    Code:
    type
            COULEUR
    contrainte de domaine
             {vert ; orange ; rouge}
    fin COULEUR
    L’expression " contrainte de domaine " exprime que toute donnée de type COULEUR est assujettie à prendre sa valeur dans l’ensemble précisé. Là encore, ce n’est pas la seule façon de définir ce type. En voici une autre : (cuze it's always good)

    Code:
    type COULEUR
            défini par l’énumération {vert ; orange ; rouge}
    fin COULEUR
    Ayant posé cette définition, on considère que nous disposons d’un type COULEUR comme il existe des nombres entiers ou des nombres décimaux. On peut alors simplifier l’expression de l’algorithme 1 avec les conventions suivantes. Le nom de l’algorithme est fait d’une chaîne de caractères unique : changer_couleur, ou changerCouleur, ou ce que l’on voudra comme convention, pourvu qu’elle soit claire, sans ambiguïté. On précise ensuite le type des données sur lesquelles il travaille en entrée, c’estàdire les données qu’il doit recevoir et sur lesquelles il opère pour réaliser l’objectif qui lui est assigné : Entrée c : COULEUR.

    On indique également que cet algorithme a pour objectif de modifier la donnée qu’il reçoit en entrée et que cette modification est sa raison d’être, sa responsabilité. Il s’agit donc de préciser clairement que la donnée c est à la fois une donnée d’entrée, à partir de laquelle l’algorithme va établir son calcul, mais aussi une donnée de sortie, dont la nouvelle valeur est le but du calcul effectué. Il existe différentes conventions qui peuvent être adoptées pour préciser simplement ces points. En voici une :

    Code:
    Entrée Sortie c : COULEUR

    Lorsque l’algorithme modifie certaines données qu’il reçoit en entrée, on ne précise rien de particulier. Ainsi donc, c’est lorsqu’il n’en modifie aucune qu’une mention explicite sera utilisée. Ce sera fait plus bas. Pour ce qui concerne l’algorithme particulier de changement de couleur, le lecteur sait qu’il modifie la donnée en entrée parce que rien ne vient infirmer ce fait. Cependant, un autre signe indique cette particularité.

    L’algorithme retient la valeur de la donnée d’entrée. Il restitue cette valeur lorsqu’il s’agit de préciser l’effet de l’algorithme. Pour obtenir cette valeur, la construction ancienne valeur de c ou ancien c a été utilisée précédemment.
    Cette construction signifie que l’algorithme utilise un opérateur, noté ici ancien par exemple, et que cet opérateur permet de déterminer la valeur de c avant l’exécution du calcul. Ainsi donc, d’une valeur c donnée, cet opérateur en détermine une autre. Pour cette raison, la notation fonctionnelle sera utilisée dans la suite et justifiée plus tard. Par conséquent, la valeur de c avant l’exécution de l’algorithme sera obtenue par ancien(c).

    Il reste à dire clairement ce que fait l’algorithme. C’est le paragraphe introduit par Effet qui l’exprime. Au lieu du mot effet, c’est le mot postcondition qui sera utilisé :

    Code:
    postcondition 
          c = successeur(ancien(c))
    Cette clause exprime que la nouvelle valeur de c calculée par l’algorithme est égale au successeur de la valeur que possédait c avant l’exécution de l’algorithme. On ne dit pas comment ce résultat est calculé, mais seulement ce que fait l’algorithme : il calcule le successeur de c et l’utilise pour modifier c. Ainsi, l’expression désignée par postcondition est une expression qui est soit VRAIE si changer_couleur fait correctement son travail, soit FAUSSE sinon. C’est donc une expression dont le résultat est BOOLÉEN. On parle dans ce cas de prédicat.

    On peut donc à présent donner une définition de changer_couleur utilisant ces conventions :

    Algorithme 3 : Changement de la couleur d’un feu à un carrefour - version 1.0
    Code:
    algorithme : changer_couleur
    Entrée
           c : COULEUR
    postcondition
           c = successeur ( ancien ( c ) )
    fin changer_couleur
    Lorsque l’opérateur successeur fait partie du répertoire de base du langage et que le type COULEUR a été défini, cet algorithme est entièrement spécifié. Cependant, le type COULEUR ayant été construit pour les besoins du problème particulier à résoudre, l’opérateur successeur n’est pas encore défini. Par conséquent, l’algorithme changer_couleur ne prendra tout son sens que lorsque l’opérateur sera complètement spécifié. Ce sera fait plus bas.

    Cette définition de changer_couleur peut encore s’écrire de plusieurs façons équivalentes, utilisant des conventions légèrement différentes. En voici d’autres.

    Algorithme 4 : Changement de la couleur d’un feu à un carrefour - version 1.0
    Code:
    changer_couleur(c : COULEUR)
    postcondition
               c = successeur ( ancien ( c ) )
    fin changer_couleur
    Cette fois, les données d’entrée, celles à partir desquelles l’algorithme réalise son calcul, sont précisées derrière le nom de l’algorithme. C’est cette notation qu’utilisent tous les langages impératifs, avec parfois quelques variations syntaxiques dans la position des éléments. La première ligne est alors appelée la signature de l’algorithme.

    Revenons au fonctionnement. changer_couleur fait passer le système d’un état initial I dans lequel le feu a une couleur c quelconque du domaine du type COULEUR, à un état final F dans lequel la couleur c du feu est devenue le successeur de l’ancienne couleur.

    La transition de l’état initial à l’état final est assurée par l’opération changer_couleur. Finalement, le calcul du changement de couleur peut s’écrire comme ci dessous :

    Algorithme 5 : Changement de la couleur d’un feu à un carrefour - version 2.0
    Code:
    changer_couleur(c : COULEUR)
           # Modifier la couleur du feu qui règle la circulation d’un carrefour.
    précondition
         aucune
    postcondition
         c = successeur ( ancien ( c ) )
    fin changer_couleur
    * La ligne :

    Code:
    # Modifier la couleur du feu qui règle la circulation d’un carrefour.
    forme un commentaire (tu m’étonne tiens). Il n’intervient pas dans la logique des opérations de l’algorithme. Son but est de clarifier une situation en apportant une précision supplémentaire par rapport aux instructions opérationnelles. La clause introduite par précondition indique les conditions que doivent satisfaire les données pour que l’algorithme fasse correctement son travail. Ici, aucune condition particulière n’est imposée aux données d’entrée.

    A Venir : Dernières Améliorations (promis juré)
    Dernière édition par TeamWorK; 25/07/2012 à 02h19
    Not Available

  7. [Les 2 membres suivants remercient TeamWorK pour cet excellent message :


  8. #4
    Inscrit
    juin 2012
    Lieu
    Not Available
    Messages
    537
    Remerciements
    15
    Remercié(e) 188 fois dans 140 messages
    Pouvoir de réputation
    8

    Arrow Re : Algorithmique , Raisonner pour concevoir

    Alors pendant que certains se déchire sur un article que je regrette d'avoir poster (faut vraiment que je filtre mes articles) , cet endroit devient très agréable a fréquenter puisque dénuer de tous bullshit mais que du technique je dis ça car les cours qui vont venir vont s'adresser aux matheux d'entre vous donc intelligence sensible s'abstenir .

    DoncIl est important de bien se convaincre que cet algorithme ne dit rien sur la façon dont il calcule la couleur que doit prendre le feu. Il ne dit pas comment il réalise ce calcul. Il ne dit que ce qu’il fait : calculer la prochaine couleur du feu en utilisant le successeur de la couleur actuelle c qu’il a reçue en entrée. C’est la nouvelle couleur, qui remplace l’ancienne dans c, qui résulte du calcul de changer_couleur.

    Pour que cette définition soit complète, il s’agit, à présent, de préciser ce que fait l’opération successeur. Cette précision n’est nécessaire que s’il n’est pas un opérateur du répertoire d’instructions de notre "langage ". Ainsi, si une COULEUR était un nombre entier par exemple, il ne serait peut être pas nécessaire de définir cet opérateur.

    Pour le définir, il suffit de préciser sa signature et la valeur du résultat qu’il calcule ; c’est ce que fait l’algorithme ci dessous.

    Algorithme 6 :Opérateur successeur - version 1.0

    Code:
    Algorithme successeur
        # Le successeur de c dans la liste (rouge ; vert ; orange).
    Entrée
        c : COULEUR
    Résultat : COULEUR
    précondition
        aucune
    postcondition 
        # c n’est pas modifié. 
        ancien(c) = c
        # Définition du résultat calculé.
          (c = vert   => Résultat = orange)
        ou sinon
          (c = orange => Résultat = rouge)
        ou sinon
          (c = rouge  => Résultat = vert)
    fin successeur
    La postcondition est constituée de deux clauses. La première précise que la couleur c reçue en entrée par l’algorithme successeur n’est pas modifiée. La seconde exprime ce que fait l’algorithme.

    Il existe une différence essentielle, fondamentale, entre cette opération et l’algorithme précédent. L’algorithme changer_couleur a pour but de modifier l’état du système. Il prend une couleur, valeur de c, et il la modifie. La valeur de c n’est plus la même que celle qu’elle avait en entrée lorsque l’algorithme se termine. Au contraire, successeur ne modifie rien ; c’est ce qu’exprime la première clause de la postcondition :

    Code:
    ancien(c) = c
    La valeur de c à la fin de l’exécution de l’algorithme est la même que celle de c lorsque l’algorithme commence son calcul. Il ne fait que calculer une nouvelle valeur à partir d’une donnée c qui reste ce qu’elle est, immuable. L’opérateur successeur est de la même nature qu’une opération, comme 2+3 par exemple. Cette opération prend deux nombres en entrée, 2 et 3 et calcule un résultat, 5, sans modifier les nombres 2 et 3. C’est ce que fait l’opération successeur : elle prend une couleur c et calcule un résultat, le successeur de c, sans modifier c. C’est aussi ce qu’exprime la notation :

    Code:
    Résultat : COULEUR


    Elle signifie que successeur retourne un résultat de type COULEUR, comme 2+3 retourne un résultat de type ENTIER, sans modifier l’opérande, c’est à dire la donnée d’entrée c, elle même de type COULEUR. L’effet de l’algorithme, précisé par les clauses de la postcondition, utilise encore le terme Résultat, qui exprime bien qu’une nouvelle valeur vient d’être obtenue.(génial)

    La notation fonctionnelle introduite plus haut montre mieux encore cette différence de nature entre changer_couleur et successeur :

    Algorithme 7 : Changement de la couleur d’un feu à un carrefour *- version 2.1

    Code:
    successeur(c : COULEUR) : COULEUR
        # Le successeur de c dans la liste (rouge ; vert ; orange).
    précondition
        aucune
    postcondition
        # c n’est pas modifié. 
        ancien(c) = c
        # Définition du résultat calculé.
          (c = vert   => Résultat = orange)
        ou sinon
          (c = orange => Résultat = rouge)
        ou sinon
          (c = rouge  => Résultat = vert)
    fin successeur
    Cette fois, les données d’entrées sont précisées dans la signature. La mention complémentaire indique que l’algorithme calcule un résultat et que ce résultat est de type COULEUR. Ainsi, trois éléments de la notation de ce type d’algorithme concourent à indiquer qu’il ne modifie pas les données qu’il reçoit en entrée pour effectuer ses calculs :

    - la signature porte mention du type du résultat calculé et « retourné » à l’utilisateur logiciel de ses services ;
    - une pseudovariable notée Résultat reçoit la valeur calculée par l’algorithme. C’est cette valeur qui est " retournée " au client logiciel lorsque l’algorithme se termine. Ainsi, la valeur rendue au client est celle que possède cette pseudo variable lorsque l’instruction fin est atteinte ;
    - la postcondition contient une clause qui indique que la valeur de chacune des données d’entrée reste constante pendant les calculs de l’algorithme.

    Le type du résultat, indiqué dans la signature de l’algorithme, est le type de la pseudo variable Résultat qui n’est donc pas déclarée en tant que telle.

    On peut remarquer, cependant, que la conjonction de ces trois conventions est redondante. En effet, les deux premières suffisent à qualifier l’algorithme pour lequel on peut accepter implicitement qu’il ne modifie pas les données en entrée, dès lors que la pseudo variable Résultat apparaît. Le simple fait de donner la signature de l’algorithme montre qu’il est de la classe des opérations qui calculent un résultat sans modifier les données sur lesquelles il opère, comme une addition ne modifie pas les opérandes pour calculer leur somme. Ainsi, la mention ancien(c) = c n’est pas nécessaire et, pour l’algorithme de l’opération successeur, on peut affirmer que c’est un prédicat implicite qui participe à sa postcondition. On s’autorisera donc à ne pas le préciser lorsqu’aucune ambiguïté n’est à craindre.

    Enfin, ici encore, on ne dit que ce que fait l’algorithme, sans dire comment il le fait. C’est que dire comment il fait son travail est plus difficile. Ce sera étudié plus tard.

    Finalement, nous pouvons résumer ce que nous avons appris dans cet exemple.

    Un algorithme est écrit sans contrainte de syntaxe autre que celle qui permet de l’exprimer sans ambiguïté. Ainsi, les conventions d’écriture exposées dans cette section ne sont pas obligatoires. Il est possible d’en adopter d’autres et le seul critère qui doit guider l’auteur de l’algorithme est sa correction et sa lisibilité.

    Nous avons mis en évidence deux classes d’algorithmes. Les uns prennent des données en entrée pour calculer un nouveau résultat et ce calcul ne modifie pas les données utilisées. La signature d’un tel algorithme fait apparaître le type du résultat calculé. De plus, ce résultat est symbolisé par l’expression Résultat qui est donc la valeur produite par l’algorithme au bénéfice des logiciels clients de ses services. Ce résultat devient disponible dès que l’algorithme se termine, c’est à dire juste avant l’expression de la fin annoncée. Un tel algorithme sera appelé une fonction dans la suite du livre. Il ressemble à une fonction mathématique qui calcule un résultat à partir de paramètres sans les modifier. Il a donc le statut d’une requête qui " interroge " le système logiciel pour obtenir une information qui dépend de son état sans modifier cet état. (même moi je trouve ça barbant)

    TeamWorK's Knowledge : "Définition d'une requête"
    Une fonction (requête) est un algorithme qui rend un résultat sans modifier l’état du système logiciel.
    L’autre classe d’algorithmes regroupe ceux qui ne calculent pas un résultat, mais qui modifient certaines données qui leur sont communiquées. Ils modifient donc l’état du système logiciel. Un tel algorithme ressemble à une commande envoyée au système logiciel pour lui demander de modifier son état actuel : c’est une procédure. La signature d’une procédure précise quelles sont les données en entrée et, parmi ces données, celles qui sont modifiées, c’est à dire celles destinées à recevoir de nouvelles valeurs réalisant ainsi un nouvel état du système. Lorsqu’une donnée en entrée voit sa valeur modifiée par l’algorithme, celui ci " retient " la valeur initiale et cette valeur initiale peut être utilisée dans la postcondition à l’aide de la construction ancien.(qui l'aurait cru)

    TeamWorK's Knowledge : "Définition d'une procédure"
    Une procédure (commande) est un algorithme dont le calcul modifie l’état du système logiciel.
    Alors pourquoi pas des exercices récoltés par ci par la mais rassurez vous car expliqué moi je vais .

    Exercice 1 : "Division euclidienne de deux entiers"

    Pré-requis :
    On suppose que la division euclidienne de deux entiers n’est pas une opération du répertoire de notre langage d’implémentation.

    1- Donner les spécifications de l’algorithme qui calcule le quotient entier de deux entiers positifs.
    2- Donner les spécifications de l’algorithme qui calcule le reste de la division entière de deux entiers positifs.
    Dernière édition par TeamWorK; 02/08/2012 à 03h51
    Not Available

  9. Les membres suivants ont remercié TeamWorK pour cet excellent message :


  10. #5
    Inscrit
    juin 2012
    Lieu
    Not Available
    Messages
    537
    Remerciements
    15
    Remercié(e) 188 fois dans 140 messages
    Pouvoir de réputation
    8

    Arrow Re : Algorithmique , Raisonner pour concevoir

    Analyse :
    Le texte de l’énoncé est clair : on demande les spécifications des algorithmes, autrement dit ce que font ces algorithmes et non pas comment ils font leurs calculs. Dans ce cas, le problème est simple.

    Soient a et b deux entiers, positif ou nul pour a qui sera le dividende, strictement positif pour b qui sera le diviseur. Le quotient entier et le reste de la division euclidienne de a par b sont respectivement les entiers q et r tels que :

    Code:
    a = b x q + r avec 0 ≤ r < b
    Le quotient est, par définition, l’unique entier q tel que :

    Code:
    b x q ≤ a < b x (q+1) (équation 1)
    De plus, étant donnés a, b et q, on obtient r par :

    Code:
    r = a - b x q (équation 2)
    On en déduit les spécifications demandées.

    Algorithme 8 : Calcul du quotient euclidien de deux entiers

    Code:
    Algorithme quotient
        # Le quotient euclidien de a par b.
    Entrée :
        a, b : ENTIER
    Résultat : ENTIER
    précondition
           a ≥ 0 
           b > 0
    postcondition
          b x Résultat≤ a < b x (Résultat+1)
    fin quotient
    L’algorithme calcule un résultat : le quotient entier de a par b. Il utilise pour cela des données, a et b de type ENTIER, sans les modifier : c’est une fonction. Le résultat calculé est un ENTIER : c’est dit dans la signature de l’algorithme.

    Cette signature aurait pu s’écrire aussi :

    Code:
    quotient(a, b : ENTIER) : ENTIER
    # Le quotient euclidien de a par b.
    Cependant, la situation est nouvelle cette fois. Cet algorithme exige des conditions sur les données pour pouvoir assurer ses responsabilités. Il est clairement dit que a doit être positif ou nul et b strictement positif. La conjonction de ces deux contraintes imposées aux données en entrée forment la précondition. Ainsi, l’algorithme annonce qu’il ne fera correctement son travail qu’à ces conditions et qu’il est de la responsabilité du client logiciel de s’assurer qu’elles sont remplies avant de demander à l’algorithme de calculer le quotient. L’algorithme, quant à lui, assure que lorsque ces
    conditions sont satisfaites, il rend un Résultat vérifiant les assertions énoncées dans la postcondition.

    La spécification de l’algorithme de calcul du reste consiste à utiliser la formule de calcul de l’équation (2) ci dessus.

    Algorithme 9 : Calcul du reste de la division euclidienne de deux entiers

    Code:
    Algorithmereste
        # Le reste de la division euclidienne de a par b.
    Entrée: 
           a,b:ENTIER
    Résultat : ENTIER
    précondition
           a ≥ b
           b > 0 
    postcondition
        Résultat= a - b x quotient(a,b)
    fin reste
    Remarquez que ce dernier algorithme utilise le résultat calculé par le précédent pour exprimer ce qu’il fait. Cela ne signifie pas qu’il utilise quotient pour calculer son propre résultat. En effet, cette spécification ne dit rien sur la façon dont reste calcule son résultat. Il dit seulement que son calcul consiste à établir un résultat égal à ce qu’annonce la postcondition. En ce sens, cette spécification ne fait que donner une définition du reste de la division.

    A Venir : Plus d'exercices
    Dernière édition par TeamWorK; 03/08/2012 à 00h16
    Not Available

  11. Les membres suivants ont remercié TeamWorK pour cet excellent message :


  12. #6
    Inscrit
    juin 2012
    Lieu
    Not Available
    Messages
    537
    Remerciements
    15
    Remercié(e) 188 fois dans 140 messages
    Pouvoir de réputation
    8

    Arrow Re : Algorithmique , Raisonner pour concevoir

    Exercice : Calcul d’une moyenne arithmétique

    Pré-requis :
    Vous êtes professeur et vous voulez calculer la moyenne arithmétique des notes obtenues dans votre matière par Yahsra.

    Problèmes :
    1- Quels éléments sont nécessaires pour ce calcul ?
    2- Comment spécifier ce calcul à l’aide des éléments recensés à la question précédente ?

    Analyse :
    La moyenne arithmétique est le résultat du quotient de la somme des notes par le nombre de notes. Les éléments nécessaires à ce calcul sont le nombre de notes et les notes proprement dites. Posons
    k > 0 le nombre de notes et n1, n2, ..., nk les notes.(bref rien de compliqué c'est des bases déjà dégrossis)

    Donc, la spécification du calcul peut s’écrire alors :

    Code:
    Entrée
          n1, n2, ..., nk : RÉEL      # Les notes dont on veut la moyenne.
          k : ENTIER                    # Le nombre de notes.
    Résultat : RÉEL          # La moyenne arithmétique des notes.
    précondition
            # Une note est comprise entre 0 et 20.
            (∀i, 1 ≤ i ≤ k) (0 ≤ ni ≤ 20)
            # Le nombre de notes n’est pas nul.
            k ≥ 1
    postcondition
    ∑ni/k
    La spécification de ce problème met en œuvre avantageusement le symbolisme mathématique dont la précision et la concision sont incomparables. Cependant, cette notation n’est pas obligatoire et toute notation, qui définit clairement et sans ambiguïté le problème à résoudre, est acceptable. Ainsi, par exemple, l’expression de la postcondition peut être :

    Code:
    postcondition
        Le quotient par k de la somme des notes n1 , n2 , ..., nk
    Exercice : Calcul*des*intérêts*d’un*compte*d’épargne

    Pré-requis :
    MrCrousty*possède un livret à la Caisse d’épargne. En fin d’année, il souhaite calculer lui même le montant des intérêts rapportés en un an par son capital.

    Problèmes :
    1- Quels sont les éléments nécessaires à ce calcul ?
    2- Spécifier le calcul du montant des intérêts.

    Analyse :
    Le montant des intérêts annuels est obtenu en multipliant le montant du capital par le taux de placement et en divisant le produit par 100. Les données en entrée sont donc le montant du capital placé et le taux de placement.

    Code:
    Entrée
       capital : RÉEL    # Montant du capital.
           taux : RÉEL # Taux de placement.
    Résultat : RÉEL
    précondition
         capital ≥ 0
         taux > 0
    postcondition
         Résultat = capital x taux x 0,01
    Premiers algorithmes :

    Remarque :
    Cette section complète la précédente en montrant, sur quelques exemples élémentaires, les notations utilisées pour dire comment un algorithme effectue son calcul, autrement dit, comment assurer la transition de l’état initial I à l’état final F du système logiciel. On en reste encore, comme dans tout ce chapitre, à des idées intuitives, non formalisées, mais pourtant rigoureuses. Ici aussi, la méthode est exposée à partir d’exercices résolus.(et expliqués bien sure)

    Exercice : Réapprovisionnement de stock

    Cet exercice reprend l’étude de l’exemple 3 commencée au début .

    T.A.F :
    - Écrire les instructions qui résolvent le problème posé.

    Il s’agit donc d’étudier quelles sont les transitions qui feront passer le système logiciel de son état initial I, dans lequel sont connues les valeurs des données d’entrée du problème, à l’état final F dans lequel on sait s’il faut ou non lancer un réapprovisionnement. Nous avons vu, lors de l’étude préliminaire de cet exemple, que les étapes du calcul s’organisent selon le plan suivant :

    - récupérer les données qs, dr et v1, v2, ..., v12 ;
    - calculer la moyenne arithmétique mv des ventes quotidiennes de ce produit ;
    - calculer le niveau de déclenchement qd ;
    - comparer qs à qd :
    - qs ≤ qd => proposer de réapprovisionner ;
    - qs < qd => ne rien faire.

    Analyse :
    Cet algorithme résout le problème et il est complet si on sait calculer une moyenne. Pour réussir à présenter la solution de problèmes plus complexes, pour lesquels cette forme simple d’écriture en langage naturel n’est pas adaptée, nous allons écrire la solution trouvée en utilisant un formalisme un peu plus restrictif que le langage naturel.

    Il s’agit donc, à présent, de dire comment sont effectués les calculs de chaque étape pour prendre la décision.

    On obtient la moyenne mv des ventes quotidiennes en divisant le total des ventes sur l’année par le nombre de jours ouvrables. Si on admet 25 jours ouvrables par mois, on a :

    mv = ∑(i=1…12) vi / 12*25

    Le niveau de déclenchement qd est le produit de cette moyenne par le délai dr de réapprovisionnement : qd = mv x dr

    Comme les vi, dr et qs sont des données du problème, nous disposons de tout ce qui est nécessaire pour organiser le calcul complet. Une première version est donnée ci dessous en deux parties. La première reprend les spécifications du problème. La seconde détaille les opérations à réaliser pour obtenir un résultat qui exprime s’il convient ou non de réapprovisionner.

    Algorithme 9.1 : Spécifications du problème de réapprovisionnement
    Code:
    Algorithme déclenchement
         # Faut-il réapprovisionner ?
    Entrée
         v1, v2, ..., v12 : ENTIER # Volumes des ventes mensuelles.
        dr : ENTIER # Délai de réapprovisionnement.
        qs : ENTIER # Seuil de déclenchement.
    Résultat : BOOLÉEN
    précondition
         toutes les données en entrée sont positives ou nulles.
    Postcondition
         Résultat = qs <= (∑(i=1…12) vi / 12*25)*dr
    fin déclenchement
    Analyse :
    La signature exprime que le calcul produit un résultat BOOLÉEN. Autrement dit, l’algorithme calcule un résultat égal à soit VRAI, soit FAUX, sans modifier les données utilisées pour réaliser ce calcul. Ces données sont des ENTIERs déjà présentés précédemment et elles ne sont soumises à aucune condition particulière, si ce n’est que l’algorithme attend en entrée des entiers non négatifs. Cette condition est exprimée ici en français, mais elle aurait pu tout aussi simplement utiliser les symboles mathématiques usuels dans ce cas.

    La postcondition est un peu délicate et elle mérite quelques explications. Elle est exprimée sous la forme d’une égalité.

    À gauche, on trouve la pseudo variable Résultat dont la valeur est celle rendue par l’algorithme lorsqu’il se termine. À droite du signe égal, on trouve une expression booléenne. Elle prend la valeur VRAI lorsque qs est inférieur ou égal au membre de droite de la comparaison. Elle prend la valeur FAUX sinon. Dans tous les cas, c’est cette valeur, soit VRAI, soit FAUX, que doit prendre Résultat et que vérifie la postcondition. Il faut bien comprendre que le résultat de l’évaluation du membre de droite de l’égalité est une valeur dans l’ensemble {VRAI ; FAUX} et que c’est l’égalité de Résultat avec cette valeur qu’exprime la postcondition.

    Passons à la deuxième partie de cette analyse. Il s’agit de dire comment passer de l’état dans lequel les données d’entrée vérifient la précondition à l’état qui vérifie la postcondition. C’est l’algorithme suivant qui exprime cette réalisation.

    Algorithme 9.2 : Calcul de la décision de réapprovisionner (version provisoire)
    Code:
    Algorithme déclenchement
    Réalisation
        # Calcul de la moyenne quotidienne des ventes.
        mv = (v1 + v2 + ... + v12) / 300
        # Calcul du niveau de déclenchement.
        qd <- mv x dr
        # Calcul de la décision.
        Résultat = (qs ≤ qd)
    fin déclenchement
    Analyse :
    Le calcul de la moyenne mv et du niveau de déclenchement qd utilisent le symbole <*- (flèche dirigée vers la gauche) pour exprimer que, par exemple, mv prend la valeur calculée à droite de la flèche. Ce symbole est utilisé pour le distinguer du signe d’égalité qui exprime une condition booléenne dont la valeur est soit VRAI soit FAUX. Le signe <-* est appelé symbole d’affectation. Il exprime que la variable placée à gauche prend la valeur placée à droite. Ainsi, mv prend la valeur (v1+v2+...+v12)/300 (∑(i=1…12) vi / 12*25) et qd prend la valeur mv x dr.

    Lorsque la quantité actuelle en stock qs est inférieure ou égale au niveau de déclenchement, il faut émettre une proposition de réapprovisionnement. La responsabilité de l’algorithme consiste simplement à renvoyer VRAI comme résultat dans ce cas, ou FAUX dans le cas contraire. C’est ce que fait l’instruction annoncée par le commentaire # Calcul de la décision. La valeur à droite du symbole d’affectation est calculée. Elle prend la valeur VRAI lorsque le stock actuel est inférieur ou égal au niveau de déclenchement. C’est la valeur affectée à Résultat dans ce cas. Lorsque le stock actuel est strictement supérieur au niveau de déclenchement, (qs>qd) est VRAI et par conséquent (qs ≤ qd) est FAUX.

    C’est alors cette valeur qui est affectée à Résultat. Ainsi, dans tous les cas, Résultat prend bien un valeur booléenne qui permettra de prendre la décision de réapprovisionner ou non.

    Sous cette forme, l’algorithme n’est pas assez précis : il ne dit rien sur les symboles mv et qd. Il doit préciser que ce sont deux nombres réels, utilisés localement pour effectuer les calculs intermédiaires. Ces deux symboles n’ont d’existence que dans la fonction.On les déclare en donnant leur type, en début d’algorithme. On obtient alors la version plus détaillée cidessous.
    Dernière édition par TeamWorK; 03/08/2012 à 01h17
    Not Available

  13. #7
    Inscrit
    juin 2012
    Lieu
    Not Available
    Messages
    537
    Remerciements
    15
    Remercié(e) 188 fois dans 140 messages
    Pouvoir de réputation
    8

    Re : Algorithmique , Raisonner pour concevoir

    Algorithme 9.3 : Calcul de la décision de réapprovisionner : version 1.0

    Code:
    Algorithme déclenchement
    variables
         mv : RÉEL # Moyenne quotidienne des ventes.
         qd : RÉEL # Seuil de déclenchement du réapprovisionnement.
    Réalisation
        # Calcul de la moyenne quotidienne des ventes.
        mv = (v1 + v2 + ... + v12) / 300
       # Calcul du niveau de déclenchement.
       qd <* mv x dr
       # Calcul de la décision.
       Résultat = qs ≤ qd
    fin déclenchement
    Analyse : (on commence a en avoir marre non)
    La construction notée à l’aide de l’expression variables précise que ces symboles sont destinés à recevoir des valeurs qui participent au calcul du résultat. Il serait légitime d’insister sur le fait que ces symboles sont locaux à la fonction et qu’ils n’ont pas d’existence en dehors d’elle en écrivant : variables locales. Cependant, cela ne semble pas nécessaire dès lors qu’il est convenu que tout ce qui n’apparaît pas dans la signature est local. De même, il serait possible d’insister sur la nature de l’algorithme en précisant devant son nom fonction ou procédure, comme le font certains auteurs :

    Code:
    fonction déclenchement ( liste des données en entrée) : BOOLÉEN
    Là encore, cela ne semble pas nécessaire avec les conventions adoptées.

    A Venir : Encore encore et encore des exercices
    Dernière édition par TeamWorK; 03/08/2012 à 01h18
    Not Available

  14. #8
    Inscrit
    février 2011
    Lieu
    alger
    Messages
    1 772
    Remerciements
    778
    Remercié(e) 810 fois dans 485 messages
    Pouvoir de réputation
    16

    Re : Algorithmique , Raisonner pour concevoir



    Visitez mon blog habibal.tk en ligne



    et aussi habibal-tv.tk en ligne


    chaine youtube : https://www.youtube.com/user/omhabibal

Règles des messages

  • Vous ne pouvez pas créer de sujets
  • Vous ne pouvez pas répondre aux sujets
  • Vous ne pouvez pas importer de fichiers joints
  • Vous ne pouvez pas modifier vos messages
  •  
  • Les BB codes sont Activés
  • Les Smileys sont Activés
  • Le BB code [IMG] est Activé
  • Le code [VIDEO] est Activé
  • Le code HTML est Désactivé



Liens annexes