MicroAlg - Tutoriel par blocs

Cette page est la suite de celle-ci. Impossible de continuer si vous ne l’avez pas lue avant.

Sur cette page, aller directement à : 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, Taper du code, Contact.

Sur la page précédente, aller directement à : Prise en main et affichage, Commentaires, Texte et concaténation, 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.

Contact

En cas de problème, ne pas hésiter à poser une question dans la section Questions/Réponses, ou à envoyer un email au créateur de MicroAlg.

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 utilisant le bloc des variables, dans la catégorie « Valeurs ». Par défaut, le bloc donne la valeur de la variable ma_variable, mais vous pouvez indiquer la variable que vous voulez en cliquant dessus.

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.

Dans le dernier programme, on remarque que le symbole de la multiplication × ressemble à la lettre x. C’est bien le produit de x et de x.

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

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. Nous allons donner deux exemples.

Dans le premier, on accumule des nombres avec une instruction de la forme :
(Affecter_a valeur (Somme 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.

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 Liste puis en choisissant Entrées externes).

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 ?

Taper du code

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.

Ce que vous allez perdre en abandonnant les blocs :

Ce que vous allez gagner en abandonnant les blocs :

Quand vous passerez au code, le travail avec les blocs ne doit pas être oublié. La forme des pièces indique :

Fin

Ce tutoriel est en cours de rédaction (tous les blocs ne sont pas codés : appel à contribution !).

Il est temps de toutes façons de lacher la souris et de taper directement du code ! Pour cela, voir les autres tutoriels.

Si vous préférez ne pas utiliser votre souris et taper le code vous-même, vous pouvez plutôt essayer :