MicroAlg - Tutoriel

Commencer tout de suite, sans lire l’introduction.

Aller directement à : Affichage, Commentaires, Texte et concaténation, Parenthèses, Répéter, Nombres pseudo-aléatoires, Demander à l’utilisateur, Calculs avec des nombres, Calculs avec des nombres demandés à l’utilisateur, Booléens, Si, Variables, Affectation circulaire, Opérations logiques, Manipulation de texte, Faire… tant que…, Tant que… faire…, Construction et affichage de listes, Listes : structure et lien avec le texte, Parcours de listes, Listes : type et affectation, Définir ses commandes, Exemples et tests, Algorithmes de parcours de listes, Contact.

Les autres tutoriels

Si vous débutez en algorithmique ou en programmation, il est fortement conseillé de travailler en bougeant des blocs comme un puzzle. Utilisez cette page.

Si vous pensez que seulement des exemples et des notes très brèves peuvent vous suffire, utilisez cette page.

Qu’est-ce ?

Cette page est un tutoriel pour MicroAlg.

Le tutoriel est assez long car il couvre tout le langage. Patience ! Peut-être faudra-t-il le faire en plusieurs fois !

Au cours de ce tutoriel, on vous proposera des petits programmes à exécuter directement dans le navigateur. N’hésitez pas à les modifier afin d’être sûre de comprendre le principe (si possible une modification rigolote).

Avant de les exécuter, essayez de deviner ce qu’ils vont faire.

Contact

Si jamais cette page ne réagit pas comme vous l’attendiez, si vous trouvez une faute d’orthographe, ou si vous avez envie de contribuer avec une idée lumineuse, merci de (au choix) :

Affichage

Pourquoi ne pas commencer tout de suite !

Après avoir cliqué sur Exécuter, un message de bienvenue devrait s’être affiché dans la barre un peu arrondie ci-dessus (sinon, suivre les instructions de cette section).

Dans toute la suite, vous pourrez modifier les programmes pour tester des idées ou répondre aux questions. Essayez tout de suite avec le programme ci-dessus ! Notez que vous pouvez revenir à la version originale grâce à Control+Z ou en rechargeant la page.

Remarquez bien la forme de ce premier programme. Il contient une seule instruction, qui se décompose ainsi :

  1. une parenthèse ouvrante, sur fond rouge ;
  2. une commande, ici la commande Afficher ;
  3. d’éventuels arguments, ici le texte "Bonjour tout le monde !" ;
  4. une parenthèse fermante, sur fond rouge aussi.

La parenthèse ouvrante marque le début d’une instruction, comme une majuscule marque le début d’une phrase. La parenthèse fermante marque la fin de l’instruction, comme le fait un point pour marquer la fin d’une phrase.

Tous les programmes de MicroAlg seront toujours une suite d’instructions qui seront toujours de la même forme. Toujours.

Commentaires

Pour expliquer certains passages délicats d’un programme, on peut écrire des instructions qui n’ont aucun effet. C’est le rôle de la commande !!!. Il faut, comme pour la commande Afficher, mettre le message entre guillemets.

Texte et concaténation

Dans un des exemples précédents, que nous rappelons ci-dessous, nous avons affiché du texte. Nous dirons que nous avons passé du texte en paramètre à la commande Afficher.

Mieux : ce que l’on appelle ici « texte » est parfois appelé « chaîne de caractères ». On doit le mettre entre guillemets.

Supposons maintenant que l’on veuille afficher deux textes.

La commande `Afficher` ne prend qu’un paramètre. Le programme suivant génère une erreur.

L’idée d’utiliser deux instructions est bonne, mais avec cette technique, il est impossible d’afficher deux textes différents sans passer à la ligne :

Pour « concaténer » deux textes, c’est-à-dire les mettre bout-à-bout, on utilise la commande Concatener. Dans l’exemple suivant, on affiche la concaténation de deux textes :

Rappelez-vous, vous pouvez modifier les programmes de cette page pour éventuellement les améliorer !

Notez les parenthèses qui s’emboîtent. L’emboîtement des parenthèses est la base de MicroAlg, et plus généralement des langages de type Lisp (noter aussi le nombre de traductions de cette page Wikipedia !).

Même si en français on dit que le programme « affiche la concaténation de deux textes », le programme s’exécute depuis l’intérieur vers l’extérieur : le programme concatène d’abord, et affiche ensuite.

Attention, les guillemets utilisés ici : « " » servent aussi bien à ouvrir qu’à fermer une chaîne de caractères. On voit sur ce dernier exemple que c’est moins clair que des parenthèses, mais il faudra faire avec.

Une solution pour y voir clair : organiser son code sur différentes lignes :

Pour finir la partie « concaténation », notons qu’il n’y a pas de limite au nombre de textes à concaténer :

Les parenthèses

Même si les parenthèses indiquent déjà assez clairement la structure du programme, il est bien pratique de pouvoir savoir quelle parenthèse fermante correspond à une parenthèse ouvrante (et inversement). C’est le but de la coloration des parenthèses (la parenthèse à droite du curseur et celle qui lui correspond sont en gris).

Si jamais les parenthèses ne sont pas équilibrées, les parenthèses en trop seront affichées en rouge vif. Essayez d’en ajouter ou d’en supprimer dans le « programme » précédent !

Vous verrez que dans les programmes suivants, certaines lignes sont décalées vers la droite. C’est ce qu’on appelle « l’indentation ». Si elle est respectée :

De plus, on ne trouvera jamais deux parenthèses ouvrantes de suite.

Dans le dernier exemple de la section précédente, nous avons affiché la concaténation de trois textes.

Comment aurions-nous pu faire la même chose si la commande Concatener n’acceptait que deux paramètres ?

Il aurait suffit :

  1. de prendre les deux premiers (ou les deux derniers, puisque la concaténation est associative),
  2. de les concaténer,
  3. puis de concaténer le résultat au troisième fragment de texte.

Si on commence par la gauche :

Et si on commence par la droite :

Si vous trouvez que l’on y comprend rien, c’est normal (quoiqu’avec un peu d’habitude…).

Pour y voir plus clair, il suffit encore passer à la ligne à des endroits judicieux. Pour le côté gauche :

Et pour le côté droit :

Notez que, comme en maths, les commandes qui sont « les plus à l’intérieur des parenthèses » seront exécutées en premier, en commençant par la gauche (nous allons le vérifier plus loin).

Répéter

Un algorithme décrit souvent (mais pas toujours) un travail répétitif que l’on veut faire faire à un ordinateur. Sans surprise, ce programme affiche trois fois la même chose :

À vous de tester à nouveau ce programme en changeant le nombre de répétitions et le texte à afficher.

Question : comment faire pour afficher ce texte avec le moins d’instructions possible ? Huit parenthèses devraient suffire.

Bonjour,
ça va ?
ça va ?
ça va ?
ça va ?
Bonjour,
ça va ?
ça va ?
ça va ?
ça va ?
Bonjour,
ça va ?
ça va ?
ça va ?
ça va ?

Nombres pseudo-aléatoires

Il est possible d’obtenir un nombre entier pseudo-aléatoire grâce à la commande Entier@. Il faut lui passer les valeurs minimale et maximale possibles. Lancer plusieurs fois de suite le programme suivant :

Comment changer ce programme pour simuler le lancer d’un dé à six faces ?

Utilisation avancée : si vous n’avez pas besoin de reproductibilité (le fait de pouvoir obtenir à nouveau certaines séquences de tirages), vous pouvez passer directement à la section suivante).

Il est possible de contrôler les tirages de deux façons : avec la commande Initialiser@ et avec la variable spéciale sequence_tirages@.

La commande Initialiser@ permet de contrôler l’état initial du générateur de nombres pseudo-aléatoires. Grâce à elle, un même programme donnera toujours les mêmes tirages. Ce n’est bien sûr pas souhaitable pour un jeu de hasard comme un jeu de cartes. Néanmoins, pour certaines applications artistiques ou scientifiques, cette reproductibilité peut être intéressante. On peut par exemple vouloir générer un même labyrinthe pour tous les joueurs, on peut vouloir vérifier si un programme est correct en comparant avec un autre que l’on sait être correct…

Voici par exemple un programme qui affichera toujours les mêmes cinq tirages (1984, 1932, 1967, 2000 et 1957) :

Celui-ci affichera toujours 1969, 1921, 1987, 1941 et 1950 :

Il est même possible de fournir une séquence de nombres entiers qui sera utilisée pour les tirages, en boucle. Les commandes Affecter_a et Liste seront vues plus loin.

Demander à l’utilisateur

Plutôt que de demander une valeur pseudo-aléatoire à l’ordinateur, il est possible de demander une valeur à l’utilisateur :

Mais si on ne fait rien du résultat de cette commande, rien ne se passe bien sûr. On peut par exemple afficher le résultat de Demander.

L’utilisation de la commande Demander peut sembler étrange car elle n’a pas de paramètre. Il faut taper : (Demander). Mais en fait, il n’y a pas de raison pour qu’elle en ait car l’utilisateur peut taper ce qu’il veut, sans limite. La saisie sera simplement validée par la touche Entrée. Ensuite, c’est comme si ce qu’il allait taper allait remplacer (Demander).

Un premier programme interactif ! En combinant les commandes Demander, Concatener et Afficher, nous allons pouvoir coder un premier programme (presque) intéressant : les salutations.

Avant de l’exécuter, essayez de deviner ce que le programme va faire.

Mieux : les présentations !

Ici, nous effectuons deux affichages successifs. Même s’il y a une demande dans le deuxième affichage, on peut dire que le programme est de la forme :

(Afficher ...)
(Afficher ...)

Comme promis, une vérification que, pour des instructions situées au même niveau, l’exécution se fait bien de la gauche vers la droite ou du haut vers le bas :

Calculs avec des nombres

MicroAlg sait effectuer des calculs, mais il faut les rédiger correctement. Pour chaque exemple ci-dessous, essayer de deviner ce que va afficher MicroAlg, puis vérifier en exécutant le code avec Ctrl + Entrée.

Voici d’autres exemples avec peut-être d’autres opérations. Essayez de deviner ce que va afficher MicroAlg, puis vérifiez en cliquant sur Exécuter. Vous pouvez utiliser un crayon et du papier ou une calculatrice si votre calcul mental n’est pas encore solide.

Remarque : La touche TAB (à gauche du A) permet de passer de zone de code en zone de code, en passant aussi sur les liens. En appuyant deux fois dessus, vous arrivez à la prochaine zone. Pratique, pas besoin de toucher la souris.

Pour calculer l’opposé d’un nombre, on peut toujours de retirer ce nombre à 0 ou le multiplier par -1, mais on peut aussi ne passer qu’un paramètre à la commande -.

Un exercice pour finir : écrire un programme qui tire au hasard une année qui a commencé un siècle entre le dixième et le vingt-et-unième siècle.

Pour approfondir la mise en place des calculs, voir le site expressions.club.

Calculs avec des nombres demandés à l’utilisateur

La commande Demander renvoie du texte, celui tapé par l’utilisateur. Même s’il n’est constitué que de chiffres, MicroAlg le considère comme étant du texte.

Le problème ici est que les opérations +, -, * et / ne travaillent qu'avec des nombres et non avec du texte. En voici la preuve (le programme génère une erreur) :

Ainsi, le programme suivant ne peut pas fonctionner, même en répondant par exemple « 1 » pour calculer « 1 + 1 » :

C'est la première fois que dans ce tutoriel nous évoquons la distinction entre 1 et "1". C’est la notion de type. On dira que :

Nous verrons d'autres types plus loin. Pour l'instant, nous avons les nouvelles commandes :

Quelques exemples avec Type :

Un exemple avec Demander :

Pour demander un nombre avec lequel faire un calcul, il faut donc utiliser une combinaison de Demander et de Nombre. En reprenant le premier exemple :

Plus de détails sur les différentes façons de « demander » sont disponibles sur cette page de la galerie.

Plus tard, grâce à ce paragraphe, vous pourrez vous-même créer une commande qui sera un raccourci pour cette combinaison de Nombre et de Demander : DemanderNbre.

Pour finir cette section en beauté, voici un programme qui réutilise tout ce que l’on a appris jusqu’ici. Pourrez-vous deviner ce qu’il va afficher ?

Rappel : l’exécution se fait de l’intérieur vers l’extérieur. Voici donc ce que fait ce petit programme, dans l’ordre d’exécution :

  1. demander une valeur à l’utilisateur,
  2. convertir le texte reçu en nombre,
  3. ajouter 1,
  4. convertir le résultat en texte,
  5. le concaténer avec le début de la phrase.

Pour résumer en une phrase : « le programme affiche la concaténation de "Un de plus : " avec le texte correspondant à la somme de 1 avec le nombre que l’utilisateur a tapé ».

Calculs avec des booléens

Dans certaines situations, comme les jeux, on peut avoir besoin de comparer des valeurs. Par exemple, on peut vouloir tester :

Il y a donc dans MicroAlg des commandes qui retournent des valeurs spéciales : Vrai ou Faux, pour répondre à ces questions. Ces valeurs Vrai et Faux sont d’un type nouveau. Ce ne sont ni des nombres ni du texte, mais des booléens (de George Boole). Un booléen ne peut avoir qu’une de ces deux valeurs Vrai ou Faux, contrairement aux nombres et au textes qui peuvent prendre (quasiment) une infinité de valeurs différentes.

Les commandes qui retournent un booléen sont appelées des prédicats. En voici quelques-uns :

= et =/ peuvent comparer des booléens. Essayez de deviner ce que va afficher le programme suivant :

Concernant les nombres, pas de surprise :

Pas de surprise non plus pour comparer du texte :

À vous maintenant d’explorer les comparaisons entre nombres ! Il y a quatre commandes à tester : <, <=, > et >=, mais aussi différentes combinaisons de nombres à essayer.

Si

Les booléens servent surtout à décider quelle instruction exécuter plutôt qu’une autre.

Par exemple, lorsque l’on discute avec quelqu’un, on peut commencer par : « Salut, ça va ? ».
Si la personne répond « oui » (qui correspondrait à Vrai), alors on lui répond « Tant mieux ! ».
Sinon (ce qui correspondrait à Faux), on lui répond « Ah, qu’y a-t-il ? ».

Avec MicroAlg, pour programmer ce genre de situation, on utilisera la commande Si.

Attention, dans l’exemple suivant, seul le mot « oui » en minuscule est reconnu comme une réponse positive.

Le code ci-dessus peut se lire :

On peut donc résumer la commande Si ainsi :
(Si booléen Alors commande-si-vrai Sinon commande-si-faux)

Ou en arrangeant le code sur plusieurs lignes :

(Si booléen
 Alors
    commande-si-vrai
 Sinon
    commande-si-faux
)

Si on veut détailler, la commande Si possède cinq paramètres :

Cette commande agit comme un aiguillage pour les rails des trains. En actionnant l’aiguillage, on décide sur quelle voie va rouler le train.

L’analogie de l’arbre est aussi possible : le déroulement du programme peut suivre une des deux branches, la branche du « alors » ou la branche du « sinon ».

Voici d’autres exemples :

Après avoir vu les bases de la commande Si, voyons quelques variantes :

Si sans « sinon »

Il est possible d’ommettre la commande correspondant au « sinon » :

Si avec plusieurs commandes

On a parfois besoin d’exécuter plusieurs instructions dans une même branche. Il suffit de bien placer le mot-clef Sinon (si besoin) et la parenthèse finale.

Avec plusieurs commandes, la commande Si est finalement de la forme :
(Si booléen Alors commandes-si-vrai Sinon commandes-si-faux)

Ou en arrangeant le code sur plusieurs lignes :

(Si booléen
 Alors
    commande-si-vrai
    commande-si-vrai
    ...
 Sinon
    commande-si-faux
    commande-si-faux
    ...
)

Si(s) emboîtés

Un arbre a parfois plus de deux branches !

Qu’affiche le programme suivant ? Comment lui faire afficher les autres textes du programme en ne changeant que la valeur des booléens ?

Voici une application concrète d’une structure avec des Si emboîtés (Declarer et Affecter_a seront vues en détail un peu plus loin) :

Si avec des valeurs uniquement

Comme une valeur peut être considérée comme une instruction (et inversement), on peut utiliser Si ainsi :

Attention, si le booléen est Faux et s’il n’y a pas de valeur correspondant au « sinon », la commande Si retournera Rien, qui est un symbole spécial qui représente une absence de valeur.

Variables

On a parfois besoin de stocker le résultat de (Demander) 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.

Cela peut être :

Pour pouvoir utiliser une variable avec MicroAlg, il faut :

  1. tout d’abord la déclarer, c’est-à-dire annoncer qu’on veut l’utiliser et qu’elle aura un certain type, en utilisant la commande Declarer,
  2. lui affecter une valeur, peut-être plusieurs fois au cours du programme, en utilisant la commande Affecter_a,
  3. accéder à sa valeur, simplement en donnant son nom dans une instruction.

Voici quelques exemples :

Exercice : 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.

Attention, les commandes Declarer et Affecter_a effectuent des vérifications :

Astuce : Il est possible de déclarer plusieurs variables en une seule instruction :
(Declarer var1 var2 var3 ... De_type "le_type")

Affectation circulaire

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’accumuler des valeurs, qu’elles soient textuelles, numériques ou d’un autre type.

Dans (Affecter_a var (Calcul var)), il faut bien comprendre que :

  1. le second var désigne la valeur qui est stockée dans la variable, qui sera envoyée à Calcul ;
  2. le premier var désigne le nom de la variable à mettre à jour avec le résultat de (Calcul var).

Nous allons donner deux exemples.

Dans le premier, on accumule des nombres avec une instruction de la forme :
(Affecter_a valeur (+ valeur valeur_a_ajouter))

Ce qui signifie : « valeur prend pour nouvelle valeur le résultat du calcul valeur + valeur_a_ajouter ».

Dans le second, on accumule du texte avec une instruction de la forme :
(Affecter_a texte (Concatener texte texte_a_ajouter))

Ce qui signifie : « texte prend pour nouvelle valeur la concaténation de texte avec texte_a_ajouter ».

Voici deux programmes plus complets qui utilisent ce principe.

Un où l’on accumule des nombres pour calculer leur somme :

Un où l’on accumule du texte (en ajoutant au passage des espaces) :

Opérations logiques

Voici un programme vu précédemment :

On peut parfois éviter d’emboîter les Si 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.

Essayez d’obtenir le même résultat sans l’instruction Et !

MicroAlg fournit les opérations sur les booléens suivantes :

Manipulation de texte

Un texte, ou chaîne de caractères n’est qu’une liste de lettres.

La commande Longueur retourne le nombre de lettres d’un texte.

Le prédicat Vide? permet d’écrire (Vide? texte) au lieu de (= 0 (Longueur texte)).

La commande Nieme, prononcée « énième », retourne une des lettres du texte, en fonction de l’indice que l’on fournit (deuxième argument).

La commande Nieme@, prononcée « énième aléatoire » (pseudo-aléatoire pour les puristes), retourne une des lettres du texte, prise au hasard. Lancez plusieurs fois de suite le programme suivant :

Nous aurons parfois besoin de couper la tête d’un texte, pour travailler de proche en proche.

Faire… tant que…

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 ?
C’est le rôle des instructions Faire... Tant_que... et Tant_que... Faire....

Commençons par l’instruction Faire... Tant_que avec un exemple très simple, mais très important :

Voici comment se déroule ce programme :

  1. Les deux instructions qui suivent Faire sont exécutées :
    (Afficher valeur) affiche le contenu de valeur, c’est-à-dire 3 ;
    (Affecter_a valeur (- valeur 1)) diminue la valeur de valeur d’une unité (voir cet exemple) et la fait donc passer à 2.
  2. La condition du Tant_que est évaluée, et pour cette première fois, elle vaut Vrai (car 2≠0) et donc on exécute à nouveau les instructions dans le Faire.
  3. Comme lors du premier tour :
    (Afficher valeur) affiche le contenu de valeur, c’est-à-dire maintenant 2 ;
    (Affecter_a valeur (- valeur 1)) fait passer valeur à 1.
  4. La condition du Tant_que est évaluée, et lors de ce deuxième tour, elle vaut encore Vrai (car 1≠0) et donc on exécute à nouveau les instructions dans le Faire.
  5. Comme lors des deux premiers tours :
    (Afficher valeur) affiche le contenu de valeur, c’est-à-dire maintenant 1 ;
    (Affecter_a valeur (- valeur 1)) fait passer valeur à 0.
  6. La condition du Tant_que est évaluée, et lors de ce tour, elle vaut Faux (valeur de 0≠0). C’est le signal qui annonce la sortie du Faire... Tant_que....
  7. La dernière ligne est exécutée.

Voici deux exemples plus complets :

Idem en accumulant du texte (en ajoutant au passage des espaces) :

Dans ce dernier programme, il y a au moins un bug. Quel est ce bug et comment le faire disparaître ?

Tant que… faire…

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 Faire et Tant_que, mais dans l’autre sens : d’abord Tant_que, et ensuite Faire.

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 :

Construction et affichage de listes

Pour construire une liste, on utilise la commande Liste. N’oublions pas que pour qu’une valeur s’affiche, il faut utiliser la commande Afficher !

On remarque que l’affichage d’une liste est identique à la commande qui aurait pu servir à la construire.

Quelques cas particuliers :

Attention, contrairement aux listes, les tableaux doivent contenir des valeurs homogènes.

Listes : structure et lien avec le texte

La liste est une des structures de données les plus simples. Elle est linéaire, 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).

Comme les chaînes de caractères (ce qu’on appelle ici parfois le texte en MicroAlg), les listes sont numérotées à partir de 1 et peuvent être passées aux commandes Longueur, Concatener, Nieme, Nieme@, Tete et Queue.

Voici quelques exemples utilisant la commande Longueur. Vous noterez que :

Voici quelques exemples utilisant la commande Concatener :

Attention, si on ne lui passe pas d’argument, la commande Concatener retourne plutôt un texte vide qu’une liste vide :

Rappel : Nieme se prononce « énième » et permet d’obtenir un élément dans une liste en donnant une position.

Rappel : Nieme@ se prononce « énième aléatoire » (ou pseudo-aléatoire), n’a pas besoin de position et tire un élément au hasard dans la liste.

Parcours de listes

Dans certains langages, il existe les instructions Pour ou Pour_chaque, mais pas avec MicroAlg. Avec MicroAlg, le parcours d’une liste se fera « à la main » avec un compteur dans un Tant_que, Nieme étant appelée avec ce compteur comme deuxième argument.

Dans l’exemple suivant, le compteur est la variable index.

Pourrez-vous modifier le programme précédent pour parcourir la liste à l’envers ?

Listes : Type et affectation

Une liste peut être stockée dans une variable. Le type correspondant est "liste", quel que soit le type des valeurs contenues dans la liste, comme on peut le voir ci-dessous :

Affecter une liste à une variable est indispensable pour un parcours de liste dont on ne connaît pas à l’avance la longueur.

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 ?

Saurez-vous parcourir la liste à l’envers ?

Définir ses commandes

En plus des symboles prédéfinis dans MicroAlg, vous pouvez créer vos propres commandes, grâce à la commande Definir.

Comme d’habitude, modifier le code ci-dessus puis le tester pour bien comprendre la commande Definir.

Attention ! La commande Retourner doit être la dernière de la commande créée car Retourner n’en interrompt pas l’exécution, comme on peut le voir ici :

Voir la documentation pour plus de détails.

Comme promis, voici un moyen de définir une commande qui demande un nombre à l’utilisateur..

À essayer une première fois en tapant un nombre, puis une seconde en tapant une lettre.

Exemples et tests

Supposons que vous veniez de créer une commande. Un bon moyen d’expliquer à quoi elle sert ou comment on l’utilise (en plus d’une jolie phrase d’explication bien sûr), est de donner des exemples d’utilisation.

Ce qu’il faut retenir ici est que :

Les exemples ainsi attribués à une commande peuvent être testés, et ceci pour deux raisons :

  1. vérifier qu’une commande respecte son contrat ;
  2. donner les exemples d’abord, pour implémenter la commande ensuite.

Dans la seconde raison, la personne qui écrit les tests peut être le professeur ou le patron, ou parfois simplement soi-même. C’est ce qu’on appelle le développement dirigé par les tests.

Si rien ne se passe, c’est que tout va bien. Essayez de « casser » exprès les tests pour voir ce qu’il se passe, soit en changeant un exemple, soit en changeant la commande Double.

Sachez pour finir qu’il est possible de « copier » les exemples d’une commande dans une autre. Pour copier les exemples de cmd_1 dans cmd_2, on utilise : (Exemples_de cmd_2 (Exemples_de cmd_1)).

Algorithmes de parcours de listes

Tous les outils sont maintenant entre vos mains pour mettre en place des algorithmes basés sur le simple parcours d’une liste.

À vous de faire passer les tests suivants !

Rappel : l’instruction Retourner n’interrompt pas l’exécution des commandes que vous définissez (voir la documentation ou cet exemple).

Fin

Voilà, c’est fini. Si désormais vous cherchez une information, allez voir directement la documentation.

Si vous avez envie de créer votre propre tutoriel, vous pouvez utiliser la galerie. Pour mettre MicroAlg en place sur votre propre site, voir cette page.

Si vous avez une remarque à faire, ou envie de contribuer, suivre les instructions de cette section.

Bonne continuation !