MicroAlg - Tutoriel rapide

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

Pour un tutoriel comportant plus d’explications, utiliser cette page.

Qu’est-ce ?

Ce tutoriel propose 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

Plusieurs possibilités :

Affichage

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

Texte et concaténation

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

Concaténation.

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

Noter 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.

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 !

Si l’indentation 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.

Même si la commande Concatener n’acceptait que deux textes, nous aurions pu en concaténer trois quand même.

Si on commence par la gauche :

Et si on commence par la droite :

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 :

Les commandes qui sont « les plus à l’intérieur des parenthèses » seront exécutées en premier, en commençant par la gauche.

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

Une vérification que l’exécution se fait bien de la gauche vers la droite :

Calculs avec des nombres

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, mais les opérations +, -, * et / ne travaillent qu'avec des nombres. 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 » :

Types :

Commandes relatives aux types :

Quelques exemples avec Type :

Un exemple avec Demander :

Donc pour un calcul avec un nombre demandé :

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

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 ?

Calculs avec des booléens

Un booléen (de George Boole) est une des deux valeurs Vrai ou Faux. Les commandes qui retournent un booléen sont appelées des prédicats. En voici quelques-uns :

= et =/ peuvent bien sûr comparer des booléens.

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

On peut 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
)

Voici un autre exemple :

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

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

Variables

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.

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.

Dans (Affecter_a var (Calcul var)), il faut 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).

Dans ce premier exemple, 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

Manipulation de texte

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

La commande Nieme se prononce « énième ».

La commande Nieme@ se prononce « énième aléatoire » (ou pseudo-aléatoire pour les puristes).

Faire… tant que…

Commençons par un exemple très simple, mais très important :

Voici deux exemples plus complets :

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

Tant que… faire…

Construction et affichage de listes

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

Quelques cas particuliers :

Listes: structure et lien avec le texte

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.

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.

Listes: type et affectation

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

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.

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 :

Exemples et tests

Ce qu’il faut retenir ici est que :

Il est possible de mettre en place du développement dirigé par les tests en utilisant la commande Tester.

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

À 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 !