retour vers la page d'accueil

STS IG 2 - année 2002/2003
TD n°1 : Rendre la monnaie
éléments de correction

Hypothèses - Algo de principe - Algo principal

Hypothèses

SommeClient > SommeTotale
Cette hypothèse n'est pas à conserver car elle est simple à implémenter.

Fonctionnement dans la zone EURO
La monnaie en vigueur est donc l'Euro,
qui offre donc 15 valeurs différentes : de 0,01E à 500,00E
Réfléchir à ce qu'il faudrait faire pour rendre l'application internationale.

Monnaie en caisse inépuisable
Cette hypothèse est peu réaliste pour un commerçant.
Néanmoins, elle pourra être retenue dans un premier temps.
Il faudra trouver une solution pour la fin du TD.

SommeClient - Somme Totale <= 500
Cette hypothèse n'a en fait aucune incidence sur l'algorithme lui même,
donc il n'est pas nécessaire de la retenir

Algorithme de principe

Il faut connaître :
la SommeTotale, celle dûe par le client
la SommeClient , celle versée par le client, ainsi que les valeurs données par le client

Si il faut rendre la monnaie :
Calculer la SommeARendre

Regarder dans la caisse quelle est la plus grande valeur qui peut être rendue
et déterminer la quantité. Il faut regarder si cette quantité est disponible, en tenant compte de ce que verse le client. Cela donne donc la véritable quantité à rendre
Il faut déduire de la SommeARendre le montant qui va être rendue

on recommence avec la valeur suivante à rendre
et ce, jusqu'à ce qu'il n'y ait plus rien à rendre ou que l'on soit arrivé à la plus petite valeur.

Si il n'y a plus rien à rendre, le commerçant peut encaisser les valeurs du client et rendre la monnaie.

Si le commerçant ne peut pas rendre la monnaie intégralement, la transaction ne peut pas se faire.

Algorithmes

Données globales :

SommeTotale, SommeClient sont réels

NbValeurs est une constante entière qui vaut 15
// Nombre de pièces et billets

Caisse est un tableau [1 à NbValeurs, 1 à 4] d'entiers
// La 1ère colonne contient les valeurs
// La 2ème colonne contient le nombre à rendre
// La 3ème colonne contient le fond de caisse
// La 4ème colonne contient les valeurs données par le client

FinBoucle,
PaiementAccepte sont des booléens

ALGORITHME PRINCIPAL

début
  Initialisation

  FinBoucle <-- FAUX
  REPETER
    PreparerTransaction // Mise à 0 des colonnes 2 et 4 de la caisse
    SaisirInformations (SommeTotale, SommeClient)

    SI (SommeClient < SommeTotale)
    ALORS
      Afficher "La somme versée par le client est insuffisante"
    SINON
      SI (SommeClient = SommeTotale)
      ALORS
        Afficher "Il n'y a pas de monnaie à rendre. Merci."
        MettreAJourFondCaisse // Ajouter les valeurs données par le client au fond de caisse

        FinBoucle <-- VRAI
      SINON
        TraiterInformations (SommeTotale, SommeClient, PaiementAccepte)
        SI PaiementAccepte
        ALORS
          MettreAJourFondCaisse
           // Ajouter les valeurs données par le client
           // et retrancher les valeurs versées au client, dans le fond de caisse

          AfficherInformations
        SINON
          Afficher "Désolé, le paiement ne peut être accepté, faute de monnaie"
        FIN SI

        FinBoucle <-- VRAI
      FIN SI
    FIN SI
  JUSQU'A FinBoucle
fin

Algorithme Initialisation

Donnée : IndexMonnaie est un entier

début
// La caisse contient les valeurs en CENTIMES d'EUROS
  Caisse [ 1, 1] <-- 50000 // 500 Euros
  Caisse [ 2, 1] <-- 20000
  Caisse [ 3, 1] <-- 10000
  Caisse [ 4, 1] <-- 5000
  Caisse [ 5, 1] <-- 2000
  Caisse [ 6, 1] <-- 1000
  Caisse [ 7, 1] <-- 500
  Caisse [ 8, 1] <-- 200
  Caisse [ 9, 1] <-- 100
  Caisse [10, 1] <-- 50
  Caisse [11, 1] <-- 20
  Caisse [12, 1] <-- 10
  Caisse [13, 1] <-- 5
  Caisse [14, 1] <-- 2
  Caisse [15, 1] <-- 1 // 1 centime d'Euro

// La caisse contient les valeurs en CENTIMES d'EUROS
// Fond de caisse
  Caisse [ 1, 3] <-- 1 // 500 Euros
  Caisse [ 2, 3] <-- 2
  Caisse [ 3, 3] <-- 5
  Caisse [ 4, 3] <-- 1
  Caisse [ 5, 3] <-- 2
  Caisse [ 6, 3] <-- 5
  Caisse [ 7, 3] <-- 1
  Caisse [ 8, 3] <-- 2
  Caisse [ 9, 3] <-- 5
  Caisse [10, 3] <-- 1
  Caisse [11, 3] <-- 2
  Caisse [12, 3] <-- 5
  Caisse [13, 3] <-- 1
  Caisse [14, 3] <-- 2
  Caisse [15, 3] <-- 5 // 1 centime d'Euro
fin

Algorithme PreparerTransaction

Donnée : IndexCaissse est un entier

début
  POUR IndexCaisse <-- 1 à NbValeurs FAIRE
    Caisse [IndexCaisse, 2] <-- 0  // Nombre de valeurs à rendre
    Caisse [IndexCaisse, 4] <-- 0  // Nombres de valeurs fournies par le client
  FIN POUR
fin

Algorithme SaisirInformations (S : Total, Paiement sont réels)

données : IndexCaisse est un entier

début
  Afficher "Montant à payer par le client : "
  Saisir Total

  Paiement <-- 0
  POUR IndexCaisse <-- 1 à NbValeurs FAIRE
    Afficher "Valeur : ", Caisse [IndexCaisse, 1]/100, " Euro(s) - Nombre versé par le client : "
    Saisir Caisse [IndexCaisse, 4]

    Paiement <-- Paiement + Caisse [IndexCaisse, 4]*Caisse [IndexCaisse, 4]/100
  FIN POUR
fin

Algorithme TraiterInformations (E : MontantTotal, MontantPaye sont réels; S : PaiementOK est un booléen)

Données : MontantARendre, IndexValeur sont entiers

// On suppose ici qu'il faut toujours rendre de la monnaie

début
  PaiementOK <-- VRAI

  MontantARendre <-- (MontantPaye - MontantTotal) * 100
// MontantARendre est un entier,
// ce qui garantit l'absence de décimales

  SI (MontantARendre < 0) // On s'assure ici d'avoir un entier positif
  ALORS
     MontantARendre <-- 0
  FIN SI

  POUR IndexValeur <-- 1 à NbValeurs FAIRE
    Caisse [IndexValeur, 2] <-- MontantARendre DIV Caisse [IndexValeur, 1]

    SI Caisse [IndexValeur, 2] > (Caisse [IndexValeur, 3] + Caisse [IndexValeur, 4])
    ALORS
      Caisse [IndexValeur, 2] <-- (Caisse [IndexValeur, 3] + Caisse [IndexValeur, 4])
    FIN SI

    MontantARendre <-- MontantARendre - Caisse [IndexValeur, 2]*Caisse [IndexValeur, 1]
  FIN POUR

  PaiementOK <-- (MontantARendre = 0)
fin

Jeu de test de l'algorithme TraiterInformations

Valeur 1 : 0 ou 1 fois
Valeur 2 : 0, 1 ou 2 fois
Valeur 5 : 0 ou 1 fois

MontantTotal	MontantPaye	MontantARendre	Caisse	Situation
10	5,00	0,00	Toutes les valeurs à 0	< 0
10	10,00	0,00	Toutes les valeurs à 0	= 0
10	1009,99 2 x 500 1 x 5 2 x 2 1 x 0,50 2 x 0,20 1 x 0,05 2 x 0,02	999,99	rendre 1 x 500 2 x 200 1 x 50 2 x 20 1 x 5 2 x 2 1 x 0,50 2 x 0,20 1 x 0,05 2 x 0,02	En caisse, 3 exemplaires de chaque valeur Situation de la caisse à la fin   4 x 500 - 1 x 200 - 3 x 100   2 x 50 - 1 x 20 - 3 x 10   3 x 5 - 3 x 2 - 3 x 1   3 x 0,50 - 3 x 0,20 - 3 x 0,10   3 x 0,05 - 3 x 0,02 - 3 x 0,01
10	121,11 1 x 100 1 x 20 1 x 1 1 x 0,10 1 x 0,01	111,11	rendre 1 x 100 1 x 10 1 x 1 1 x 0,10 1 x 0,01	En caisse, 3 exemplaires de chaque valeur Situation de la caisse à la fin   3 x 500 - 3 x 200 - 3 x 100   3 x 50 - 4 x 20 - 2 x 10   3 x 5 - 3 x 2 - 3 x 1   3 x 0,50 - 3 x 0,20 - 3 x 0,10   3 x 0,05 - 3 x 0,02 - 3 x 0,01
10	232,22 1 x 200 1 x 20 1 x 10 1 x 2 1 x 0,20 1 x 0,02	222,22	rendre 1 x 200 1 x 20 1 x 2 1 x 0,20 1 x 0,02	En caisse, 3 exemplaires de chaque valeur Situation de la caisse à la fin   3 x 500 - 3 x 200 - 3 x 100   3 x 50 - 3 x 20 - 4 x 10   3 x 5 - 3 x 2 - 3 x 1   3 x 0,50 - 3 x 0,20 - 3 x 0,10   3 x 0,05 - 3 x 0,02 - 3 x 0,01
2	10,00 1 x 5 5 x 1	8,00	rendre 1 x 5 3 x 1	En caisse   0 x 5 - 0 x 2 - 3 x 1 Situation de la caisse à la fin   0 x 5 - 0 x 2 - 5 x 1
2	10,00 1 x 10	8,00	Impossible de rendre la monnaie	En caisse   1 x 5 - 0 x 2 - 1 x 1 Situation de la caisse à la fin   1 x 5 - 0 x 2 - 1 x 1

Algorithme MettreAJourFondCaisse

donnée : IndexCaisse est une entier

début
  POUR IndexCaisse <-- 1 à NbValeurs FAIRE
    Caisse [IndexCaisse, 3] <-- Caisse [IndexCaisse, 3] + Caisse [IndexCaisse, 4] - Caisse [IndexCaisse, 2]
  FIN POUR
fin

Algorithme AfficherInformations

Donnée : IndexValeur est entier

début
  Afficher "Il faut rendre : "

  POUR IndexMonnaie <-- 1 à NbValeurs FAIRE
    SI (Caisse [IndexValeur, 2] <> 0)
    ALORS
      Afficher Caisse [IndexValeur, 2], " pièce(s) ou billet(s) de ", Caisse [IndexValeur, 1]/100, " Euro(s)"
    FIN SI
  FIN POUR

  Afficher "Merci."
fin