Parcours
/
Factor
Factor
/
Exercices
/
Conversion de devises
Conversion de devises

Conversion de devises

Exercice d'apprentissage

Introduction

Cet exercice s'appuie sur l'arithmétique des nombres entiers de Les lasagnes délicieuses de Leah. Ici, tu vas travailler avec des nombres à virgule flottante et choisir le mot de division adapté à la situation.

Entiers et nombres à virgule flottante

Factor distingue les nombres entiers (1, 42, 1_000_000) des nombres à virgule flottante (1.0, 3.14, 6.02e23). Si tu mélanges un entier et un nombre à virgule flottante dans un même calcul, le résultat est un nombre à virgule flottante :

2 3 + .      ! => 5
2 3.0 + .    ! => 5.0

Tu peux insérer des tirets bas à l'intérieur d'un nombre pour regrouper les chiffres, comme dans 1_000_000, et Factor les ignore tout simplement.

Les mots de division

Factor dispose de mots de division distincts. Ils vivent tous dans le vocabulaire math.

/    ( x y -- x/y )    ! exact: ratio for two integers, float if either is a float
/f   ( x y -- f   )    ! always a float
/i   ( x y -- q   )    ! integer division (truncates toward zero)
mod  ( x y -- r   )    ! remainder
/mod ( x y -- q r )    ! quotient and remainder together
1 2 / .        ! => 1/2     (a proper ratio)
16 3 / .       ! => 5+1/3   (an improper ratio, printed as a mixed numeral)
16 3 /f .      ! => 5.333333333333333
16 3 /i .      ! => 5      (truncated)
16 3 mod .     ! => 1
16 3 /mod .s   ! quotient and remainder in one pass
! => 5
! => 1
16.0 3 / .     ! => 5.333333333333333

/ produit un ratio (le type rationnel exact de Factor) à partir de deux entiers, ou un float si l'une des entrées est un flottant. /f force un résultat flottant, même pour deux entiers. /i tronque toujours vers zéro.

Vérification

Les prédicats numériques de math, math.functions et math.primes :

zero?    ( x       -- ? )
even?    ( x       -- ? )
odd?     ( x       -- ? )
prime?   ( x       -- ? )
divisor? ( m n     -- ? )    ! true when n divides m
integer? ( x       -- ? )    ! true for ints (fixnum or bignum)
float?   ( x       -- ? )    ! true for floats
number?  ( x       -- ? )    ! true for any numeric kind
0 zero? .            ! => t
0.0 zero? .          ! => t
3 zero? .            ! => f

4 even? .            ! => t
7 even? .            ! => f
7 odd? .             ! => t

7 prime? .           ! => t
9 prime? .           ! => f

15 5 divisor? .      ! => t   (5 divides 15)
15 4 divisor? .      ! => f

Du flottant vers l'entier

Les mots floor, ceiling et round du vocabulaire math.functions renvoient tous un flottant (3.0, et non 3). Pour obtenir un véritable entier, enchaîne avec >integer :

3.7 floor >integer .       ! => 3
3.2 ceiling >integer .     ! => 4

Puissances et valeur absolue

Les mots sq, ^ et abs (dans math.functions) calculent les carrés, les puissances quelconques et les valeurs absolues :

sq  ( x   -- x*x )
^   ( x y -- x^y )
abs ( x   -- |x| )
5 sq .          ! => 25
2 10 ^ .        ! => 1024
2 0.5 ^ .       ! => 1.4142135623730951
-7 abs .        ! => 7
3 abs .         ! => 3

Minimum et maximum

Les mots min ( x y -- z ) et max ( x y -- z ) (dans math.order) renvoient le plus petit ou le plus grand de deux nombres :

3 7 min .       ! => 3
3 7 max .       ! => 7

L'usage le plus courant est le clamping : on fixe une valeur à un plancher avec max (par exemple, 0 max garde une valeur positive ou nulle) ou à un plafond avec min.

Prédicats d'ordre

math.order fournit aussi before?, after?, before=? et after=?, des prédicats de comparaison qui fonctionnent sur tout type ordonnable, qu'il s'agisse de nombres, de strings ou de caractères :

before?  ( obj1 obj2 -- ? )   ! obj1 <  obj2
before=? ( obj1 obj2 -- ? )   ! obj1 <= obj2
after?   ( obj1 obj2 -- ? )   ! obj1 >  obj2
after=?  ( obj1 obj2 -- ? )   ! obj1 >= obj2

Utilise-les plutôt que </<= quand les valeurs peuvent être des strings : les opérateurs arithmétiques ne prennent pas en charge les strings.

Instructions

Ton ami Chandler prévoit de visiter des pays exotiques aux quatre coins du monde. Malheureusement, Chandler n’est pas très bon en maths. Il redoute de se faire arnaquer par les bureaux de change pendant son voyage, et il aimerait que tu lui fabriques un calculateur de devises.

1. Estime la valeur après échange

Définis exchange-money, qui prend un budget et un exchange-rate et renvoie la valeur de la devise échangée.

Remarque : si ta devise est l’USD et que tu veux échanger des USD contre des EUR avec un taux de change de 1.20, alors 1.20 USD == 1 EUR.

127.5 1.2 exchange-money .
! => 106.25

2. Calcule la devise restante après un échange

Définis get-change, qui prend un budget (avant l’échange) et l’exchanging-value (le montant prélevé sur le budget pour être échangé). Renvoie le montant d’argent qui reste.

127.5 120 get-change .
! => 7.5

3. Calcule la valeur des billets

Définis value-of-bills, qui prend une denomination (la valeur d’un seul billet) et un number-of-bills. Renvoie la valeur totale des billets.

5 128 value-of-bills .
! => 640

4. Calcule le nombre de billets

Définis number-of-bills, qui prend un amount et une denomination. Renvoie le nombre de billets entiers de la dénomination donnée qui tiennent dans le montant. Arrondis à l’inférieur : les fractions de billet n’existent pas.

127.5 5 number-of-bills .
! => 25

5. Calcule le reste après un échange en billets

Définis leftover-of-bills, qui prend un amount et une denomination. Renvoie le montant restant qui ne peut pas être rendu sous forme de billets entiers.

127.5 20 leftover-of-bills .
! => 7.5

6. Calcule la valeur après échange

Définis exchangeable-value, qui prend une denomination, un budget, un spread et un exchange-rate.

spread est le pourcentage prélevé au titre des frais de change, écrit sous forme d’entier. Il faut l’ajouter au taux de change sous forme de fraction. Si 1.00 EUR == 1.20 USD et que le spread vaut 10, le taux de change total est 1.00 EUR == 1.32 USD (10 % de 1,20 font 0,12, que l’on ajoute à 1,20).

Renvoie la valeur maximale de la nouvelle devise après application du taux augmenté du spread, arrondie à l’inférieur en billets entiers de la denomination donnée. La valeur renvoyée est un entier.

20 127.25 10 1.20 exchangeable-value .
! => 80

5 127.25 10 1.20 exchangeable-value .
! => 95

7. Échange sécurisé

Comme get-change, mais si Chandler a tapé par erreur une valeur d’échange supérieure à son budget, renvoie 0 au lieu d’un nombre négatif. Définis safe-change, qui prend un budget et un exchanging-value.

127.5 120 safe-change .
! => 7.5

50 100 safe-change .
! => 0

8. Plafonne selon le budget

Chandler marchande un souvenir. Définis cap-spend, qui prend un budget et un price et renvoie le plus petit des deux, c’est-à-dire le maximum qu’il peut réellement payer.

100 30 cap-spend .
! => 30

20 30 cap-spend .
! => 20
Modifie via GitHub Le lien s'ouvre dans une nouvelle fenêtre ou un nouvel onglet
Factor Exercism

Prêt à commencer Conversion de devises ?

Inscris-toi sur Exercism pour apprendre et maîtriser Factor avec 47 concepts163 exercices, et un vrai mentorat humain, le tout gratuitement.