Travaux pratiques "Executor Draftsman. Algorithmes auxiliaires". Algorithmes d'assistance avec arguments

Travaux pratiques« Dessinateur exécuteur testamentaire. Utilisation d'algorithmes d'assistance avec des arguments"

Tâche A L'algorithme auxiliaire dont nous avons besoin (qui dessine un carré d'une certaine longueur) peut s'écrire comme suit :

algue carré( arg chose un)
tôt
. baisser le stylo
. décalage par vecteur(0,a)
. décalage par vecteur(a,0)
. décalage par vecteur(0,-a)
. décalage par vecteur(-a,0)
. lever la plume
con

Enregistrement " algue carré( arg chose a)" signifie que l'algorithme "carré" a un argument (arg) "a", qui peut être un nombre réel (réel) arbitraire. Pour appeler cet algorithme, vous devez écrire, par exemple, "carré (2)" - nous obtenons un carré de côté 2 ou "carré (3)" - nous obtenons un carré de côté 3, etc. Une valeur spécifique "a" ne recevra que pendant l'exécution du programme pendant l'algorithme auxiliaire correspondant. Et partout au lieu de "a", ce nombre sera remplacé par l'ordinateur.

Le programme pour dessiner cette image peut ressembler à ceci:

utiliser le tiroir
algue carrés
tôt
. passer à un point(1,1)
. carré(2)
. passer à un point(4,1)
. carré(3)
. passer à un point(8,1)
. carré(4)
. passer à un point(13,1)
. carré(5)
. passer à un point(0,0)
con
algue carré( arg chose un)
tôt
. baisser le stylo
. décalage par vecteur(0,a)
. décalage par vecteur(a,0)
. décalage par vecteur(0,-a)
. décalage par vecteur(-a,0)
. lever la plume
con

Tâche B Apprenons au dessinateur de nouvelles commandes. Appelons l'une des commandes " ligne(arg th x1,y1,x2,y2)» – pour tracer une ligne du point (x1,y1) au point (x2,y2).

algue ligne( arg chose x1, y1, x2, y2)
tôt
. passer à un point(x1,y1)
. baisser le stylo
. passer à un point(x2,y2)
. lever la plume
con

Tâche V Appelons la seconde commande " rectangle(arg th x1,y1,x2,y2)' pour dessiner un rectangle. Le point (x1,y1) est un point de la diagonale AC du rectangle, le point (x2,y2) est l'opposé. Avant d'écrire l'algorithme, vous devez comprendre quelles sont les coordonnées des deux autres points.

Un algorithme d'assistance pourrait ressembler à ceci :

algue rectangle( arg chose x1, y1, x2, y2)
tôt
. passer à un point(x1,y1)
. baisser le stylo
. passer à un point(x2,y1)
. passer à un point(x2,y2)
. passer à un point(x1,y2)
. passer à un point(x1,y1)
. lever la plume
con

Tâche G Maintenant, en utilisant ces commandes, nous allons dessiner une maison :

utiliser le tiroir
algue loger
tôt
. rectangle(2,1,8,5)
. rectangle(3,2,5,4)
. rectangle(6,1,7,4)
. ligne(1,4,5,8)
. ligne(5,8,9,4)
con
algue ligne( arg chose x1, y1, x2, y2)
tôt
. passer à un point(x1,y1)
. baisser le stylo
. passer à un point(x2,y2)
. lever la plume
con
algue rectangle( arg chose x1, y1, x2, y2)
tôt
. passer à un point(x1,y1)
. baisser le stylo
. passer à un point(x2,y1)
. passer à un point(x2,y2)
. passer à un point(x1,y2)
. passer à un point(x1,y1)
. lever la plume
con

Remarque : bien sûr, en plus de ces commandes, nous pouvons utiliser les commandes standard du dessinateur (se déplacer vers un point, se déplacer vers un vecteur...).

Tâche D Dessinez vous-même ce que le Drawer va dessiner en exécutant l'algorithme :

utiliser le tiroir
algue spirale
tôt
. passer à un point(3,3)
. baisser le stylo
. bobine(1); bobine(3); bobine(5); bobine(7); bobine (9)
. lever la plume
con
algue bobine( arg chose un)
tôt
. décalage par vecteur(un, 0)
. décalage par vecteur(0, -a)
. décalage par vecteur(-a-1.0)
. décalage par vecteur(0, a+1)
con.

Quantités dans un langage algorithmique. Commandes d'entrée/sortie d'informations. commande d'affectation. Algorithmes d'assistance. Algorithmes avec résultats et algorithmes-fonctions

Terme ordre de grandeur, qui est utilisé dans le langage algorithmique, a été introduit par Andrei Petrovich Ershov, l'empruntant aux mathématiques et à la physique, estimant qu'il serait plus facile à comprendre pour les écoliers. Dans les langages de programmation de production, le terme est couramment utilisé variable, qui est de plus en plus remplacé par le terme un objet. En même temps, dans la programmation orientée objet, ils parlent de un objet et condition objet. Nous utilisons plutôt les termes ordre de grandeur et sens quantités.

Ici, il convient de noter que de nombreux concepts de différents langages de programmation sont synonymes, et l'utilisation de l'une ou l'autre terminologie est souvent due à l'habitude d'un enseignant ou d'un développeur d'un langage de programmation, et non aux besoins de dénomination. de nouvelles notions. Au cours de l'informatique scolaire, on « ne court délibérément pas devant la locomotive », en essayant d'éviter d'introduire de nouveaux concepts et entités jusqu'au moment où il n'est plus possible de s'en passer.

Une parenthèse sur l'opportunité de la formalisation. La mathématisation et la formalisation ne sont pas nécessaires si l'essentiel de la matière peut être expliqué « sur les doigts », en utilisant un vocabulaire courant. Voici un extrait d'un manuel de théorie du langage de programmation qui explique la différence entre les "sous-mots" et les "sous-séquences" d'un mot :

Définition 1.2.19. Laisser . Puis à travers Suf( L) désigne l'ensemble constitué de tous les suffixes des mots de la langue L:

L'ensemble Suf( L) est appelé de nombreux suffixes Langue L.

numéro de journal
	Conférence 1. Les principaux objectifs du cours. Méthodologie pour construire un cours. Approche du problème. La théorie s'apprend par la pratique. Le système KuMir est un support efficace pour les concepts traditionnels des langages de programmation procéduraux et les méthodes de débogage traditionnelles. Exemples d'utilisation de "KuMir" dans les cours pré-professionnels.
	Cours 2. Connaissance pratique du système « KuMir » : Robot performeur. Le concept d'algorithme. Contrôler le robot interprète à l'aide de la télécommande. Algorithmes linéaires. Enregistrement de l'algorithme. Digression : Karel-Robot dans le cours initial de programmation à l'université de Stanford.
	Cours 3. Méthodes d'enregistrement « visuel » de l'algorithme. Contrôle logiciel du robot. Cycle " n une fois que". Utilisation d'algorithmes auxiliaires. Ecrire des algorithmes dans un langage algorithmique.
	Contrôle du travail numéro 1.
	Conférence 4. Expressions arithmétiques et règles pour leur enregistrement. Algorithmes avec "feedback". commande "au revoir". Conditions dans un langage algorithmique. Commandes "si" et "choix". Commandes de contrôle. Représentation « visuelle » des commandes. Digression: règles et forme d'écriture des expressions arithmétiques en Fortran du 21e siècle.
	Cours 5. Quantités dans le langage algorithmique. Commandes d'entrée/sortie d'informations. commande d'affectation. Algorithmes auxiliaires. Algorithmes avec résultats et algorithmes-fonctions. Le cycle "pour". Valeurs du tableau. Valeurs logiques, symboliques et littérales.
	Cours 6. Méthodes d'algorithmique. Relations récurrentes. méthode d'itération. invariant de cycle. Récursivité.
	Contrôle du travail numéro 2.
	Conférence 7. Fondements physiques des ordinateurs modernes. Le microprocesseur est le cœur de l'ordinateur moderne. Comment construire un ordinateur.
	Conférence 8. Interprètes virtuels et réels dans le système KuMir. Dessinateur interprète. Lego-Robot est un exécuteur contrôlé par programme de "KuMir". Hypertextes dans le système KuMir. Préparation des devoirs pour les étudiants et leur vérification automatique. Travail final.

Définition 1.2.20. Ils disent le mot X - sous-mot(sous-chaîne) mots y, si y = uxv pour certains mots, peut-être vides tu et v.

Définition 1.2.21. Laisser . Puis via Subw( L) désigne l'ensemble constitué de tous les sous-mots des mots de la langue L. L'ensemble Subw( L) est appelé beaucoup de sous-mots Langue L.

Définition 1.2.22. Mot un 1 un 2 …un(longueur n i 0) s'appelle sous-séquence(sous-séquence) mots y, s'il existe de tels mots éventuellement vides tu 0 , tu 1 , …, vous, Quel tu 0 un 1 tu 1 un 2 …un n u n = y.

Définition 1.2.23. Tous les sous-mots du mot y sont aussi des sous-séquences du mot y.

Définition 1.2.24. Laisser . Puis via Subseq( L) désigne l'ensemble constitué de toutes les sous-séquences de mots de la langue L. Set Subseq( L) est appelé ensemble de sous-séquences Langue L.

Une telle présentation est nécessaire pour les futurs auteurs de compilateurs de langages de programmation qui ont besoin de maîtriser des centaines de concepts de la théorie mathématique des langages formels. Si vous n'avez besoin d'expliquer que quelques concepts, il est plus utile de se passer de toute notation mathématique, après avoir analysé l'essence du sujet à l'aide d'exemples :

les mots "vapeur", "fossé" et "chariot" sont appelés sous-mots les mots « moteur », ils sont constitués de lettres consécutives du mot « moteur » ;

le mot "pic" sous-mot le mot « moteur » ne l'est pas, il ne peut pas être obtenu à partir de lettres consécutives du mot « moteur », mais vous pouvez l'obtenir, de manière séquentielle, de gauche à droite, en choisissant des lettres du mot « moteur » : nous prenons la première lettre " p", sautez les 6 lettres suivantes et les deux dernières nous prenons les lettres "ik" ;

dire que le mot "pic" est sous-séquence les mots "train" ;

dans le mot « désignation », il y a un sous-mot de la langue russe et plusieurs sous-séquences ;

tout sous-mots d'un mot donné sont aussi des sous-séquences de ce mot, de sorte que les mots "steam", "ditch" et "voz" ne sont pas seulement sous-mots, mais aussi sous-séquences le mot « train ».

Ainsi, à la suite de l'académicien Ershov, nous n'utilisons pas les termes acceptés en programmation variable ou un objet, et nous introduisons le terme évaluer.

Comme toujours dans notre cours, une approche problématique est utilisée pour introduire un nouveau concept. Autrement dit, tout commence par la formulation du problème, pour la solution duquel nous avons besoin de quantités. Amenons-la.

Le Robot est situé à proximité d'un mur horizontal de dimensions inconnues, la distance entre le Robot et les bords du mur est inconnue, il est nécessaire de déplacer le Robot "à travers le mur" d'une cellule vers le bas. Étant donné que le robot ne peut pas traverser les murs, c'est-à-dire vous ne pouvez pas simplement commander "vers le bas", alors vous devez forcer le robot à contourner ce mur d'une manière ou d'une autre.

Comme toujours, la principale technique méthodologique au départ est l'opposition du schéma de contrôle du programme au schéma de contrôle direct du Robot "manuellement". Si vous proposez de résoudre le problème à l'aide de la télécommande et sans voir le champ Robot, les élèves comprendront rapidement qu'ils doivent se rendre sur l'un des bords du mur, par exemple à droite, en demandant tout le temps " est le mur en dessous ? et compter le nombre de pas effectués. Et lorsque le mur se termine, commandez "bas" et faites autant de pas "vers la gauche" que de pas "vers la droite" ont été effectués auparavant.

Avec le contrôle direct, les élèves se souviennent du nombre de pas effectués « vers la droite » « dans leur esprit » ou l'écrivent sur papier. Si nous passons maintenant du contrôle direct du Robot à l'écriture d'un algorithme, il faudra en quelque sorte écrire dans l'algorithme que lors du contrôle du Robot, l'ordinateur (comme un écolier) doit se souvenir du nombre de commandes exécutées par le Robot "pour la droite » et utilisez cette information lorsque vous reculez vers la gauche.

Si la tâche de contrôle direct est résolue dans un dialogue entre l'enseignant et la classe, il est alors commode pour l'enseignant de dessiner un petit rectangle sur le tableau noir avec de la craie et, au fur et à mesure que les commandes «à droite» sont reçues, avec les élèves, inscrivent dans ce rectangle le nombre de pas effectués par le Robot : avant de commencer, ils inscrivent « 0 ». Ils ont fait le premier pas vers la droite - effacé "0" et entré "1" dans le rectangle du tableau, ont fait un autre pas - effacé "1" et écrit "2", etc. Au-dessus du rectangle, l'enseignant peut, sans explication, écrire le nom du rectangle sous la forme ensemble X .

Ce que nous avons fait avec le rectangle dans le processus de contrôle manuel :

· tracer un rectangle et son nom au tableau ;

· notez les informations dans un rectangle en effaçant les anciennes informations ;

lire les informations d'un rectangle.

Les mêmes opérations devront être effectuées lors du contrôle du robot et de l'ordinateur, et dans le programme, nous devons en quelque sorte enregistrer ces opérations.

Au lieu de "rectangle", nous dirons "valeur". Dessiner un rectangle et son nom sur le tableau correspond à la commande pour décrire le nom de la valeur (et son type).

Enregistrement d'informations dans un rectangle avec effacement anciennes informations correspond à une commande spéciale - la commande d'affectation (:=); la lecture des informations correspond à l'utilisation du nom de la valeur dans les expressions.

La valeur a plusieurs caractéristiques. Le plus important d'entre eux est le nom. Les noms de valeurs dans un algorithme doivent être différents, comme on dit, le nom doit être unique pour cet algorithme.

Retraite. L'unicité du nom d'une personne. Les noms que nous utilisons dans la vie de tous les jours sont-ils uniques ? Malheureusement non. Il peut y avoir deux Denis et trois Dashas dans une classe, et deux Vovas dans une famille. Les gens le combattent en ajoutant au nom Informations Complémentaires: surnom, nom, patronyme, date et lieu de naissance. Dans la classe, ils distinguent Denis Ivanov et Denis Petrov, dans la famille Sidorov, ils distinguent Vova le grand et Vova le petit. Cependant, cela ne donne pas une garantie à 100% d'unicité. Ainsi, dans les années 90, deux dames se sont rencontrées en Australie, nées le même jour et portant le même nom et prénom. Ils se sont rencontrés lorsqu'une des dames a reçu une contravention pour infraction au stationnement, qu'elle n'a pas violée. C'est alors qu'il s'est avéré que le nom, le prénom et la date de naissance ne peuvent pas identifier une personne de manière unique. Pour clarifier, vous devez ajouter l'adresse et bien d'autres caractéristiques diverses qui forment ensemble le nom unique d'une personne en particulier (nom avec lettre capitale). Le problème de l'unicité est ancien. Tout le monde connaît le nom du célèbre philosophe grec ancien Thales de Milet, c'est-à-dire Thales de Milet, la ville où il a vécu. Jésus de Nazareth est encore plus célèbre. En lisant l'Ancien Testament, nous rencontrons de longues généalogies de lignée masculine: aux temps bibliques, une telle généalogie était le nom unique d'une personne.

Le nom arrive aux valeurs, aux tables, aux algorithmes et aux interprètes. Le nom est une séquence de mots séparés par des espaces. Le premier mot du nom ne doit pas commencer par un chiffre. Aucun des mots ne doit être un mot-clé. Un mot est une séquence de caractères (de dictionnaire) autorisés : · lettres (cyrillique et latine, majuscules et minuscules); · Nombres; · deux caractères spéciaux : "@", "_" Exemples de noms : m, météo pour demain, 7 novembre, 7 novembre, maison_57b. Exemples de noms incorrects : · alpha-bêta ("-" est un caractère invalide ); alpha ou oméga ( ou - mot-clé). Les mots clés du langage KuMir sont : alg début fin utilisation fin_utilisation donnée besoin arg couper argrez valeur int ve log sim lit tab celtab vehtab logtab symtab littab et ou non oui non oui sortie entrée sortie ns sinon toute sélection à nc ccc cc_at temps tant que pour de à pas vrai faux Noter. Mot-clé ne pas peuvent être insérés dans des noms logiques à plusieurs mots. Exemple: log l, demain c'est jeudi l := ne pas Demain c'est jeudi | Correct, mais pas l:= demain ne pas ce sera jeudi | C'est vrai, l: = demain sera ne pas Jeudi | C'est vrai l: = demain c'est jeudi ne pas| Faux l := ne pas demain ne pas sera jeudi | Faux

Les valeurs d'un langage algorithmique diffèrent non seulement par leur nom, mais aussi par le lieu où elles "vivent": des valeurs issues d'algorithmes différents peuvent avoir le même nom. Lorsque la valeur x est utilisée dans l'algorithme Walk the Wall, on peut imaginer que nom et prénom cette valeur ressemble à
« x from walk around the wall » : dans un autre algorithme, il est possible d'utiliser le même nom x pour une valeur complètement différente.

La deuxième caractéristique importante d'une grandeur est sa Type de.

Il existe 5 types de quantités dans un langage algorithmique : les types numériques ensemble et chose, types de texte Litas et Simulateur et type booléen Journal. Connaissant le type, vous pouvez en dire beaucoup sur l'ampleur. Premièrement, quelles valeurs peut-il prendre. Ainsi, un entier ( ensemble) Peut stocker entier, mais ne peut pas stocker de valeurs réelles, et pour les valeurs réelles, il y a type séparé (chose). Une valeur textuelle peut stocker une séquence de caractères, y compris un caractère vide, une valeur booléenne stocke l'une des deux valeurs Pas vraiment.

Le type vous indique également quelles opérations sont autorisées sur la valeur.

Les opérations de comparaison sont applicables aux valeurs de types numériques et textuels ; les opérations arithmétiques et le calcul de diverses fonctions sont applicables aux valeurs de types numériques. Les opérations logiques sont applicables aux valeurs de type booléen et ,ou,ne pas.

On notera en particulier l'opération, notée " + ” . Il peut être appliqué aux types numériques et dans cette situation signifie addition. Il peut également être appliqué aux types de texte et signifie "coller" deux chaînes ou caractères ensemble :

Les opérations de comparaison sont applicables aux valeurs de types numériques et textuels. Ainsi, avec des valeurs réelles (et entières), les opérations arithmétiques et les opérations de comparaison sont autorisées. Pour les lettres, les opérations de comparaison sont autorisées, etc.

Types de valeur Les quantités de langage algorithmique sont divisées en plusieurs types : · ensemble - prend des valeurs entières de -2 147 483 647 à 2 147 483 647 ; · chose - prend des valeurs réelles entre? 2 1023 et 2 1023 ; · Journal - accepte les valeurs oui ou non ; · Simulateur - la valeur peut être un caractère littéral ; · Litas - la valeur peut être une chaîne de caractères littéraux. Les types ensemble et chose sont appelés numériques ; les types Simulateur et Litas- texte. Chaque valeur doit avoir une description, par exemple : longueur, largeur de l'article allumé mon texte

Une autre caractéristique de quantité est voir valeurs : argument, résultat, valeur intermédiaire de l'algorithme, valeur totale de l'interprète. Le type de valeur montre son rôle informationnel dans l'algorithme. Par exemple, les arguments contiennent les informations initiales nécessaires au fonctionnement de l'algorithme, et les valeurs intermédiaires sont destinées à stocker les informations courantes que l'algorithme traite. Lors de l'exécution de l'algorithme, à chaque instant particulier, soit la valeur a une certaine valeur, soit elle n'est pas définie.

Le nom, le type et le type de valeur peuvent être déterminés sans ambiguïté par le texte de l'algorithme.

Ce sont des caractéristiques statiques de la quantité. Les étudiants peuvent toujours les trouver dans le programme. En revanche, la valeur d'une grandeur n'est déterminée qu'au moment de l'exécution. On peut dire que c'est une caractéristique dynamique.

Ayant à portée de main un outil tel que les quantités, vous pouvez utiliser un ordinateur - Électronique L'informatique Machine - non pas pour contrôler divers appareils, mais pour son "usage prévu" - pour l'informatique. Commençons par un calcul relativement simple - trouver la somme S première N nombres impairs:

S = 1 + 3 + 5 + 7 + ... + 2N–1

Dans ce montant N nombres, et si vous les numérotez de 1 à N, puis le nombre avec le nombre je sera égal à 2 je–1.

Le programme de calcul que nous allons écrire doit, comme tout autre programme, récupérer les informations initiales quelque part et « envoyer » le résultat du calcul quelque part. Nous ferons un programme de dialogue. Il recevra les premières informations d'une personne tapant au clavier le nombre requis de membres de la somme N Notre programme "rapportera" également le résultat à la personne, en affichant la valeur du montant calculé à l'écran S. Pour stocker des informations dans le processus de calcul, nous utiliserons deux valeurs entières - N et S. Pour stocker le numéro de la prochaine sommation, nous utiliserons une valeur entière je. Pour entrer et sortir des informations, nous utiliserons les commandes saisir et conclusion, et pour itérer sur les termes de la somme, nous utiliserons le cycle au revoir. Le programme ressemblera à ceci :

Les équipes sont nouvelles ici saisir et conclusion en utilisant la troisième fenêtre - Fenêtre d'E/S système "Kumir". Jusqu'à présent, nous n'avons effectivement utilisé que deux fenêtres sur trois dans le système KuMir. La troisième fenêtre affichait des messages tels que "l'exécution a commencé" et "l'exécution est terminée", et parfois des messages d'erreur. Désormais, cette fenêtre sera utilisée "aux fins prévues" - pour l'entrée et la sortie de valeurs. Comment cela se passerait-il ?

Lors de l'exécution de la commande saisir N L'ordinateur affichera un curseur clignotant dans la fenêtre de sortie, invitant l'étudiant à entrer un nombre à partir du clavier. Si l'élève tape un chiffre sur le clavier, par exemple le chiffre 3, et termine la saisie en appuyant sur la touche , l'ordinateur effectuera exactement les mêmes actions que lors de l'exécution de la commande d'affectation N := 3 . Autrement dit, le nombre 3 deviendra la valeur de la quantité N(sera écrit à l'intérieur du "rectangle" de la valeur N).

Contrairement à BASIC et Pascal, le nouvel appel de commande conclusion dans le langage algorithmique de l'école, en soi ne conduit pas à une nouvelle ligne dans la fenêtre d'E / S. Si nous voulons dire à l'ordinateur que la prochaine information doit être sortie d'une nouvelle ligne, alors nous devons explicitement écrire le mot ns(abréviation de "nouvelle ligne") dans une commande conclusion . C'est exactement ce que nous avons fait dans le programme. Si nous sommes le motns ne pas écrire, alors aucune transition implicite vers une nouvelle ligne n'est effectuée et différents appels à la commande conclusion affichera les informations les unes après les autres sur une seule ligne. La saisie des informations se fait généralement en appuyant sur une touche , c'est à dire. sauter à une nouvelle ligne. Par conséquent, généralement lors de l'entrelacement d'une commande de sortie avec des commandes d'entrée, en règle générale, aucunens pas besoin d'écrire. Si on veut, comme dans le programme "Sum", afficher les informations sur deux lignes, alors il faut écrire les commandes au bon endroit conclusion mot ns .

Exécutons le programme "Sum" en mode continu. Au début de l'exécution, une ligne contenant des informations sur le début de l'exécution sera affichée dans la fenêtre d'E / S. De plus, lors de l'exécution de la ligne

cible précoce N, S, je

dans la mémoire de l'algorithme "Sum", une place est allouée pour stocker des valeurs entières N , S , je. Dans un premier temps, ces trois grandeurs ne sont pas définies (aucune valeur n'est inscrite dans leurs "rectangles"). Évaluer N recevra Valeur souhaitée lors de l'exécution de la commande

saisir N

En voyant un curseur clignotant à l'intérieur de la fenêtre d'E/S et le message "Entrée attendue : entier" en bas de la fenêtre, l'utilisateur saisit un entier, appuie sur la touche, et la valeur de la valeur N devient égal à ce nombre. Notez que ce nombre ne changera pas au cours de l'exécution ultérieure du programme. Après avoir saisi un numéro N le programme prépare la sommation : la valeur S la valeur initiale de la somme, c'est-à-dire 0, est attribuée, et la valeurje le numéro du premier membre de la somme est attribué, c'est-à-dire 1. Ensuite, la boucle «while» commencera à être exécutée. Au cours de l'exécution du cycle, les valeursS et je changera en concert : après k exécutions de cycle S sera égal à la somme des premiers k nombres sommables, etje sera égal au nombre du nombre suivant, pas encore additionné, c'est-à-direk + 1 . Le cycle se terminera lorsque je devient égal N + 1 . Une fois la boucle terminée, la commande sera exécutée

sortie "Somme des premiers", N, "

nombres impairs ", ns, "est égal à", S

Cette commande fournit la sortie de plusieurs informations :

1) chaîne "Somme des premières"

2) la valeur d'une valeur entière N

3) ficelle "nombres impairs"

4) instruction de saut de ligne ns

5) ficelle "égal"

6) la valeur d'une valeur entière S

Parce que dans l'équipe conclusion rencontré le mot ns, la sortie sera produite en deux lignes.

La dernière ligne à exécuter sera con. Lorsque cette ligne est exécutée, un message indiquant la fin de l'exécution du programme et une barre horizontale s'affichent dans la fenêtre d'E / S.

Retraite. Sur la vérification expérimentale des théorèmes mathématiques. Exécutez le programme Somme plusieurs fois, en donnant le nombre de termes 4, 5, 6 et 10. Le programme nous donnera les réponses 16, 25, 36 et 100.

Il semble que la somme des premiers N les nombres impairs sont toujours égaux N 2 ! Cette hypothèse mathématique est en effet correcte, la formule

1 + 3 + 5 + 7 + ... + 2N– 1 =N 2

peut être rigoureusement prouvée mathématiquement, mais si nous échouons, nous pourrions continuer à explorer expérimentalement l'hypothèse, écrire un programme qui calcule les sommes des premiers 7, 8, 9, 10, 11, ..., 99, 100 nombres impairs et vérifie si une telle somme est toujours égale au carré du nombre de nombres additionnés. C'est ainsi que les mathématiciens utilisent l'ordinateur pour tester expérimentalement des théorèmes non prouvés. Fin de retraite.

L'un des calculs les plus célèbres souvent vus au lycée est le calcul des racines d'une équation quadratique. Un tel calcul est capable de réaliser une partie importante des diplômés lycée La Russie, qui les distingue de leurs pairs étrangers. De plus, tout élève qui a appris à calculer les racines d'une équation quadratique peut expliquer à un autre élève comment effectuer un tel calcul. Cela signifie que cet algorithme ne sera pas difficile à « expliquer » à un ordinateur.

Alors, donné équation quadratique gentil hache 2 + boîte+ c= 0
Avec chose coefficients naturels (réels) un,b,c.

Quoi nécessaire fais?

Vous dites que vous devez trouver les vraies racines de l'équation X 1 et X 2. Cette réponse est généralement correcte, mais pas complète. Il faut le préciser, car une équation quadratique peut ne pas avoir de racines, et pour certaines valeurs des coefficients un,b,c Une équation peut avoir une racine, pas deux. La réaction de l'ordinateur dans ces cas doit également être prévue dans l'algorithme. Ainsi, plus en détail, la tâche de compilation de l'algorithme ressemble à ceci :

Étant donné les nombres réels un,b,c, et un non égal à zéro.

Besoin de trouver un numéro n racines réelles de cette équation et les racines elles-mêmes (dans le cas n= 2 trouver X 1 et X 2 , un au cas où n= 1 découverte X 1 .

Nous avons déjà commencé à approfondir les détails mathématiques sans résoudre la question de savoir comment notre algorithme recevra les informations initiales et où le résultat sera "envoyé". Cette fois, nous allons composer un algorithme qui, au début et à la fin de son exécution, sera prêt à "communiquer" non pas avec une personne, mais avec tout autre algorithme, recevant de sa part des informations initiales (arguments) et renvoyant des résultats.

Pour notre algorithme, nous choisissons nom courtkvoor- équation quadratique. Arguments d'algorithmekvoor seront des nombres réels un , b,c.Résultats de l'algorithme kvoor sera un entier n et deux nombres réels x1 et x2.La première ligne de l'algorithme ressemblera à :

alg quur(arg ref a, b, c, int res n, ref x1, x2)

Les règles du langage algorithmique permettent, après l'en-tête de l'algorithme, d'écrire dans la commande donné conditions que les arguments doivent satisfaire, et dans la commande nécessaire conditions que les résultats de l'algorithme doivent satisfaire. Ces conditions peuvent être écrites soit formellement, sous forme d'expressions logiques, puis l'ordinateur les vérifiera, soit de manière informelle, sous forme de commentaires pour une personne. Dans l'algorithme kvoor nous utilisons les deux approches :

alg quur (arg wt a, b, c, res int n,

Donné un<>0 |a, b, c – coefficients

besoin de 0<= n <= 2 |при n = 2, x1 и x2

| racines de l'équation, pour n = 1, x1

| la seule racine de l'équation,

| pour n = 0, l'équation n'a pas de racine

Comment résoudre un tel problème ? Il faut d'abord calculer le discriminant ( ré) selon la formule ré = b 2 – 4ac. Si un ré< 0, alors l'équation n'a pas de racine, avec ré = 0 - la racine est une (on dit parfois que les racines coïncident). Lorsque ré> 0 - deux racines. Dans ce cas, les racines sont trouvées par la formule :

Numéro ré n'est pas un argument de notre algorithme, il n'est pas inclus dans la condition du problème ; n'est pasré et le résultat, puisque dans l'état du problème il faut trouver le nombre de racines et les racines elles-mêmes, mais pas le discriminant ; ré est un résultat intermédiaire de notre calcul, et pour stocker ce nombre nous le décrirons dans l'algorithmekvoor valeur intermédiaire réelle chose D. Les valeurs intermédiaires de l'algorithme sont généralement décrites dans la ligne tôt ou juste après :

alg quur (arg wt un, b, c, coupé intact n,

chose x1, x2)

donné un<> 0 |un, b, c- coefficients

| équation a * x * x + b * x + c = 0

besoin de 0<= n<= 2

| quand n= 2, les racines de l'équation égal x1 et x2;

| quand n= 1, la seule racine est x1 ;

| quand n= 0, l'équation n'a pas de racine ;

commencer les choses ré; ré:= b* b– 4 * un * c

En se souvenant de la manière dont les expressions sont écrites dans un langage algorithmique, nous obtenons le programme suivant :

Entrée sortie Format d'appel conclusion : conclusion expression1, . . . , expressionN Chaque expression peut être soit une expression arithmétique, logique ou textuelle, soit une commande de retour à la ligne (mot clé ns). Les valeurs des expressions sont sorties séquentiellement sur la ligne de la zone d'E/S et sont séparées par un espace. Lorsqu'une ligne est pleine, elle saute automatiquement au début d'une nouvelle ligne. Lorsque la fenêtre d'E/S est pleine, les commandes de sortie suivantes poussent le contenu de la fenêtre vers le haut, effaçant les lignes supérieures de la fenêtre. Format d'appel saisir : nom d'entrée1, . . . , nomN Lors de l'exécution de cette commande, "KuMir" place le curseur dans la fenêtre d'E / S et attend que l'utilisateur entre les valeurs appropriées. Une fois terminé, les valeurs saisies sont affectées aux valeurs spécifiées. En tant que nom de valeur, vous pouvez spécifier le nom d'une valeur simple ou le nom d'un élément de table avec des valeurs d'index. Un signe de fin de saisie est l'appui sur la touche . Lors de la saisie de plusieurs chiffres, ils sont séparés les uns des autres par une virgule ou un espace.

Fichiers d'artistes

En principe, des algorithmes simples pourraient se passer de commandes d'entrée-sortie. L'entrée de valeurs de quantités peut être remplacée avec succès par des commandes d'affectation, et la sortie des résultats de l'algorithme peut être observée dans les champs :

Dans les marges, nous voyons la dernière valeur de la quantité S, égal à 10 000. Cette valeur est le résultat du calcul.

Mais dans certains cas, lorsque nous voulons automatiser complètement la solution d'une tâche, la confier à un ordinateur, regarder le contenu des champs ou des fenêtres d'entrée-sortie, ou appuyer sur des touches pour saisir des chiffres, il n'y a tout simplement personne , puisque nous voulons simplement exclure complètement une personne du processus de calcul effectué par l'ordinateur. Bien sûr, au lieu d'entrer une ou deux valeurs initiales de quantités, vous pouvez entrer des commandes d'affectation dans le programme, mais ce ne sera pas un programme universel qui fonctionne pour n'importe quelle valeur de paramètre, mais un programme spécialisé, par exemple, calculant la somme du premier N nombres impairs uniquement N= 100. Il est clair que nous n'avons pas besoin de tels programmes. Une autre chose est si dans la commande d'entrée, il serait possible d'obtenir les valeurs des quantités en les demandant à un interprète, et non à une personne. Pour résoudre un tel problème, vous avez besoin d'un exécuteur Files. Un dossier est un concept familier pour un écolier, et vous n'aurez pas à passer beaucoup de temps à inventer une méthodologie pour introduire le concept de « dossier ». Un peu de temps devra être consacré aux fonctionnalités de l'interprète de fichiers dans KuMir.

Traditionnellement, nous utilisons cohérent accès aux fichiers. Soit un fichier contenant trois nombres réels un, b, c, les coefficients de l'équation quadratique. Avec un accès séquentiel, nous ne pourrons pas lire à partir du fichier b sans lire un et pour arriver à Avec, doit lire d'abord un et b. Il en va de même pour l'écriture dans un fichier. Les valeurs des quantités sont sorties dans le fichier dans l'ordre dans lequel elles sont répertoriées dans la commande de sortie et dans l'ordre dans lequel les appels de commande de sortie apparaissent. L'exécuteur de fichiers peut travailler avec chaque fichier dans l'un des deux modes suivants : en mode lecture ou en mode écriture. Travailler avec un fichier en mode lecture commence par la commande ouvert à la lecture; travailler avec un fichier en mode écriture commence par la commandeouvert à l'écriture. Le fichier doit exister lorsque l'une de ces deux commandes est appelée. Inutile de créer le fichier que nous allons lire, il sera vide. Mais il est logique de créer un fichier vide avant d'y écrire des informations, et cela peut être fait avec la commande create.

Comme les valeurs dans un langage algorithmique, les fichiers doivent également être nommés d'une manière ou d'une autre. Les principes de nommage des fichiers sont légèrement différents selon le système d'exploitation sur lequel KuMir s'exécute (MS Windows, MacOS, Linix, etc.). Le nom de fichier n'est nécessaire que pour les commandes d'ouverture et de création de fichiers. La commande open (qu'elle soit en lecture ou en écriture) renvoie une valeur entière, en l'attribuant à une valeur que nous appelons la clé. Chaque fichier ouvert a sa propre clé unique qui lui est associée, et les commandes d'E/S utilisent la clé obtenue lors de l'ouverture du fichier, plutôt que le nom du fichier. Pour distinguer les commandes de lecture/écriture de fichier des commandes d'E/S habituelles, leurs noms commencent par une lettre F(Voir le tableau).

Fichiers d'artistes Le système de commande de l'exécuteur de fichiers comprend : · 5 commandes-ordres (création/fermeture de fichier, ouverture en lecture/écriture, démarrage de relecture) ; · 2 commandes de vérification des conditions (existence du fichier et atteinte de la fin du fichier) ; · 2 instructions d'E/S. · créer un fichier ( argument allumé Nom de fichier) Crée un nouveau fichier vide dans le répertoire d'E/S courant. · ouvert à la lecture ( argument allumé Nom de fichier, coupé intact Clé) Ouvre un fichier en lecture et lui attribue un identifiant. · ouvert à l'écriture ( argument allumé Nom de fichier, coupé intact Clé) Ouvre un fichier en écriture et lui attribue un identifiant. · commencer à lire ( arg entier Clé) Commence à lire les éléments d'un fichier depuis le début · Clé f_input, . . . Opérateur. Saisie des données d'un fichier avec clé d'identification . Clé f_output, . . . Opérateur. Sortie des données dans un fichier avec clé d'identification . · Journal fin de fichier ( arg entier Clé) Vérifie si la fin du fichier a été atteinte. · proche ( arg entier Clé) Ferme un fichier après l'avoir ouvert en lecture ou en écriture. · Journal le fichier existe ( argument allumé Nom de fichier) Vérifie si un fichier existe dans le répertoire d'E/S courant.

À la fin du travail avec le fichier, nous lui disons "au revoir" avec la commande proche.L'argument de cette commande sera à nouveau la valeur de la valeur Key .

Il est important de noter que vous ne pouvez pas lire et écrire dans le même fichier en même temps. Voici les modifications apportées à l'algorithme quur qui vous permettent de lire les coefficients à partir d'un fichier lisible avec la clé entrée et d'écrire les résultats dans un fichier inscriptible avec la clé sortie . Nous appellerons cet algorithme f_quur . Il existe également un programme de test qui lit les coefficients de l'équation quadratique à partir du fichier "tR.txt", et écrit le résultat dans un fichier portant le nom "tW.txt", et si un fichier portant ce nom n'existe pas, puis il est créé.

Dans le dernier exemple de fichier, nous avons une nouvelle commande de l'exécuteur de fichiers :

ouvert à la lecture ( argument Litas Nom de fichier,

Couper ensemble Clé)

En même temps, ce n'est pas seulement une nouvelle Équipe d'un nouvel Artiste. Pour nous, c'est un nouveau style dans le traitement des algorithmes auxiliaires. Ici, nous passons non seulement un argument à l'algorithme (qui est le nom de fichier ) ou obtenez simplement le résultat - les commentaires de l'interprète. Ici, ces deux phénomènes sont combinés en un seul appel. Dans le même temps, que nous parlions des commandes de l'exécuteur (par exemple, Files) ou de l'algorithme auxiliaire écrit par nous, le mécanisme d'interaction reste inchangé. Si auparavant, en utilisant des arguments, nous avons transmis des informations de l'algorithme principal à l'algorithme auxiliaire, maintenant, en utilisant les résultats, nous pouvons transférer des informations de l'algorithme auxiliaire à l'algorithme principal.

Comment l'ordinateur fonctionnera, en exécutant des algorithmes avec des arguments et des résultats, nous expliquerons à l'aide de l'exemple d'un algorithme qui calcule la longueur de l'hypoténuse à partir des valeurs des jambes d'un triangle rectangle.

Lorsqu'un algorithme auxiliaire est appelé, le sacrement suivant se produit : l'algorithme auxiliaire commence à "vivre", alloue de l'espace dans sa mémoire pour les paramètres (qu'il s'agisse d'arguments ou de résultats), puis les valeurs des arguments qui ont été passés à il de l'algorithme principal lorsqu'il est appelé sont copiés sur ceux créés dans les quantités de l'algorithme auxiliaire. Ceci est suivi par l'exécution de l'algorithme auxiliaire lui-même. Avant de terminer, les résultats de l'algorithme auxiliaire sont copiés dans les valeurs spécifiées dans l'appel. Et puis l'algorithme auxiliaire cesse d'exister, est supprimé de la mémoire de l'ordinateur avec toutes ses valeurs.

Ainsi, si nous devons transmettre des valeurs de l'algorithme principal à l'auxiliaire, nous utilisons des arguments, si de l'auxiliaire au principal -
puis les résultats. À l'aide d'arguments et de résultats, nous pouvons organiser tout échange d'informations entre les algorithmes principaux et auxiliaires.

Dans le même temps, il est souhaitable que les écoliers maîtrisent non seulement le concept d'algorithme auxiliaire avec des résultats, mais apprennent également à identifier indépendamment ces algorithmes auxiliaires dans les tâches, à proposer leurs arguments et leurs résultats et à les décrire brièvement dans donné et nécessaire finalité et conditions de fonctionnement de l'algorithme.

Passons maintenant à un autre type d'algorithmes auxiliaires - algorithme-fonction. Dans les exemples ci-dessus - à la fois pour trouver la longueur de l'hypoténuse et pour résoudre l'équation quadratique - la fonction mathématique intégrée à KuMir a été utilisée sqrt. Comme vous l'avez probablement deviné (ou su), cette fonction calcule la racine carrée de l'argument spécifié, par exemple, sqrt(1.21) . On peut supposer qu'il existe toute une classe d'algorithmes auxiliaires intégrés à KuMir, qui sont organisés de manière similaire. Et c'est la vraie vérité.

Les commandes de rétroaction des interprètes sont disposées de la même manière, par exemple, la commande "top free" du Robot. La forme d'écriture de ces algorithmes auxiliaires-fonctions est légèrement différente des algorithmes auxiliaires avec résultats.

Voici à quoi ressemble l'algorithme modifié pour calculer l'hypoténuse le long de deux jambes, en utilisant une fonction d'algorithme auxiliaire :

Algorithmes-procédures et algorithmes-fonctions La fonction-algorithme après exécution renvoie la valeur-résultat. Les règles de description des algorithmes-procédures et des algorithmes-fonctions ont deux différences. Tout d'abord, pour les algorithmes de fonction sur place, algorithm_type un des types de langage algorithmique simple doit être spécifié (chose , ensemble etc.) qui définit le type de valeurs que cette fonction accepte. Pour les algorithmes de procédure type_algorithme devrait être omis. Deuxièmement, dans le corps de l'algorithme-fonction, il est nécessaire d'utiliser la valeur de service évaluer , dans lequel la valeur calculée de la fonction est écrite. Dans le corps de l'algorithme-procédure, la valeurévaluer Ne peut pas être utilisé. Les algorithmes-fonctions et les algorithmes-procédures diffèrent également dans la manière dont ils sont appelés.

Tout algorithme qui utilise un algorithme de fonction auxiliaire peut toujours être écrit sans algorithmes de fonction, en les remplaçant par des algorithmes auxiliaires avec des résultats (cela peut être vu dans l'exemple précédent, cependant, nous avons fait le contraire). Au lieu d'une commande d'affectation un:= F(X), où F- algorithme-fonction, vous pouvez écrire un appel F(X,un), où X est un argument, et un- résultat.

Bien sûr, les fonctions sont plus pratiques dans certains cas. Si nous comparons deux algorithmes de calcul de l'hypoténuse par jambes, nous pouvons noter que dans l'algorithme principal, lors de l'utilisation d'algorithmes-fonctions auxiliaires, la valeur «supplémentaire» n'était pas du tout requise DE. Les algorithmes-fonctions sont pratiques dans la mesure où nous pouvons immédiatement les écrire dans une expression et ainsi simplifier la notation. En même temps, il n'y a pas d'essence fondamentale dans les fonctions algorithmiques. Ce n'est qu'une forme spéciale d'écriture d'un algorithme auxiliaire avec un résultat.

Lors de l'utilisation d'algorithmes-fonctions et d'algorithmes avec résultats, la même chose se produit : les arguments sont passés de l'algorithme principal à l'auxiliaire, et le résultat est renvoyé. L'essence des algorithmes avec des résultats et des algorithmes-fonctions est la même. Ce n'est qu'à la fin de l'exécution de l'algorithme-fonction que la valeur de la quantité évaluer est substitué dans l'expression au lieu d'appeler la fonction-algorithme. Motévaluer est une abréviation des mots «valeur de fonction» et, comme le reste de la terminologie du cours scolaire d'informatique et du langage algorithmique (algorithme, argument, résultat, valeur, valeur, etc.), a été introduite par l'académicien Andrei Petrovich Ershov en empruntant aux mathématiques.

Ici, vous pouvez attirer l'attention des écoliers sur le fait que cette tâche n'est pas équivalente à la tâche de Charles Perrault, qui, dans un conte de fées bien connu, voulait rentrer chez lui avec ses frères: "... Le pouce était le dernier à partir. De temps en temps, il sortait des cailloux blancs de sa poche et les jetait derrière lui sur la route. Le problème Thumb-Boy est résolu en peignant sur les cellules traversées par le robot (on suppose initialement qu'il n'y a pas de cellules peintes sur le terrain). Dans ce cas, vous n'avez pas à vous souvenir du nombre d'étapes. ( Perro Sh. Garçon de pouce. Chaperon Rouge. Blue Beard et autres. M.: Maison d'édition "HARVEST LLC".)

2 Tous les algorithmes étudiés à l'école ne sont pas faciles à expliquer à un ordinateur. Essayez, par exemple, d'écrire un algorithme de multiplication décimale à plusieurs chiffres (max 6 chiffres) qui manipule uniquement des informations symboliques pour représenter les chiffres de 0 à 9. Ce n'est pas du tout un algorithme aussi simple que la résolution d'une équation quadratique.

Remarque importante : il convient de noter que pendant l'exécution de l'algorithme auxiliaire, l'exécution de l'algorithme principal est suspendue.

Pour dessiner deux carrés avec des côtés différents, disons 2 et 3, nous avons dû écrire deux algorithmes d'assistance différents. Mais que se passe-t-il si vous devez dessiner de nombreux carrés différents avec des longueurs de côté différentes ? N'écrivez pas votre propre algorithme pour tout le monde ! Il s'avère que les algorithmes peuvent avoir des arguments, il est possible de composer un algorithme pour dessiner un carré avec une longueur de côté arbitraire.

Vous avez déjà rencontré le concept d'argument en mathématiques. En mathématiques, un argument de fonction est une variable indépendante dont les valeurs dépendent des valeurs de la fonction.
Par exemple, la fonction f(x) = x 2 +1 a un argument. Pour différentes valeurs de l'argument, nous obtiendrons différentes valeurs de la fonction - pour x=2 nous obtenons f(x)=5, pour x=3 nous obtenons f(x)=10, etc.

L'algorithme auxiliaire dont nous avons besoin (qui dessine un carré d'une certaine longueur) peut s'écrire comme suit :

alg carré(arg w)
tôt
. baisser le stylo
. décalage par vecteur(0,a)
. décalage par vecteur(a,0)
. décalage par vecteur(0,-a)
. décalage par vecteur(-a,0)
. lever la plume
con

La notation "alg square(arg w)" signifie que l'algorithme "square" a un argument (arg) "a", qui peut être un nombre réel (réel) arbitraire.
Pour appeler cet algorithme, vous devez écrire, par exemple, "carré (2)" - nous obtenons un carré de côté 2 ou "carré (3)" - nous obtenons un carré de côté 3, etc. .
Une valeur spécifique "a" ne sera reçue que pendant l'exécution du programme pendant l'algorithme auxiliaire correspondant. Et partout au lieu de "a", ce nombre sera remplacé par l'ordinateur.

Le programme pour dessiner cette image peut ressembler à ceci:

utiliser le tiroir
carrés d'algues
tôt
. passer à un point(1,1)
. carré(2)
. passer à un point(4,1)
. carré(3)
. passer à un point(8,1)
. carré(4)
. passer à un point(13,1)
. carré(5)
. passer à un point(0,0)
con
alg carré(arg w)
tôt
. baisser le stylo
. décalage par vecteur(0,a)
. décalage par vecteur(a,0)
. décalage par vecteur(0,-a)
. décalage par vecteur(-a,0)
. lever la plume
con

Apprenons au dessinateur de nouvelles commandes. Appelons l'une des commandes " ligne(arg th x1,y1,x2,y2)» – pour tracer une ligne du point (x1,y1) au point (x2,y2).

tôt
. passer à un point(x1,y1)
. baisser le stylo
. passer à un point(x2,y2)
. lever la plume
con

Appelons la seconde commande " rectangle(arg th x1,y1,x2,y2)' pour dessiner un rectangle. Le point (x1,y1) est un point de la diagonale AC du rectangle, le point (x2,y2) est l'opposé. Avant d'écrire l'algorithme, vous devez comprendre quelles sont les coordonnées des deux autres points.

Un algorithme d'assistance pourrait ressembler à ceci :

tôt
. passer à un point(x1,y1)
. baisser le stylo
. passer à un point(x2,y1)
. passer à un point(x2,y2)
. passer à un point(x1,y2)
. passer à un point(x1,y1)
. lever la plume
con

Maintenant, en utilisant ces commandes, nous allons dessiner une maison :

utiliser le tiroir
maison de campagne
tôt
. rectangle(2,1,8,5)
. rectangle(3,2,5,4)
. rectangle(6,1,7,4)
. ligne(1,4,5,8)
. ligne(5,8,9,4)
con
ligne alg(arg th x1, y1, x2, y2)
tôt
. passer à un point(x1,y1)
. baisser le stylo
. passer à un point(x2,y2)
. lever la plume
con
alg rectangle(arg th x1, y1, x2, y2)
tôt
. passer à un point(x1,y1)
. baisser le stylo
. passer à un point(x2,y1)
. passer à un point(x2,y2)
. passer à un point(x1,y2)
. passer à un point(x1,y1)
. lever la plume
con

Remarque : bien sûr, en plus de ces commandes, nous pouvons utiliser les commandes standard du dessinateur (se déplacer vers un point, se déplacer vers un vecteur...).

Tâche 1. À l'aide des algorithmes auxiliaires de ligne et de rectangle, créez un dessin.

Tâche 2. Essayez de réécrire les algorithmes de ligne et de rectangle afin que le dessin soit effectué par la commande de vecteur de décalage.

Tâche 3. Écrire un algorithme "rectangle (arg w x, y, a, b)" qui dessine un rectangle avec des longueurs de côté a et b, commençant et se terminant au point (x, y).

Tâche 4. Dessinez vous-même ce que le dessinateur dessinera en exécutant l'algorithme :

utiliser le tiroir
spirale d'algue
tôt
. passer à un point(3,3)
. baisser le stylo
. bobine(1); bobine(3); bobine(5); bobine(7); bobine (9)
. lever la plume
con
tour alg(arg w)
tôt
. décalage par vecteur(un, 0)
. décalage par vecteur(0, -a)
. décalage par vecteur(-a-1.0)
. décalage par vecteur(0, a+1)
con