rendre monnaie avec le minimum de pièces et billets

Version imprimable

bonsoir,
j'ai l’énoncé suivant:
Considérons les billets et pièces de valeurs suivantes : 20 euros, 10 euros, 5 euros, 2 euros, 1 euros. Écrivez une fonction rendre_monnaie qui prend en paramètres un entier prix et cinq valeurs entières x20, x10, x5, x2, x1 représentant le nombre de billets et de pièces de chaque sorte que donne un client pour payer l’objet dont le prix est mentionné. La fonction doit renvoyer cinq valeurs représentant la somme qu’il faut rendre au client, décomposée en billets et pièces (dans le même ordre que précédemment). La décomposition doit être faite en rendant le plus possible de billets et pièces de grosses valeurs (éventuellement avec d'autres billets que ceux apportés par le client; on suppose qu'il y a toujours assez de billets chez le vendeur).
Pour renvoyer les cinq valeurs, vous utilisez l'instruction:

return res20, res10, res5, res2, res1
où les cinq variables res20 à res1 contiennent les cinq valeurs à renvoyer (res20 contient le nombre de billets de 20 à remettre, ..., res1 le nombre de pièces de 1 à remettre).

S'il manque de l'argent, la fonction renverra cinq valeurs None.

j'ai essayé un peu mais je sent que je ne suis pas dans le bon chemin:ci joint le code
Code:

1 2 3 4 5 6 7 8 9 10 11 12 def rendre_monnaie(prix, x20, x10, x5, x2, x1): while(prix>= x20): res20 = prix / 20 if ((prix % 20) != 0): res10 = res20 / 10 elif ((res20 % 10) != 0): res5 = res10 / 5 elif ((res10 % 5) != 0): res2 = res5 / 2 elif (res5 % 2 != 0): res1 = res2 / 1 return res20, res10, res5, res2, res1

19/03/2019, 07h30
fred1599

Bonjour,

Les valeurs des billets représentent une variable (à votre niveau vous connaissez ;)) et une seule.

Imaginons que vous deviez découper le prix en 400 billets de valeurs différentes, vous mettriez 400 arguments dans la fonction ?

Il va falloir regarder de votre côté une manière algorithmique moins contraignante de résoudre votre problème, et cela n'est pas pour l'instant un problème python.
19/03/2019, 07h32
marco056
Il faudrait faire la division euclidienne du prix par 20 (et non la division simple) d'abord :

Code:

prix//20

Exemples sur le reste et le quotient :
Code:

1 2 43%20 -> 3 43//20 -> 2
19/03/2019, 09h46
lg_53

On peut aussi utiliser la fonction divmod qui renvoit directement le quotient et le reste.
19/03/2019, 10h06
fred1599

Une boucle et une soustraction peuvent suffirent ;)
19/03/2019, 14h27
marco056

Citation:

Envoyé par fred1599

Une boucle et une soustraction peuvent suffirent ;)

Aussi...
19/03/2019, 19h21
FATENMRABET

Citation:

Envoyé par fred1599

Bonjour,

Les valeurs des billets représentent une variable (à votre niveau vous connaissez ;)) et une seule.

Imaginons que vous deviez découper le prix en 400 billets de valeurs différentes, vous mettriez 400 arguments dans la fonction ?

Il va falloir regarder de votre côté une manière algorithmique moins contraignante de résoudre votre problème, et cela n'est pas pour l'instant un problème python.

salut,
c'est ce qui est demandé à l'énoncé:

Citation:

Écrivez une fonction rendre_monnaie qui prend en paramètres un entier prix et cinq valeurs entières x20, x10, x5, x2, x1 représentant le nombre de billets et de pièces de chaque sorte que donne un client pour payer l’objet dont le prix est mentionné.

et le test ce fait par upylab donc il faut respecter l'entête
19/03/2019, 19h32
fred1599

Il faudra prendre un site d'apprentissage python, qui vous fera travailler aussi l'algorithmie...

Quelle valeur va prendre x20, x10, ... d'après vous ? Il semble que ces variables représentent le nombre de billets d'une valeur spécifique, donc 2 pour la variable x20 par exemple, représentera 2 billets de 20 distribués. Donc si j'ai bien compris votre code, vous oubliez la multiplication du nombre de billets par sa valeur, non ?

bonsoir,
à ce niveau j'ai encore rien: :oops:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
def rendre_monnaie(prix, x20, x10, x5, x2, x1):
    if (prix<x20):
        x20, x10, x5, x2, x1=None
    else:
        res20 = prix // 20
        while((divmod(prix,x20)!=0) or (divmod(prix,x10)!=0)or ((divmod(prix,x5)!=0)) or ((divmod(prix,x2)!=0))):
            res10 = res20 // 10
            res5 = res10 // 5
            res2 = res5 // 2
            res1 = res2 // 1
    return res20, res10, res5, res2, res1
 
rendre_monnaie(100, 20, 10, 5, 2, 1)

19/03/2019, 20h00
wiztricks

Citation:

Envoyé par FATENMRABET

salut,
c'est ce qui est demandé à l'énoncé:

Citation:

Écrivez une fonction rendre_monnaie qui prend en paramètres un entier prix et cinq valeurs entières x20, x10, x5, x2, x1 représentant le nombre de billets et de pièces de chaque sorte que donne un client pour payer l’objet dont le prix est mentionné.

et le test ce fait par upylab donc il faut respecter l'entête

Dans ce cas, il faut déjà calculer que la somme d'argent donnée par le client est bien supérieure au prix de l'achat... puis calculer ce qu'il faut lui rendre et le traduire en nombre de billets/pièces.

- W

bonjour,

en utilisant une boucle et divmod ça va tout seul (si j'ose dire), voici un exemple
Code:

1 2 3 4 5 6 7 8 def rendre_monnaie(somme): liste_valeur_billet= (20, 10, 5, 2, 1) if somme <20: return [None]*5 v_retour = {} for value in liste_valeur_billet: v_retour[value], somme = divmod(somme, value) return list(v_retour.values())
ps: j'ai édité le nom des variables pour qu'il n'y est pas d'ambiguïté entre v, values et value

Voici une solution , tu peux mettre la liste de billet que tu veux , toujours par ordre décroissant par contre :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 def rendre_monnaie(prix) : global n global tot_billet global listBillets billet = prix // listBillets[n] tot_billet [listBillets[n]] = billet prix = prix - (listBillets[n] * billet ) n = n + 1 if prix == 0 : return True else : rendre_monnaie(prix) a= {} n = 0 tot_billet = {} listBillets = [20, 10, 5, 2, 1] rendre_monnaie(257) print (tot_billet)
-> {20: 12, 10: 1, 5: 1, 2: 1}

PS : je ne comprend pas le retour à la ligne après tot_Billet ?? on dois bien lire tot_billet
[listBillets[n]] = billet sur la meme ligne !!!

Bonjour,

Voilà une solution:

Code:

1
2
3
4
5
6
7
8
9
10
def rendre_monnaie(somme=0, monnaie=[]) :
    global caisse, prix
    #print("===>", somme, monnaie) # décommenter pour voir la recherche 
    monnaie = monnaie[:] # recopie indispensable
    for n in caisse:
        if somme+n==prix:
            return somme+n, monnaie+[n]
        if somme+n<prix:
            return rendre_monnaie(somme+n, monnaie+[n])
    return 0, [] # si échec

Il faut donner au départ la liste des pièces ou billets de la caisse (ordre décroissant des valeurs!), ainsi que le prix à payer.
Exemple:

Code:

1
2
3
4
5
caisse = [20, 10, 5, 2, 1]
prix = 58
 
somme, monnaie = rendre_monnaie()
print("Payé:", somme, "Rendu:", monnaie)

Ce qui donne dans ce cas:

Code:

Payé: 58 Rendu: [20, 20, 10, 5, 2, 1]

Compte tenu du principe de la recherche, il me semble que le nombre de pièces ou billets rendu est mini. Mais j'ai supposé ici que le nombre de chaque pièce ou billet de la caisse n'est pas limité. S'il était limité, il y aurait bien entendu des possibilités d'échec.

J'ai essayé cette fonction 1 million de fois avec des prix tirés au hasard , et je n'ai pas trouvé d'erreur.

Voilà un exemple de test aléatoire:

Code:

1
2
3
4
5
6
7
8
9
10
11
from random import randint
 
caisse = [20, 10, 5, 2, 1]
 
for i in range(0, 1000000):
    prix = randint(1,200)
    somme, monnaie = rendre_monnaie()
    print("prix:", prix, "payé:", somme, "monnaie:", monnaie)
    if somme!=sum(monnaie) or somme!=prix: # vérification de validité
        print("Echec!")
        break

Ce qui donne par exemple:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
...
prix: 12 payé: 12 monnaie: [10, 2]
prix: 114 payé: 114 monnaie: [20, 20, 20, 20, 20, 10, 2, 2]
prix: 157 payé: 157 monnaie: [20, 20, 20, 20, 20, 20, 20, 10, 5, 2]
prix: 14 payé: 14 monnaie: [10, 2, 2]
prix: 1 payé: 1 monnaie: [1]
prix: 117 payé: 117 monnaie: [20, 20, 20, 20, 20, 10, 5, 2]
prix: 57 payé: 57 monnaie: [20, 20, 10, 5, 2]
prix: 27 payé: 27 monnaie: [20, 5, 2]
prix: 127 payé: 127 monnaie: [20, 20, 20, 20, 20, 20, 5, 2]
prix: 157 payé: 157 monnaie: [20, 20, 20, 20, 20, 20, 20, 10, 5, 2]
...

1 pièce(s) jointe(s)

merci pour toutes vos réponses,
en fait l'énoncé est pour des novices c'est pourquoi les structures qui facilite la tâche que vous avez proposé ne marche pas pour cette énoncé voilà l'entête valide et le retour valide pour l'énoncé 8O: mais malheureusement y a des erreurs Pièce jointe 459595
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 def rendre_monnaie(prix, x20, x10, x5, x2, x1 ): if prix <x20: res20= None res10= None res5= None res2= None res1= None else: res20 = prix//x20 res10 = (prix%x20) //x10 res5 = (prix%x10) //x5 res2 = (prix%x5) //x2 res1 = (prix%x2) //x1 return res20,res10,res5,res2,res1

1 pièce(s) jointe(s)

je crois j'avais pas compris bien l'énoncé :
donc cette amélioration en ce code:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
def rendre_monnaie(prix, x20, x10, x5, x2, x1 ):
    liste_valeur_billet = (20, 10, 5, 2, 1)
    somme = x20*20+x10*10+x5*5+x2*2+x1*1
    if somme <prix:
        res20 = None
        res10 = None
        res5 = None
        res2 = None
        res1 = None
    else:
        res20 = prix // x20
        res10 = (prix % x20) // x10
        res5 = (prix % x10) // x5
        res2 =(prix % x5) // x2
        res1 = (prix % x2) // x1
    return res20,res10,res5,res2,res1

donne cette résultat:
Pièce jointe 459642

C'est déjà mieux, j'en propose une, que je ne peux tester sur ton système

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
def rendre_monnaie(prix, x20, x10, x5, x2, x1): 
    """
    Args:
        prix (int): somme à déterminer selon la monnaie dispo
        x20 (int): n billets de 20
        x10 (int): n billets de 10
        ...
    
    Returns:
        list of numbers of billets of 20, 10, 5, 2 and 1 in this order
    """
    billets = [
        (x20, 20),
        (x10, 10),
        (x5, 5),
        (x2, 2),
        (x1, 1)
    ]
    somme = prix
    total = sum([x*y for x, y in billets])
    if total < prix:
        return None
    resultat = []
    total = 0
    for n, valeur in billets:
        count = 0
        while prix // valeur >= 1 and n and prix:
            count += 1
            total += valeur
            prix = somme - total
            n -= 1
        resultat.append(count)
    return resultat
 
 
print(rendre_monnaie(85, 3, 1, 1, 5, 5)) # [3, 1, 1, 5, 0]
 
 
# 3 billets de 20,
# 1 billet de 10,
# 1 billet de 5,
# 5 pièces de 2
# aucune pièce de 1

20/03/2019, 16h07
flapili

il faut nous dire à quelle ligne correspond l'exception, ici il n'y a pas de ligne 25.
20/03/2019, 16h14
fred1599

Citation:

Envoyé par FATENMRABET

en fait j'ai une seule problème maintenant" Votre programme a été interrompu par une exception:
Ligne 25: ZeroDivisionError: integer division or modulo by zero", lorsque j'ajoute un while le programme ne donne rien:oops:

Tu parles de quel code ? Et aussi donne le message d'erreur entier !

Bonjour,

En n'utilisant que les fonctions de base de Python, voilà comment j'écrirais la fonction:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
def rendre_monnaie(prix, x20=20, x10=10, x5=5, x2=2, x1=1):
 
    res20 = prix//x20
    prix = prix - res20*x20
 
    res10 = prix//x10
    prix = prix - res10*x10
 
    res5 = prix//x5
    prix = prix - res5*x5
 
    res2 = prix//x2
    prix = prix - res2*x2
 
    res1 = prix//x1
    prix = prix - res1*x1
 
    return res20, res10, res5, res2, res1

resultat

salut à tous,
en fait voilà la résultat valide, il faut lire très bien l'énoncé, vos remarques ont aidés certainement

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
def rendre_monnaie(prix, x20, x10, x5, x2, x1):
    liste_valeur_billet = (20, 10, 5, 2, 1)
    n = len(liste_valeur_billet)
    somme = x20 * 20 + x10 * 10 + x5 * 5 + x2 * 2 + x1 * 1
    reste = somme - prix
    if somme <= prix:
        res20 = None
        res10 = None
        res5 = None
        res2 = None
        res1 = None
    else:
        res20 = reste // 20
        reste -= res20 * 20
        res10 = reste // 10
        reste -= res10 * 10
        res5 = reste // 5
        reste -= res5 * 5
        res2 = reste // 2
        reste -= res2 * 2
        res1 = reste // 1
    return res20, res10, res5, res2, res1

Citation:
Envoyé par tyrtamos
Bonjour,

En n'utilisant que les fonctions de base de Python, voilà comment j'écrirais la fonction:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 def rendre_monnaie(prix, x20=20, x10=10, x5=5, x2=2, x1=1): res20 = prix//x20 prix = prix - res20*x20 res10 = prix//x10 prix = prix - res10*x10 res5 = prix//x5 prix = prix - res5*x5 res2 = prix//x2 prix = prix - res2*x2 res1 = prix//x1 prix = prix - res1*x1 return res20, res10, res5, res2, res1
j'ai posté déjà auparavant cette résultat , bref pour l'entête c'est pas juste , il faut relire l'énoncé, tu peux voir la dernière solution valide que j'ai posté

Ouais mon code ça le faisait aussi, suffisait de modifier une ligne ;)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
def rendre_monnaie(prix, x20, x10, x5, x2, x1): 
    """
    Args:
        prix (int): somme à déterminer selon la monnaie dispo
        x20 (int): n billets de 20
        x10 (int): n billets de 10
        ...
    
    Returns:
        list of numbers of billets of 20, 10, 5, 2 and 1 in this order
    """
    billets = [
        (x20, 20),
        (x10, 10),
        (x5, 5),
        (x2, 2),
        (x1, 1)
    ]
    somme = prix
    total = sum([x*y for x, y in billets])
    if total < prix:
        return None
    resultat = []
    total = 0
    for n, valeur in billets:
        count = 0
        while prix // valeur >= 1 and n and prix:
            count += 1
            total += valeur
            prix = somme - total
            n -= 1
        resultat.append(count)
    res20, res10, res5, res2, res1 = resultat
    return res20, res10, res5, res2, res1 

print(rendre_monnaie(85, 3, 1, 1, 5, 5)) # [3, 1, 1, 5, 0]
 
 
# 3 billets de 20,
# 1 billet de 10,
# 1 billet de 5,
# 5 pièces de 2
# aucune pièce de 1