-
Notifications
You must be signed in to change notification settings - Fork 1
Expand file tree
/
Copy pathtuto_blocs_2.html
More file actions
803 lines (789 loc) · 37.2 KB
/
tuto_blocs_2.html
File metadata and controls
803 lines (789 loc) · 37.2 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
<title>Tuto blocs - MicroAlg</title>
<meta name="description"
content="Tutoriel en ligne pour MicroAlg." />
<meta name="keywords" content="microalg, algo, algorithme, algorithmique, lisp, environnement" />
<script type="text/javascript" src="http://ajax.googleapis.com/ajax/libs/jquery/1.8.2/jquery.min.js"></script>
<script>window.jQuery || document.write('<script src="web/jquery.min.js"><\/script>')</script>
<script src="emulisp/int.js" type="text/javascript"></script>
<script src="emulisp/emulisp_core.js" type="text/javascript"></script>
<link href="//fonts.googleapis.com/css?family=Raleway:400,300,600" rel="stylesheet" type="text/css">
<link rel="stylesheet" type="text/css" href="web/style.css" />
<script type="text/javascript" src="web/ide_injections.js"></script>
<script type="text/javascript" src="web/parenedit.js"></script>
<link type="text/css" href="web/parenedit.css" rel="stylesheet" />
<script src="web/showdown.js"></script>
<script src="web/svg-tree-drawer/svg-tree-drawer.js"></script>
<link href="web/css-ninja-tree/css-ninja-tree.css" rel="stylesheet"/>
<script src="web/showup.js"></script>
<link type="text/css" href="web/showup.css" rel="stylesheet" />
<script type="text/javascript" src="web/blockly/blockly_compressed.js"></script>
<script type="text/javascript" src="web/blockly_microalg.js"></script>
<link rel="icon" href="visuels/logo_microalg.ico" />
</head>
<body class="microalg">
<noscript>
<div style="color:#CC0000; text-align:center">
Besoin de JavaScript pour les exercices interactifs.
</div>
</noscript>
<div class="navbar">
<a href="./">accueil</a> :
<a href="#top">haut de page</a>
</div>
<h1 id="top">MicroAlg - Tutoriel par blocs</h1>
<p>Cette page est la suite de <a href="tuto_blocs.html">celle-ci</a>.
Impossible de continuer si vous ne l’avez pas lue avant.</p>
<p><strong>Sur cette page</strong>, aller directement à :
<a href="#variables">Variables</a>,
<a href="#affectation-circulaire">Affectation circulaire</a>,
<a href="#operations-logiques">Opérations logiques</a>,
<a href="#manipulation-de-texte">Manipulation de texte</a>,
<a href="#faire-tant-que">Faire… tant que…</a>,
<a href="#tant-que-faire">Tant que… faire…</a>,
<a href="#construction-affichage">Construction et affichage de listes</a>,
<a href="#structure">Listes : structure et lien avec le texte</a>,
<a href="#parcours-lecture">Parcours de listes</a>,
<a href="#type-affectation">Listes : type et affectation</a>,
<a href="#taper-du-code">Taper du code</a>,
<a href="#contact">Contact</a>.
</p>
<p><strong>Sur la page précédente</strong>, aller directement à :
<a href="tuto_blocs.html#prise-en-main-et-affichage">Prise en main et affichage</a>,
<a href="tuto_blocs.html#commentaires">Commentaires</a>,
<a href="tuto_blocs.html#texte-et-concatenation">Texte et concaténation</a>,
<a href="tuto_blocs.html#repeter">Répéter</a>,
<a href="tuto_blocs.html#nbres-pseudo-aleatoires">Nombres pseudo-aléatoires</a>,
<a href="tuto_blocs.html#demander">Demander à l’utilisateur</a>,
<a href="tuto_blocs.html#calculs-nombres">Calculs avec des nombres</a>,
<a href="tuto_blocs.html#calculs-nombres-demandes">Calculs avec des nombres demandés à l’utilisateur</a>,
<a href="tuto_blocs.html#booleens">Booléens</a>,
<a href="tuto_blocs.html#si">Si</a>.
</p>
<h2 id="contact">Contact</h2>
<p>En cas de problème, ne pas hésiter à poser une question dans
<a href="http://qr.microalg.info">la section Questions/Réponses</a>,
ou à envoyer <a href="mailto:profgra.org@gmail.com" class="email">un
email au créateur de MicroAlg</a>.</p>
<h2 id="variables"><a href="#variables">: </a>Variables</h2>
<p>On a parfois besoin de stocker le résultat de <code>(Demander)</code>
pour pouvoir se servir plusieurs fois de cette valeur. En effet, si on
demande deux fois une valeur, l'utilisateur peut ne pas répondre deux fois
la même chose.</p>
<p>Cela peut être :</p>
<ul>
<li>le nom de l'utilisateur, si on veut afficher des phrases contenant
son nom tout au long d'un jeu,</li>
<li>une valeur numérique qui sert plusieurs fois dans un calcul comme
<code>x</code> dans <code>(x+1)(x+2)</code>.</li>
</ul>
<p>Pour pouvoir utiliser une variable avec MicroAlg, il faut :</p>
<ol>
<li>tout d’abord la <em>déclarer</em>, c’est-à-dire annoncer qu’on veut
l’utiliser et qu’elle aura un certain type, en utilisant la commande
<code>Declarer</code>,</li>
<li>lui <em>affecter</em> une valeur, peut-être plusieurs fois au cours
du programme, en utilisant la commande <code>Affecter_a</code>,</li>
<li><em>accéder</em> à sa valeur, simplement en utilisant le bloc des
variables, dans la catégorie « Valeurs ». Par défaut, le bloc donne
la valeur de la variable <code>ma_variable</code>, mais vous pouvez
indiquer la variable que vous voulez en cliquant dessus.</li>
</ol>
<p>Voici quelques exemples :</p>
<div id="script-variable-texte"></div>
<script>inject_microalg_editor_in('script-variable-texte', {
blockly_only: true,
src:
'(!!! "`nom` est le nom de l’utilisateur")\n' +
'(Declarer nom De_type "texte")\n' +
'(Afficher "Quel est votre nom ?")\n' +
'(Affecter_a nom (Demander))\n' +
'(Afficher\n' +
' (Concatener\n' +
' "Bonjour "\n' +
' nom\n' +
' ". "\n' +
' )\n' +
')\n' +
'(Afficher\n' +
' (Concatener\n' +
' nom\n' +
' ", c’est vraiment un joli nom."\n' +
' )\n' +
')'
});</script>
<div id="script-variable-nombre"></div>
<script>inject_microalg_editor_in('script-variable-nombre', {
blockly_only: true,
src:
'(!!! "x est le nombre fourni par l’utilisateur")\n' +
'(Declarer x De_type "nombre")\n' +
'(Afficher "Donnez une valeur à x, SVP.")\n' +
'(Affecter_a x (Nombre (Demander)))\n' +
'(Afficher\n' +
' (Concatener\n' +
' "Le carré de "\n' +
' (Texte x)\n' +
' " vaut :"\n' +
' )\n' +
')\n' +
'(Afficher (* x x))'
});</script>
<p><strong>Exercice</strong> : Dans le programme suivant, on veut
afficher un certain nombre de fois un texte que l’utilisateur va choisir.
Malheureusement, le programme ne fonctionne pas comme prévu, l’utilisateur
ne devrait écrire qu’une seule fois le mot à afficher. Corrigez ce
programme.</p>
<div id="script-variable-repeter"></div>
<script>inject_microalg_editor_in('script-variable-repeter', {
blockly_only: true,
src:
'(Afficher "Tapez d’abord un nombre, Entrée, puis le texte à répéter.")\n' +
'(Repeter (Nombre (Demander)) Fois\n' +
' (Afficher (Demander))\n' +
')\n' +
''
});</script>
<p>Dans le dernier programme, on remarque que le symbole de la
multiplication <code>×</code> ressemble à la lettre <code>x</code>.
C’est bien le produit de <code>x</code> et de <code>x</code>.</p>
<p><strong>Attention</strong>, les commandes <code>Declarer</code> et
<code>Affecter_a</code> effectuent des vérifications :</p>
<ul>
<li><code>Declarer</code>
<ul>
<li>ne peut pas déclarer une même variable deux fois,</li>
<li>le type fourni :
<ul>
<li>est un texte et doit donc être entre guillemets,</li>
<li>doit être un type existant, comme
<code>"texte"</code>, <code>"nombre"</code>,
<code>"booleen"</code>…</li>
</ul>
</li>
</ul>
</li>
<li><code>Affecter_a</code>
<ul>
<li>ne peut pas changer la valeur d’une variable si cette
variable n’a pas été déclarée auparavant,</li>
<li>ne peut pas changer le type d’une variable (la nouvelle
valeur doit être du même type que l’ancienne valeur).</li>
</ul>
</li>
</ul>
<h2 id="affectation-circulaire"><a href="#affectation-circulaire">: </a>Affectation circulaire</h2>
<p>Il n’est pas interdit d’utiliser une variable dans un calcul dont le
résultat sera affectée à cette même variable. C’est même parfois utile en
vue d’<em>accumuler</em> des valeurs, qu’elles soient textuelles,
numériques ou d’un autre type.</p>
<p>Dans <code>(Affecter_a var (Calcul var))</code>, il faut bien comprendre
que :</p>
<ol>
<li>le second <code>var</code> désigne la <strong>valeur</strong> qui est
stockée dans la variable, qui sera envoyée à <code>Calcul</code> ;</li>
<li>le premier <code>var</code> désigne le <strong>nom</strong> de la
variable à mettre à jour avec le résultat de
<code>(Calcul var)</code>.</li>
</ol>
<p>Nous allons donner deux exemples.</p>
<p>Dans le premier, on accumule des nombres avec une instruction de la
forme :<br>
<code>(Affecter_a valeur (Somme valeur valeur_a_ajouter))</code></p>
<p>Ce qui signifie : « <code>valeur</code> prend pour nouvelle valeur le
résultat du calcul <code>valeur</code> + <code>valeur_a_ajouter</code> ».</p>
<div id="script-accu-nombres-ex"></div>
<script>inject_microalg_editor_in('script-accu-nombres-ex', {
blockly_only: true,
src:
'(Declarer valeur De_type "nombre")\n' +
'(Affecter_a valeur 0)\n' +
'(Affecter_a valeur (+ valeur 1))\n' +
'(Afficher valeur)\n' +
''
});</script>
<p>Dans le second, on accumule du texte avec une instruction de la
forme :<br>
<code>(Affecter_a texte (Concatener texte texte_a_ajouter))</code></p>
<p>Ce qui signifie : « <code>texte</code> prend pour nouvelle valeur la
concaténation de <code>texte</code> avec <code>texte_a_ajouter</code> ».</p>
<div id="script-accu-textes-ex"></div>
<script>inject_microalg_editor_in('script-accu-textes-ex', {
blockly_only: true,
src:
'(Declarer texte De_type "texte")\n' +
'(Affecter_a texte "Bonjour")\n' +
'(Affecter_a texte (Concatener texte " !"))\n' +
'(Afficher texte)\n' +
''
});</script>
<p>Voici deux programmes plus complets qui utilisent ce principe.</p>
<p>Un où l’on accumule des nombres pour calculer leur somme :</p>
<div id="script-accu-nombres"></div>
<script>inject_microalg_editor_in('script-accu-nombres', {
blockly_only: true,
src:
'(Declarer S De_type "nombre")\n' +
'(Affecter_a S 0)\n' +
'(Afficher "Veuillez taper un nombre SVP.")\n' +
'(Affecter_a S (+ S (Nombre (Demander))))\n' +
'(Afficher "Veuillez en taper un autre.")\n' +
'(Affecter_a S (+ S (Nombre (Demander))))\n' +
'(Afficher "Encore un dernier SVP.")\n' +
'(Affecter_a S (+ S (Nombre (Demander))))\n' +
'(Afficher "La somme des nombres vaut :")\n' +
'(Afficher S)\n' +
''
});</script>
<p>Un où l’on accumule du texte (en ajoutant au passage des espaces) :</p>
<div id="script-accu-textes"></div>
<script>inject_microalg_editor_in('script-accu-textes', {
blockly_only: true,
src:
'(Declarer mots De_type "texte")\n' +
'(Affecter_a mots "")\n' +
'(Afficher "Veuillez taper un mot SVP.")\n' +
'(Affecter_a mots (Concatener mots (Demander)))\n' +
'(Affecter_a mots (Concatener mots " "))\n' +
'(Afficher "Veuillez en taper un autre.")\n' +
'(Affecter_a mots (Concatener mots (Demander)))\n' +
'(Affecter_a mots (Concatener mots " "))\n' +
'(Afficher "Encore un dernier SVP.")\n' +
'(Affecter_a mots (Concatener mots (Demander)))\n' +
'(Afficher "Vous avez tapé :")\n' +
'(Afficher mots)\n' +
''
});</script>
<h2 id="operations-logiques"><a href="#operations-logiques">: </a>Opérations logiques</h2>
<p>Voici un programme vu précédemment :</p>
<div id="script-si-emboites-appli2"></div>
<script>inject_microalg_editor_in('script-si-emboites-appli2', {
blockly_only: true,
src:
'(Afficher "Veuillez taper un nombre.")\n' +
'(Declarer nbre De_type "nombre")\n' +
'(Affecter_a nbre (Nombre (Demander)))\n' +
'(Si (>= nbre 0)\n' +
' Alors (Si (>= nbre 1000)\n' +
' Alors (Afficher "Ce nombre est positif et assez grand.")\n' +
' Sinon (Afficher "Ce nombre est positif ou nul, et pas trop grand.")\n' +
' )\n' +
' Sinon (Si (<= nbre -1000)\n' +
' Alors (Afficher "Ce nombre est négatif et assez grand.")\n' +
' Sinon (Afficher "Ce nombre est négatif et pas trop grand.")\n' +
' )\n' +
')'
});</script>
<p>On peut parfois éviter d’emboîter les <code>Si</code> en effectuant des
calculs sur les booléens. Cela simplifie beaucoup le code quand, par
exemple, on doit vérifier qu’un nombre appartient à un intervalle.</p>
<div id="script-intervalle"></div>
<script>inject_microalg_editor_in('script-intervalle', {
blockly_only: true,
src:
'(Afficher "Veuillez taper un nombre.")\n' +
'(Declarer nbre De_type "nombre")\n' +
'(Affecter_a nbre (Nombre (Demander)))\n' +
'(Si (Et (>= nbre 1) (<= nbre 6))\n' +
' Alors (Afficher "Ce nombre est compris entre 1 et 6.")\n' +
' Sinon (Afficher "Ce nombre est n’est pas compris entre 1 et 6.")\n' +
')' +
''
});</script>
<p>Essayez d’obtenir le même résultat sans l’instruction <code>Et</code> !</p>
<p>MicroAlg fournit les opérations sur les booléens suivantes :</p>
<ul>
<li><code>Non</code>, qui retourne le contraire du booléen fourni en
paramètre ;</li>
<li><code>Et</code>, qui retourne <code>Vrai</code> seulement si les
deux booléens en paramètre sont <code>Vrai</code>s ;</li>
<li><code>Ou</code>, qui retourne <code>Vrai</code> si au moins un des
deux booléens est <code>Vrai</code>.</li>
</ul>
<div id="script-operations-logiques"></div>
<script>inject_microalg_editor_in('script-operations-logiques', {
blockly_only: true,
src:
'(Afficher (Concatener "`(Non Faux)` donne : " (Texte (Non Faux))))\n' +
'(Afficher (Concatener "`(Non Vrai)` donne : " (Texte (Non Vrai))))\n' +
'(Afficher "")\n' +
'(Afficher (Concatener "`(Et Faux Faux)` donne : " (Texte (Et Faux Faux))))\n' +
'(Afficher (Concatener "`(Et Faux Vrai)` donne : " (Texte (Et Faux Vrai))))\n' +
'(Afficher (Concatener "`(Et Vrai Faux)` donne : " (Texte (Et Vrai Faux))))\n' +
'(Afficher (Concatener "`(Et Vrai Vrai)` donne : " (Texte (Et Vrai Vrai))))\n' +
'(Afficher "")\n' +
'(Afficher (Concatener "`(Ou Faux Faux)` donne : " (Texte (Ou Faux Faux))))\n' +
'(Afficher (Concatener "`(Ou Faux Vrai)` donne : " (Texte (Ou Faux Vrai))))\n' +
'(Afficher (Concatener "`(Ou Vrai Faux)` donne : " (Texte (Ou Vrai Faux))))\n' +
'(Afficher (Concatener "`(Ou Vrai Vrai)` donne : " (Texte (Ou Vrai Vrai))))\n' +
''
});</script>
<h2 id="manipulation-de-texte"><a href="#manipulation-de-texte">: </a>Manipulation de texte</h2>
<p>Un texte, ou <em>chaîne de caractères</em> n’est qu’une liste de lettres.</p>
<p>La commande <code>Longueur</code> retourne le nombre de lettres d’un
texte.</p>
<p>Le prédicat <code>Vide?</code> permet d’écrire <code>(Vide? texte)</code>
au lieu de <code>(= 0 (Longueur texte))</code>.</p>
<div id="script-longueur-vide"></div>
<script>inject_microalg_editor_in('script-longueur-vide', {
blockly_only: true,
src:
'(Afficher (Longueur "salut"))\n' +
'(Afficher (Vide? "salut"))\n' +
'(Afficher (Longueur ""))\n' +
'(Afficher (Vide? ""))\n' +
'\n' +
'(!!! "Cela fonctionne aussi avec une variable contenant du texte.")\n' +
'(Declarer txt De_type "texte")\n' +
'(Affecter_a txt "bonjour")\n' +
'(Afficher (Longueur txt))\n' +
'(Afficher (Vide? txt))\n' +
'(Affecter_a txt "")\n' +
'(Afficher (Longueur txt))\n' +
'(Afficher (Vide? txt))\n' +
''
});</script>
<p>La commande <code>Nieme</code>, prononcée « énième », retourne une des
lettres du texte, en fonction de l’indice que l’on fournit (deuxième
argument).</p>
<div id="script-nieme"></div>
<script>inject_microalg_editor_in('script-nieme', {
blockly_only: true,
src:
'(Afficher (Nieme "salut" 1))\n' +
'(Afficher (Nieme "salut" 2))\n' +
'(!!! "Attention, il faut que l’indice soit")\n' +
'(!!! "un entier strictement positif,")\n' +
'(!!! "inférieur ou égal à la longueur du texte.")\n' +
'(!!! "Essayez de modifier le code ci-dessus pour qu’il génère une erreur.")\n' +
'\n' +
'(!!! "Cela fonctionne aussi avec une variable contenant du texte.")\n' +
'(Declarer txt De_type "texte")\n' +
'(Affecter_a txt "bonjour")\n' +
'(Afficher (Nieme txt 4))\n' +
''
});</script>
<p>La commande <code>Nieme@</code>, prononcée « énième aléatoire »
(<em>pseudo</em>-aléatoire pour les puristes), retourne une des lettres du
texte, prise au hasard. Lancez plusieurs fois de suite le programme
suivant :</p>
<div id="script-nieme-aleatoire"></div>
<script>inject_microalg_editor_in('script-nieme-aleatoire', {
blockly_only: true,
src:
'(Afficher (Nieme@ "salut"))\n' +
''
});</script>
<p>Nous aurons parfois besoin de couper la tête d’un texte, pour
travailler de proche en proche.</p>
<div id="script-tete-queue"></div>
<script>inject_microalg_editor_in('script-tete-queue', {
blockly_only: true,
src:
'(Afficher (Tete "salut" ))\n' +
'(Afficher (Queue "salut" ))\n' +
'(Afficher (Tete "y" ))\n' +
'(Afficher (Queue "y" ))\n' +
''
});</script>
<h2 id="faire-tant-que"><a href="#faire-tant-que">: </a>Faire… tant que…</h2>
<p>Les derniers exemples peuvent nous laisser frustrés. Frustrés de devoir
savoir à l’avance combien de valeurs doivent être demandées. Comment faire
si l’utilisateur ne veut pas additionner trois nombres, mais deux ou
quatre ? ou concaténer plus ou moins de trois mots ? <br>
C’est le rôle des instructions <code>Faire... Tant_que...</code> et
<code>Tant_que... Faire...</code>.</p>
<p>Commençons par l’instruction <code>Faire... Tant_que</code> avec un
exemple très simple, mais très important :</p>
<div id="script-faire-tq"></div>
<script>inject_microalg_editor_in('script-faire-tq', {
blockly_only: true,
src:
'(Declarer valeur De_type "nombre")\n' +
'(Affecter_a valeur 3)\n' +
'(Faire\n' +
' (Afficher valeur)\n' +
' (Affecter_a valeur (- valeur 1))\n' +
' Tant_que (=/ valeur 0)\n' +
')\n' +
'(Afficher "Zéro !")\n' +
''
});</script>
<p>Voici comment se déroule ce programme :</p>
<ol>
<li>Les deux instructions qui suivent <code>Faire</code> sont exécutées :<br>
<code>(Afficher valeur)</code> affiche le contenu de <code>valeur</code>,
c’est-à-dire 3 ;<br>
<code>(Affecter_a valeur (- valeur 1))</code> diminue la valeur de
<code>valeur</code> d’une unité (voir
<a href="#script-accu-nombres-ex">cet exemple</a>) et la fait
donc passer à 2.</li>
<li>La condition du <code>Tant_que</code> est évaluée, et pour cette
première fois, elle vaut <code>Vrai</code> (car 2≠0) et donc on
exécute à nouveau les instructions dans le <code>Faire</code>.</li>
<li>Comme lors du premier tour :<br>
<code>(Afficher valeur)</code> affiche le contenu de <code>valeur</code>,
c’est-à-dire maintenant 2 ;<br>
<code>(Affecter_a valeur (- valeur 1))</code> fait passer
<code>valeur</code> à 1.</li>
<li>La condition du <code>Tant_que</code> est évaluée, et lors de ce
deuxième tour, elle vaut encore <code>Vrai</code> (car 1≠0) et donc on
exécute à nouveau les instructions dans le <code>Faire</code>.</li>
<li>Comme lors des deux premiers tours :<br>
<code>(Afficher valeur)</code> affiche le contenu de <code>valeur</code>,
c’est-à-dire maintenant 1 ;<br>
<code>(Affecter_a valeur (- valeur 1))</code> fait passer
<code>valeur</code> à 0.</li>
<li>La condition du <code>Tant_que</code> est évaluée, et lors de ce
tour, elle vaut <code>Faux</code> (valeur de 0≠0). C’est le signal
qui annonce la sortie du <code>Faire... Tant_que...</code>.</li>
<li>La dernière ligne est exécutée.</li>
</ol>
<p>Voici deux exemples plus complets :</p>
<div id="script-accu-nombres-tq"></div>
<script>inject_microalg_editor_in('script-accu-nombres-tq', {
blockly_only: true,
src:
'(Declarer somme valeur De_type "nombre")\n' +
'(Affecter_a somme 0)\n' +
'(Affecter_a valeur 0)\n' +
'(Faire\n' +
' (Afficher "Veuillez taper un nombre SVP, 0 pour arrêter.")\n' +
' (Affecter_a valeur (Nombre (Demander)))\n' +
' (Affecter_a somme (+ somme valeur))\n' +
' Tant_que (=/ valeur 0)\n' +
')\n' +
'(Afficher "La somme des nombres vaut :")\n' +
'(Afficher somme)\n' +
''
});</script>
<p>Idem en accumulant du texte (en ajoutant au passage des espaces) :</p>
<div id="script-accu-textes-tq"></div>
<script>inject_microalg_editor_in('script-accu-textes-tq', {
blockly_only: true,
src:
'(Declarer mots mot De_type "texte")\n' +
'(Affecter_a mots "")\n' +
'(Affecter_a mot "")\n' +
'(Faire\n' +
' (Afficher "Veuillez taper un mot SVP, STOP pour arrêter.")\n' +
' (Affecter_a mot (Demander))\n' +
' (Affecter_a mots (Concatener mots " " mot))\n' +
' Tant_que (=/ mot "STOP")\n' +
')\n' +
'(Afficher "Vous avez tapé :")\n' +
'(Afficher mots)\n' +
''
});</script>
<p>Dans ce dernier programme, il y a au moins un bug. Quel est ce bug et
comment le faire disparaître ?</p>
<h2 id="tant-que-faire"><a href="#tant-que-faire">: </a>Tant que… faire…</h2>
<p>Parfois, on veut que la condition soit testée avant même que la première
action ne se réalise. Dans ce cas, on peut utiliser <code>Faire</code> et
<code>Tant_que</code>, mais dans l’autre sens : d’abord
<code>Tant_que</code>, et ensuite <code>Faire</code>.</p>
<p>C’est le cas par exemple si l’on veut répéter une action un certain
nombre de fois. Ainsi l’utilisateur peut, s’il le souhaite, répéter
l’action zéro fois, ce qui n’était pas possible avec `Faire`. Essayez le
programme suivant trois fois, en répondant 2, puis 1, puis 0 :</p>
<div id="script-tq-affichage"></div>
<script>inject_microalg_editor_in('script-tq-affichage', {
blockly_only: true,
src:
'(Declarer repetitions De_type "nombre")\n' +
'(Affecter_a repetitions)\n' +
'(Afficher "Combien de fois voulez-vous afficher « Bonjour ! » ?")\n' +
'(Affecter_a repetitions (Nombre (Demander)))\n' +
'(Tant_que (=/ repetitions 0)\n' +
' Faire\n' +
' (Afficher "Bonjour !")\n' +
' (Affecter_a repetitions (- repetitions 1))\n' +
')\n' +
''
});</script>
<h2 id="construction-affichage"><a href="#construction-affichage">: </a>Construction et affichage de listes</h2>
<p>Pour construire une liste, on utilise la commande <code>Liste</code>.
<p>Il est possible de changer la façon dont les éléments s’emboîtent. Par
défaut, les entrées sont « en ligne », mais elles peuvent être « externes »
(vous pouvez essayer tout de suite en cliquant droit sur le bloc
<code>Liste</code> puis en choisissant <code>Entrées externes</code>).
</p>
<div id="script-afficher1"></div>
<script>inject_microalg_editor_in('script-afficher1', {
blockly_only: true,
src:
'(Afficher (Liste 1 3 5 7 9 11))\n' +
'(Afficher (Liste "banane" "pomme" "fraise"))\n' +
'(Afficher (Liste Vrai Faux Faux Faux Vrai))\n' +
''
});</script>
<p>Quelques cas particuliers :</p>
<div id="script-afficher2"></div>
<script>inject_microalg_editor_in('script-afficher2', {
blockly_only: true,
src:
'(!!! "La liste vide.")\n' +
'(Afficher (Liste))\n' +
'(!!! "Une liste à un seul élément.")\n' +
'(Afficher (Liste "Je suis le seul élément."))\n' +
'(!!! "Une liste de listes.")\n' +
'(Afficher (Liste (Liste 1 3 5) (Liste 2 4 6) (Liste 3 5 7)))\n' +
'(!!! "Une liste hétérogène (contenant des valeurs de types différents).")\n' +
'(Afficher (Liste Vrai "avantage" 42))\n' +
''
});</script>
<p>Attention, contrairement aux listes, les <em>tableaux</em> doivent
contenir des valeurs homogènes.</p>
<h2 id="structure"><a href="#structure">: </a>Listes : structure et lien avec le texte</h2>
<p>La <em>liste</em> est une des
<a href="http://fr.wikipedia.org/wiki/Structure_de_donn%C3%A9es" class="wp">
structures de données</a> les plus simples. Elle est <em>linéaire</em>, un
peu comme des perles sur un fil et est très semblable à une chaîne de
caractères (où chaque maillon est un caractère).</p>
<p>Comme les chaînes de caractères (ce qu’on appelle ici parfois le
<em>texte</em> en MicroAlg), les listes sont numérotées à partir de 1 et
peuvent être passées aux commandes
<code>Longueur</code>,
<code>Concatener</code>,
<code>Nieme</code>,
<code>Nieme@</code>,
<code>Tete</code> et <code>Queue</code>.</p>
<p>Voici quelques exemples utilisant la commande <code>Longueur</code>. Vous
noterez que :</p>
<ul>
<li>des valeurs de n’importe type peuvent être « rangées » dans une liste ;</li>
<li>les valeurs peuvent être de types différents ;
<li>une liste peut contenir d’autres listes !</li>
</ul>
<div id="script-cmds-longueur"></div>
<script>inject_microalg_editor_in('script-cmds-longueur', {
blockly_only: true,
src:
'(Afficher (Longueur (Liste 1 3 5 7 9 11)))\n' +
'(Afficher (Longueur (Liste "banane" "pomme" "fraise")))\n' +
'(Afficher (Longueur (Liste Vrai Faux Faux Faux Vrai)))\n' +
'(Afficher (Longueur (Liste)))\n' +
'(Afficher (Longueur (Liste "Je suis le seul élément.")))\n' +
'(Afficher (Longueur (Liste Vrai "avantage" 42)))\n' +
'(Afficher (Longueur (Liste (Liste 2 4 6) (Liste 3 5 7))))\n' +
''
});</script>
<p>Voici quelques exemples utilisant la commande <code>Concatener</code> :</p>
<div id="script-cmds-concatener"></div>
<script>inject_microalg_editor_in('script-cmds-concatener', {
blockly_only: true,
src:
'(Afficher (Concatener (Liste 1 3 5) (Liste 7 9 11)))\n' +
'(Afficher (Concatener (Liste "s") (Liste "a" "l") (Liste "u" "t")))\n' +
'(Afficher (Concatener (Liste "Je suis le seul élément.")))\n' +
'(Afficher (Concatener (Liste 1 3 5) (Liste)))\n' +
'(Afficher (Concatener (Liste 1 3 5) (Liste) (Liste)))\n' +
'(Afficher (Concatener (Liste) (Liste 1 3 5)))\n' +
'(Afficher (Concatener (Liste) (Liste 1 3 5) (Liste)))\n' +
'(Afficher (Concatener (Liste)))\n' +
''
});</script>
<p>Attention, si on ne lui passe pas d’argument, la commande
<code>Concatener</code> retourne plutôt un texte vide qu’une liste vide :</p>
<div id="script-concatener-sans-arg"></div>
<script>inject_microalg_editor_in('script-concatener-sans-arg', {
blockly_only: true,
src:
'(Afficher "Avant.")\n' +
'(Afficher (Concatener))\n' +
'(Afficher "Après.")\n' +
''
});</script>
<p><strong>Rappel</strong> : <code>Nieme</code> se prononce
« énième » et permet d’obtenir un élément dans une liste en donnant une
position.</p>
<div id="script-cmds-nieme"></div>
<script>inject_microalg_editor_in('script-cmds-nieme', {
blockly_only: true,
src:
'(Afficher (Nieme (Liste 1 3 5 7 9 11) 3))\n' +
'(Afficher (Nieme (Liste "banane" "pomme" "fraise") 3))\n' +
'(Afficher (Nieme (Liste Vrai Faux Faux Faux Vrai) 1))\n' +
'(Afficher (Nieme (Liste (Liste 2 4 6) (Liste 3 5 7)) 2))\n' +
'(Afficher (Nieme (Nieme (Liste (Liste 2 4 6) (Liste 3 5 7)) 2) 3))\n' +
''
});</script>
<p><strong>Rappel</strong> : <code>Nieme@</code> se prononce
« énième aléatoire » (ou <em>pseudo</em>-aléatoire), n’a pas besoin de
position et tire un élément au hasard dans la liste.</p>
<div id="script-cmds-nieme-aleatoire"></div>
<script>inject_microalg_editor_in('script-cmds-nieme-aleatoire', {
blockly_only: true,
src:
'(Afficher (Nieme@ (Liste 1 3 5 7 9 11)))\n' +
'(Afficher (Nieme@ (Liste "banane" "pomme" "fraise")))\n' +
'(Afficher (Nieme@ (Liste Vrai Faux Faux Faux Vrai)))\n' +
'(Afficher (Nieme@ (Liste (Liste 2 4 6) (Liste 3 5 7))))\n' +
'(Afficher (Nieme@ (Nieme@ (Liste (Liste 2 4 6) (Liste 3 5 7)))))\n' +
''
});</script>
<h2 id="parcours-lecture"><a href="#parcours-lecture">: </a>Parcours de listes</h2>
<p>Dans certains langages, il existe les instructions <code>Pour</code> ou
<code>Pour_chaque</code>, mais pas avec MicroAlg. Avec MicroAlg, le parcours
d’une liste se fera « à la main » avec un compteur dans un
<code>Tant_que</code>, <code>Nieme</code> étant appelée avec ce compteur
comme deuxième argument.</p>
<p>Dans l’exemple suivant, le compteur est la variable <code>index</code>.</p>
<div id="script-parcours"></div>
<script>inject_microalg_editor_in('script-parcours', {
blockly_only: true,
src:
'(Declarer index De_type "nombre")\n' +
'(Affecter_a index 1)\n' +
'(Tant_que (<= index 3)\n' +
' Faire\n' +
' (Afficher (Nieme (Liste "banane" "pomme" "fraise") index))\n' +
' (Affecter_a index (+ index 1))\n' +
')\n' +
''
});</script>
<p>Pourrez-vous modifier le programme précédent pour parcourir la liste
à l’envers ?</p>
<h2 id="type-affectation"><a href="#type-affectation">: </a>Listes : Type et affectation</h2>
<p>Une liste peut être stockée dans une variable. Le type correspondant est
<code>"liste"</code>, quel que soit le type des valeurs contenues dans la
liste, comme on peut le voir ci-dessous :</p>
<div id="script-type-liste"></div>
<script>inject_microalg_editor_in('script-type-liste', {
blockly_only: true,
src:
'(Afficher (Type (Liste 1 3 5 7 9 11)))\n' +
'(Afficher (Type (Liste "banane" "pomme" "fraise")))\n' +
'(Afficher (Type (Liste Vrai Faux Faux Faux Vrai)))\n' +
'(Afficher (Type (Liste)))\n' +
''
});</script>
<p>Affecter une liste à une variable est indispensable pour un parcours de
liste dont on ne connaît pas à l’avance la longueur.</p>
<p>Dans l’exemple suivant, vous pourrez changer la première liste comme bon
vous semble, le parcours se fera toujours du premier élément jusqu’au
dernier. Comment est-ce possible ? Grâce à quelle instruction ?</p>
<div id="script-parcours-affectation"></div>
<script>inject_microalg_editor_in('script-parcours-affectation', {
blockly_only: true,
src:
'(Declarer ma_liste De_type "liste")\n' +
'(Affecter_a ma_liste (Liste 1 4 9 16 25))\n' +
'(Declarer index De_type "nombre")\n' +
'(Affecter_a index 1)\n' +
'(Tant_que (<= index (Longueur ma_liste))\n' +
' Faire\n' +
' (Afficher (Nieme ma_liste index))\n' +
' (Affecter_a index (+ index 1))\n' +
')\n' +
''
});</script>
<p>Saurez-vous parcourir la liste à l’envers ?</p>
<h2 id="taper-du-code"><a href="#taper-du-code">: </a>Taper du code</h2>
<p>Bouger des blocs à la souris, c’est bien. Mais taper son code soi-même,
c’est mieux. Voici un espace de travail qui vous permet de voir à quoi
ressemble MicroAlg sans les blocs. Observez le code (juste en dessous) au
fur et à mesure que vous bougez les blocs.</p>
<div id="script-taper-du-code"></div>
<script>inject_microalg_editor_in('script-taper-du-code', {
blockly: true,
src:
'(Afficher (Concatener\n' +
' "Un de plus : "\n' +
' (Texte (+\n' +
' 1\n' +
' (Nombre (Demander))\n' +
' )\n' +
' )\n' +
'))'
});</script>
<div id="abandonner-blocs"></div>
<p>Ce que vous allez perdre en abandonnant les blocs :</p>
<ul>
<li><strong>de l’assurance</strong> : au début vous serez un peu perdues
car vous ne serez pas sûres de l’orthographe des commandes,
de l’ordre dans lequel les disposer, des parenthèses… ;
</li>
<li><strong>de la vitesse</strong> : tant que vous ne saurez pas taper
vite, taper du code vous semblera très long, il faut donc
apprendre à taper !!!
</li>
</ul>
<p>Ce que vous allez gagner en abandonnant les blocs :</p>
<ul>
<li><strong>de l’assurance</strong> : vous serez tellement heureuse quand
vous aurez franchi ce cap, que vous y prendrez goût et ne reviendrez
jamais aux blocs ;
</li>
<li><strong>de la vitesse</strong> : comme vous allez apprendre à taper,
peut-être même en <a href="http://bepo.fr">Bépo</a>, vous serez bien
plus rapide en laissant la souris tranquille (et votre corps vous
remerciera) ;
</li>
<li><strong>de la souplesse</strong> : vous pourrez présenter votre
code comme il vous plaira, passer à la ligne au meilleur moment
pour transformer votre programme en œuvre d’art. Finie la peinture
par numéros, à vous les pinceaux !!!
</li>
<li><strong>des neurones</strong> : l’effort fourni vous permettra
de devenir mentalement plus solide ;
</li>
<li><strong>des fichiers</strong> : les blocs sont pour l’instant
réservés au travail sur navigateur. Passer au code vous permettra
<a href="https://github.com/Microalg/Microalg/blob/latest/INSTALL.md">d’installer MicroAlg</a>
sur votre machine et de travailler avec des fichiers ;
</li>
</ul>
<p>Quand vous passerez au code, le travail avec les blocs ne doit pas être
oublié. La forme des pièces indique :</p>
<ul>
<li>si l’instruction peut être utilisée sans être imbriquée dans une
autre (pas d’attache sortant à gauche, mais un creux en haut) ;</li>
<li>si elle retourne une valeur (attache sortant à gauche) ;</li>
<li>si elle a besoin d’arguments (creux à droite) ;</li>
<li>et si oui, de combien ;</li>
<li>…</li>
</ul>
<h2 id="fin">Fin</h2>
<p>Ce tutoriel est en cours de rédaction (tous les blocs ne sont pas codés :
appel à contribution !).</p>
<p>Il est temps de toutes façons de lacher la souris et de taper
directement du code ! Pour cela, voir les autres tutoriels.</p>
<p>Si vous préférez <strong>ne pas utiliser votre souris</strong> et
<strong>taper le code</strong> vous-même, vous pouvez plutôt essayer :</p>
<ul>
<li>
<a href="tuto.html">le tutoriel officiel</a>, riche en explications,
<strong>pour les débutants</strong> ;
</li>
<li>
<a href="tuto_rapide.html">le tutoriel rapide</a>, réservé aux
personnes <strong>connaissant déjà un langage</strong> de
programmation.
</li>
</ul>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<script type="text/javascript" src="web/tabIndent.js"></script>
<script>
tabIndent.config.tab = ' ';
tabIndent.renderAll();
</script>
<script>
$().showUp('.navbar', {
upClass: 'navbar-show',
downClass: 'navbar-hide'
});
</script>
</body>
</html>