Cours complet d’initiation à la programmation

Annexe A - Les cartes▲

Présentation▲

Le module Cartes offre une extension du langage Caml afin d'écrire des programmes destinés à un robot manipulateur de cartes.

Le domaine de travail du robot est constitué de tas, numérotés 1,2,3,4, sur lesquels sont empilées des cartes à jouer. Ces cartes ont les couleurs habituelles (♣, ♢, ♡ et ♠) et les valeurs habituelles (par ordre croissant : as, deux, trois…, dix, valet, dame, roi). Les cartes proviennent de plusieurs jeux, il est donc possible de trouver plusieurs exemplaires d'une même carte.

Chacun des quatre tas peut contenir un nombre quelconque de cartes, y compris aucune.

Utilisation du module Cartes▲

Le module Cartes est un module spécifiquement développé à l'université de Lille 1 pour l'enseignement d'InitProg. Ce module n'est donc pas livré avec les distributions d'Objective Caml, et il est nécessaire de l'installer séparément. Nous supposons ici que cette installation est faite.

Pour utiliser ce module, plusieurs possibilités existent :

Depuis un interprète, invoquer la directive #load ;

Sélectionnez

1.
2.
3.
4.

# #load "Cartes.cma" ;;
Chargement des images. Patientez quelques instants.
....................................................
#

En lançant un interprète, ajouter le module sur la ligne de commande ;

Sélectionnez

1.
2.
3.
4.
5.

$ ocaml Cartes.cma
Chargement des images. Patientez quelques instants.
....................................................
       Objective Caml version 3.10.0
#

En lançant l'interprète dédié au module.

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.

$ ocamlcartes
Chargement des images. Patientez quelques instants.
....................................................
       Objective Caml version 3.10.0

Camlcartes
FIL IEEA univ. Lille 1 (2009)
  pour obtenir de l'aide : aide_moi () ;;
#

Dans tous les cas, une fenêtre graphique s'ouvre.

Les noms des différentes variables, fonctions et procédures déclarées dans ce module doivent normalement être préfixés par le nom du module. Par exemple, l'instruction init_tas pour initialiser un tas (cf ci-dessous) doit être invoquée par le nom Cartes.init_tas. Pour se dispenser de préfixer systématiquement tous les noms par celui du module, il suffit d'exécuter la commande

Sélectionnez

1.
2.

# open Cartes;;
#

Ceci accompli, on peut faire référence à tous les éléments déclarés dans le module en utilisant leur nom non préfixé par celui du module.

Sélectionnez

1.
2.

# init_tas (1,"T") ;;
- : unit = ()

Dans toute la suite, nous supposerons que l'instruction open Cartes a été exécutée.

Le langage du module Cartes▲

Description de tas▲

Une fois le module Cartes chargé, la fenêtre graphique montre quatre tas de cartes. Ces tas, numérotés de 1 à 4 de gauche à droite, contiennent des cartes en nombre quelconques choisies au hasard. Les problèmes que nous traiterons nécessitent de pouvoir imposer certaines configurations de l'état de ces quatre tas.

Afin de décrire en début de programme, la configuration initiale des tas de cartes, le module Cartes offre une procédure init_tas(15).

Syntaxe :

Sélectionnez

init_tas(n, s)

où n est le numéro du tas décrit, et s est une chaîne de description du tas.

En Caml, les chaînes sont délimitées par des guillemets « " » (cf chapitre 7Chapitre 7 - Caractères et chaînes de caractères).

La chaîne de description, lue de gauche à droite, indique les cartes d'un tas du bas vers le haut avec les conventions suivantes :

Les lettres T, K, C, P représentent respectivement : ♣, ♢, ♡ et ♠ ;
Si A et B sont des chaînes de description, la chaîne AB est aussi une chaîne de description qui représente les cartes de A surmontées de celles de B ;
Si A et B sont des chaînes de description, la chaîne A + B est aussi une chaîne de description qui représente un choix entre les cartes de A ou celles de B ;
Si A est une chaîne de description, [A] représente la répétition des cartes de A un nombre quelconque (défini de manière aléatoire) de fois (y compris zéro) ;
Les parenthèses sont autorisées pour éviter les ambiguïtés.

Exemple 1 :

init_tas(1,"") déclare le tas numéro 1 vide.
L'instruction init_tas(2,"TCK") décrit le tas numéro 2 contenant de bas en haut un ♣, un ♡ et un ♢.
L'instruction init_tas(3,"T+P") décrit le tas numéro 3 contenant une carte qui est soit un ♣ soit un ♠.
init_tas(4,"[T+P]") décrit le tas numéro 4 contenant un nombre quelconque, non déterminé, de cartes de couleur ♣ ou ♠.
L'instruction init_tas(1,"T+[P]CC") décrit le tas numéro 1 contenant soit une seule carte de couleur ♣, soit un nombre quelconque de ♠ surmontés de deux ♡.
L'instruction init_tas(1,"(T+[P])CC") décrit le tas numéro 1 contenant soit trois cartes ♣ surmontées de deux ♥, soit un nombre quelconque de ♠ surmontés de deux ♡. À noter qu'une autre façon de décrire la même initialisation est d'utiliser la chaîne "TCC + [P]CC".

Une instance possible de l'état des quatre tas après exécutions des instructions numérotées 1, 2, 3 et 5 est donnée par la partie gauche de la figure A.1.

Figure A.1 Transformation des tas par déplacement d'une carte

Remarque : Tout programme de résolution d'un problème sur les cartes doit débuter par une initialisation des quatre tas à l'aide de l'instruction init_tas. Une fois cette initialisation effectuée, cette instruction n'est plus utilisée. Il s'en suit qu'après l'étape d'initialisation, le nombre de cartes globalement présentes sur les quatre tas ne varie pas.

Action▲

La seule action permettant de modifier l'état des tas est le déplacement de la carte située au sommet d'un tas vers le sommet d'un autre tas. Cette action est donnée par un appel à la procédure deplacer_sommet(16) paramétrée par un couple :

Syntaxe :

Sélectionnez

deplacer_sommet(n, p)

où n est le numéro du tas duquel on prend une carte, et p est celui du tas sur lequel on la pose.

Exemple 2 :

L'instruction deplacer_sommet(2,4) a pour effet de déplacer la carte au sommet du tas 2 pour la poser au sommet du tas 4. Appliquée à l'état des tas décrits par la partie gauche de la figure A.1, cette instruction transforme les tas 2 et 4 comme le montre la partie droite.

CU : Il n'est pas permis de déplacer une carte située sur un tas vide. Toute tentative d'action deplacer_sommet(n,p) déclenche l'exception Tas_Vide si le tas n est vide.

Tests sur les tas▲

Certains traitements nécessitent des tests. Pour cela on dispose de fonctions.

Test de vacuité

Pour tester si un tas est vide, on fera appel à la fonction(17)

Syntaxe :

Sélectionnez

tas_vide(n)

qui donne la valeur vrai (true en anglais, et en Caml) si le tas numéro n est vide, faux (false en anglais et en Caml) dans le cas contraire.

On peut faire le test contraire en faisant appel à la fonction

Syntaxe :

Sélectionnez

tas_non_vide(n)

Test sur la couleur

Les quatre couleurs sont décrites dans le module Cartes par les quatre identificateurs (préfixés par le nom du module Cartes) : Cartes.TREFLE, Cartes.CARREAU, Cartes.COEUR, Cartes.PIQUE.

Si la commande open Cartes a été exécutée, on peut se dispenser de préfixer les noms des couleurs dans l'écriture des programmes.

Il est important de désigner les couleurs par ces identificateurs en lettres MAJUSCULES.

Il est possible de connaître la couleur au sommet d'un tas en faisant appel à la fonction(18)

Syntaxe :

Sélectionnez

couleur_sommet(n)

qui donne la couleur de la carte située au sommet du tas numéro n.

Exemple 3 :

Sélectionnez

if couleur_sommet(2)=PIQUE then ...

CU : Il est normalement dénué de sens de tester la couleur de la carte située au sommet d'un tas vide. Toute tentative d'appel à couleur_sommet(n) déclenche l'exception Tas_Vide si le tas n est vide.

Quatre autres fonctions(19) permettent aussi de tester la couleur du sommet d'un tas

Syntaxe :

Sélectionnez

1.
2.
3.
4.

sommet_trefle(n)
sommet_carreau(n)
sommet_coeur(n)
sommet_pique(n)

qui donnent la valeur vrai si le sommet du tas n est un ♣ (♢, ♡, ♠) et faux dans le cas contraire.

Elles sont soumises à la même contrainte d'utilisation que la fonction couleur_sommet, et déclenchent la même exception en cas de non-respect de cette contrainte.

Comparaison des valeurs▲

Une fonction permet de comparer les valeurs des cartes au sommet de deux tas :

Syntaxe :

Sélectionnez

superieur(n, p)

qui donne la valeur vrai si la carte au sommet du tas numéro n a une valeur supérieure ou égale à celle du tas numéro p, et la valeur faux dans le cas contraire.

CU : On ne peut comparer les cartes situées au sommet de deux tas que s'ils ne sont pas vides. Tout appel à superieur(n, p) déclenche l'exception Tas_Vide si l'un des tas n ou p est vide.

Contrôle de l'affichage▲

Modes d'affichage

À l'exécution, l'affichage peut se faire de trois façons :

Mode graphique : Dans ce mode, on visualise l'évolution des tas de cartes dans une fenêtre graphique. C'est le mode par défaut ;

Mode texte : Dans ce mode, on visualise l'évolution des tas de cartes dans le terminal où s'exécute le programme. Voici un exemple d'affichage textuel produit par l'exécution d'une instruction :

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.

# deplacer_sommet(4,1) ;;
deplacer_sommet(4,1);;
(*                            ._____.  *)
(*                            | 3P  |  *)
(*                            ._____.  *)
(*                            | 10P |  *)
(*                            ._____.  *)
(*                            | vP  |  *)
(*                            ._____.  *)
(*                            | 5P  |  *)
(*          ._____.           ._____.  *)
(*          | 5T  |           | 4P  |  *)
(* ._____.  ._____.  ._____.  ._____.  *)
(* | 7P  |  | 6T  |  | 6K  |  | dP  |  *)
(*_____________________________________*)
- : unit = ()

Mode texte et graphique : Dans ce mode, on visualise l'évolution des tas de cartes à la fois dans le terminal et dans une fenêtre graphique.

Le mode d'affichage par défaut est le mode graphique. L'instruction

Sélectionnez

affichage_en_mode_texte ()

permet de passer en mode texte. L'instruction

Sélectionnez

affichage_en_mode_graphique ()

permet de passer en mode graphique. Et l'instruction

Sélectionnez

affichage_en_mode_texte_et_graphique ()

permet de combiner les deux modes texte et graphique(20).

Remarque : Le mode texte permet de conserver une trace de l'exécution d'un programme dans un fichier texte. Par exemple, si un fichier nommé exo.ml contient un programme de résolution d'un problème sur les cartes, et s'il contient une instruction demandant un affichage textuel, alors dans un terminal la commande

Sélectionnez

$ ocamlcartes exo.ml > exo.result

produit un fichier texte nommé exo.result contenant toutes les instructions exécutées suivies de l'état des tas de cartes qu'elles transforment.

Vitesse d'exécution

Un délai est imposé entre l'exécution des instructions de manipulation des tas. Le temps d'attente peut être ajusté en fonction des besoins. Le module fournit deux éléments permettant de consulter (quel_delai)(21) et de modifier (fixer_delai)(22) cette temporisation.

Pour augmenter la vitesse d'exécution, il suffit de diminuer la valeur réelle.

Sélectionnez

fixer_delai(0.1)

L'instruction précédente permet de fixer la durée de l'attente à un dixième de seconde.

Pause

L'instruction pause(23) permet de faire une pause durant l'exécution d'un programme. Elle s'utilise en communiquant un message en paramètre, message qui sera imprimé dans le terminal lors de la pause. La pause s'arrête dès l'appui sur la touche Entrée.

Sélectionnez

pause ("un petit repose bien merite")

Réparer l'automate▲

Lorsqu'une contrainte d'utilisation n'est pas respectée, par exemple lorsqu'on veut déplacer une carte située sur un tas vide, une exception est déclenchée, et la fenêtre graphique apparaît barrée de deux lignes rouges qui indique que l'automate est « cassé ». À partir de ce moment plus aucune action sur l'automate n'est possible.

La session qui suit suppose que la situation actuelle est celle montrée à la figure A.1, et montre le déclenchement de l'exception LesExceptions.Tas_Vide 1 dû à la tentative de déplacer une carte depuis le tas 1 qui est vide, puis le déclenchement de l'exception LesExceptions.AutomateCasse qui montre l'impossibilité d'agir sur l'environnement des tas puisque l'automate a été cassé par la commande précédente.

Sélectionnez

1.
2.
3.
4.

# deplacer_sommet(1,2) ;;
Exception: LesExceptions.Tas_Vide 1.
# deplacer_sommet(2,3);;
Exception: LesExceptions.AutomateCasse.

Plus rien n'est possible avant l'exécution de l'instruction Admin.repare (). Cette instruction permet de « réparer » l'automate (les lignes rouges de la fenêtre graphique disparaissent), et de poursuivre les actions sur les tas de cartes.

Sélectionnez

1.
2.
3.
4.

# Admin.repare ();;
- : unit = ()
# deplacer_sommet(2,3) ;;
- : unit = ()

Obtenir de l'aide▲

Pour obtenir un aide-mémoire des principales fonctions et instructions du module Cartes, on fait appel à la fonction aide_moi.

Sélectionnez

1.
2.
3.
4.
5.
6.
7.

# aide_moi () ;;
  Les principaux elements du Module Cartes
----------------------------------------
* init_tas : numero_tas * string -> unit
    init_tas(num_tas,chaine) : initialise le tas numero num_tas
    avec la description donnee par chaine.
...

Exercices▲

Ils sont classés en ★, ★★ et ★★★ (les premiers sont très faciles).

Descriptions de tas▲

Exercice A-1

Pour chacune des descriptions qui suivent, donnez l'instruction d'initialisation du tas qui convient :

le tas 1 contient une carte de couleur ♣ ;
le tas 1 contient une carte de couleur ♣ ou ♠ ;
le tas 1 contient une carte de couleur quelconque ;
le tas 1 contient deux cartes de couleur ♡ ;
le tas 1 contient une carte de couleur ♡ surmontée d'un ♢ ;
le tas 1 contient un nombre quelconque de ♠ ;
le tas 1 contient un nombre quelconque de ♠ ou bien un nombre quelconque de ♡ ;
le tas 1 contient un nombre quelconque de cartes de couleur ♠ ou ♡ ;
le tas 1 contient un nombre quelconque de cartes de couleur quelconque ;
le tas 1 contient au moins un carreau ;
le tas 1 contient un ♣ surmonté soit d'un nombre quelconque de ♡, soit d'un nombre quelconque non nul de ♠ ;
le tas 1 contient un nombre pair de ♡ ;
le tas 1 contient un nombre impair de ♡ ;
le tas 1 contient un nombre pair de ♣ ou un nombre multiple de 3 de ♠ ;
les deux cartes extrêmes du tas 1 (la plus basse et la plus haute) sont des ♣, entre les deux il y a un nombre quelconque de successions de deux cartes de couleur ♢♡.

Séquence▲

Dans tous les exercices qui suivent, l'énoncé décrit une situation initiale des quatre tas de cartes (dans la syntaxe du module Cartes), et la situation finale à atteindre.

Exercice A-2 ★

Situation initiale :

Tas 1 : "TT" Tas 2 : ""

Tas 3 : "" Tas 4 : ""

Situation finale :

Tas 1 : "" Tas 2 : "TT"

Tas 3 : "" Tas 4 : ""

Exercice A-3 ★

Situation initiale :

Tas 1 : "TK" Tas 2 : ""

Tas 3 : "" Tas 4 : ""

Situation finale :

Tas 1 : "KT" Tas 2 : ""

Tas 3 : "" Tas 4 : ""

Exercice A-4 ★

Situation initiale :

Tas 1 : "TKTK" Tas 2 : ""

Tas 3 : "" Tas 4 : ""

Situation finale :

Tas 1 : "KKTT" Tas 2 : ""

Tas 3 : "" Tas 4 : ""

Exercice A-5 ★

Situation initiale :

Tas 1 : "TKCP" Tas 2 : ""

Tas 3 : "" Tas 4 : ""

Situation finale :

Tas 1 : "PCKT" Tas 2 : ""

Tas 3 : "" Tas 4 : ""

Conditionnelle▲

Exercice A-6 ★

Situation initiale :

Tas 1 : "T+P" Tas 2 : ""

Tas 3 : "" Tas 4 : ""

Situation finale :

Tas 1 : "" Tas 2 : "[T]"

Tas 3 : "[P]" Tas 4 : ""

Exercice A-7 ★

Situation initiale :

Tas 1 : "(T+K+C+P)(T+K+C+P)" Tas 2 : ""

Tas 3 : "" Tas 4 : ""

Situation finale :

Tas 1 : "" Tas 2 : ""

Tas 3 : "(T+K+C+P)(T+K+C+P)"↑ Tas 4 : ""

Le symbole ↑ signifiant que les cartes sont dans l'ordre croissant (i.e. la carte du dessous a une valeur inférieure ou égale à celle du dessus).

Exercice A-8 ★

Situation initiale :

Tas 1 : "T+K+C+P" Tas 2 : ""

Tas 3 : "" Tas 4 : ""

Situation finale :

Tas 1 : "[T]" Tas 2 : "[K]"

Tas 3 : "[C]" Tas 4 : "[P]"

Exercice A-9 ★

Situation initiale :

Tas 1 : "(T+K+C+P)(T+K+C+P)" Tas 2 : ""

Tas 3 : "" Tas 4 : ""

Situation finale :

Tas 1 : "[K+C]" Tas 2 : "[T+P]"

Tas 3 : "" Tas 4 : ""

Itération▲

Exercice A-10 ★

Situation initiale :

Tas 1 : "[T]" Tas 2 : ""

Tas 3 : "" Tas 4 : ""

Situation finale :

Tas 1 : "" Tas 2 : "[T]"

Tas 3 : "" Tas 4 : ""

Exercice A-11 ★★

Situation initiale :

Tas 1 : "[K+C][T+P]" Tas 2 : ""

Tas 3 : "" Tas 4 : ""

Situation finale :

Tas 1 : "[T+P][K+C]" Tas 2 : ""

Tas 3 : "" Tas 4 : ""

Exercice A-12 ★★

Situation initiale :

Tas 1 : "[K]" Tas 2 : "[T]"

Tas 3 : "" Tas 4 : ""

Situation finale :

Tas 1 : "[K]" Tas 2 : ""

Tas 3 : "[KT]" Tas 4 : ""

ou bien :

Tas 1 : "" Tas 2 : "[T]"

Tas 3 : "[KT]" Tas 4 : ""

Exercice A-13 ★★

Situation initiale :

Tas 1 : "[T]" Tas 2 : ""

Tas 3 : "" Tas 4 : ""

Situation finale :

Tas 1 : "" Tas 2 : "[T]"

Tas 3 : "[T]" Tas 4 : ""

Le nombre de cartes des tas 2 et 3 différant d'au plus 1 dans la situation finale.

Exercice A-14 ★

Situation initiale :

Tas 1 : "[T]" Tas 2 : "[K]"

Tas 3 : "[P]" Tas 4 : ""

Situation finale :

Tas 1 : "" Tas 2 : "[T]"

Tas 3 : "[K]" Tas 4 : "[P]"

En faire deux versions, la seconde utilisant une procédure vider_tas(depart,arrivee) qui vide le tas depart sur le tas arrivee.

Exercice A-15 ★★

Situation initiale :

Tas 1 : "[T]" Tas 2 : "[K]"

Tas 3 : "[C]" Tas 4 : "[P]"

Situation finale :

Tas 1 : "[P]" Tas 2 : "[T]"

Tas 3 : "[K]" Tas 4 : "[C]"

Exercice A-16 ★★

Situation initiale :

Tas 1 : "[T][K][C][P]" Tas 2 : ""

Tas 3 : "" Tas 4 : ""

Situation finale :

Tas 1 : "[P][C][K][T]" Tas 2 : ""

Tas 3 : "" Tas 4 : ""

Exercice A-17 ★★

Situation initiale :

Tas 1 : "[T]" Tas 2 : "[K]"

Tas 3 : "[P]" Tas 4 : ""

Situation finale :

Tas 1 : "" Tas 2 : ""

Tas 3 : "" Tas 4 : "[TKP][XY][Z]"

Où X et Y désignent les deux couleurs restantes lorsque l'une des couleurs manque, et Z désigne la couleur restante lorsque X ou Y manque.

Exercice A-18 ★★

Situation initiale :

Tas 1 : "[T+K+C+P]" Tas 2 : ""

Tas 3 : "" Tas 4 : ""

Situation finale :

Tas 1 : "[T]" Tas 2 : "[K]"

Tas 3 : "[C]" Tas 4 : "[P]"

Exercice A-19 ★★

Situation initiale :

Tas 1 : "T[T]" Tas 2 : ""

Tas 3 : "" Tas 4 : ""

Situation finale :

Tas 1 : "" Tas 2 : "T"−

Tas 3 : "[T]" Tas 4 : ""

Le symbole − indique que la carte est de valeur minimale.

Exercice A-20 ★★★

Situation initiale :

Tas 1 : "[T]" Tas 2 : ""

Tas 3 : "" Tas 4 : ""

Situation finale :

Tas 1 : "" Tas 2 : "[T]↑

Tas 3 : "" Tas 4 : ""

Le symbole ↑ signifiant que les cartes sont rangées par ordre croissant de valeurs de bas en haut.

Exercice A-21 ★★

Situation initiale :

Tas 1 : "[T+K]" Tas 2 : ""

Tas 3 : "" Tas 4 : ""

Situation finale :

Tas 1 : "[X][Y]" Tas 2 : ""

Tas 3 : "" Tas 4 : ""

Le symbole X désigne la couleur (♣ ou ♢) la plus nombreuse, l'autre couleur étant désignée par Y.

Exercice A-22 ★★★

Situation initiale :

Tas 1 : "K[T]" Tas 2 : ""

Tas 3 : "" Tas 4 : ""

Situation finale :

Tas 1 : "[T+K]" Tas 2 : "[T+K]"

Tas 3 : "[T+K]" Tas 4 : "[T+K]"

Les trèfles étant équitablement répartis sur les quatre tas, l'unique carreau se trouvant n'importe où.

Remarque : ce problème est infaisable sans le carreau.

Exercice A-23 ★★★

Situation initiale :

Tas 1 : "[T]" Tas 2 : "[K]"

Tas 3 : "[C]" Tas 4 : "[P]"

Situation finale :

Tas 1 : "[T] ↑" Tas 2 : "[K] ↑"

Tas 3 : "[C] ↑" Tas 4 : "[P] ↑"

Le symbole ↑ signifiant que les cartes sont rangées par ordre croissant de valeurs de bas en haut.

Fonctions et procédures▲

Exercice A-24

Soit la fonction définie en Caml par

Sélectionnez

1.
2.

let meme_couleur (couleur, tas) =
  couleur = couleur_sommet(tas) ;;

Question 1 : Quel problème pose cette fonction si lors d'un appel le tas passé en paramètre est vide ?

Question 2 : Comment modifier la fonction meme_couleur pour qu'elle renvoie la valeur faux si le tas tas est vide.

Exercice A-25 : Égalité de deux cartes

Question 1 : Écrivez une fonction qui teste l'égalité de la valeur de deux cartes situées au sommet de deux tas que l'on supposera non vide.

Question 2 : Puis écrivez une fonction qui teste l'égalité de deux cartes (valeur et couleur) situées au sommet de deux tas supposés non vides.

Exercice A-26 : Inverser l'ordre des cartes d'un tas

Il s'agit d'écrire une procédure inverser_tas1 pour inverser l'ordre des cartes du tas 1. Par exemple, si on a tas 1 : "TCCPK" alors après exécution de l'instruction inverser_tas1 (), on doit avoir tas 1 : "KPCCT".

Question 1 : Faites-le avec l'hypothèse que les autres tas sont vides.

Question 2 : Réaliser la procédure sans supposer que les autres tas sont vides.

(15)

init_tas est une fonction dont le résultat est l'unique valeur du type unit, c'est ce qu'on appellera une procédure. Le paramètre de la procédure init_tas, est un élément du produit cartésien de l'ensemble des entiers par l'ensemble des chaînes int ∗ string → unit.

(16)

Dont le type est int ∗ int → unit.

(17)

Dont le type est int → bool.

(18)

Dont le type est int → couleur.

(19)

Dont le type est int → unit.

(20)

Ces trois procédures sont de type unit → unit.

(21)

Dont le type est unit → float.