Wechselgeld gegeben

[Ceauzey7]

Der Algorithmus bestimmt die Zusammensetzung der Währung (Banknoten und Münzen), den Anteil des Zahlers und den Anteil des Eigentümers. Er gibt den geringstmöglichen Geldbetrag zurück und gibt bei der Verteilung die 20-, 10- und 5-Euro-Scheine sowie die 2-, 1-Euro- und 50-, 20-, 10-, 5-, 2- und 1-Cent-Münzen zurück.

Wenn Sie eine Lösung finden, werden Sie nie das gewünschte Ergebnis erzielen. Bitte helfen Sie mir, meinen Fehler zu finden und sagen Sie mir, ob die Methode korrekt ist.

Hier ist der Algorithmus
a=float(input("Geben Sie den zu zahlenden Betrag ein:"))
b=float(input("Geben Sie den vom Käufer angegebenen Betrag ein:"))

Währung=b-a
Zähler=0

Währung>=20:
Währung=Währung-20
Zähler=Zähler+1
Drucken(Zähler,"20-Euro-Scheine")

Währung=Währung-(Zähler*20)
Zähler=0

Währung>=10:
Währung=Währung-10
Zähler=Zähler+1
Drucken(Zähler,"10-Euro-Scheine")

Währung=Währung-(Zähler*10)
Zähler=0

Währung>=5:
Währung=Währung-5
Zähler=Zähler+1
Drucken(Zähler,"5-Euro-Scheine")

Währung=Währung-(Zähler*5)
Zähler=0

Währung Währung>=2:
Währung=Währung-2
Zähler=Zähler+1
Drucken(Zähler, "2-Euro-Münzen")

Wechselgeld=Wechselgeld-(Zähler*2)
Zähler=0

Wechselgeld>=1:
Wechselgeld=Wechselgeld-1
Zähler=Zähler+1
Drucken(Zähler, "1-Euro-Münzen")

Wechselgeld=Wechselgeld-(Zähler*1)
Zähler=0

Wechselgeld>=0,50:
Wechselgeld=Wechselgeld-0,50
Zähler=Zähler+1
Drucken(Zähler, "50-Cent-Münzen")

Wechselgeld=Wechselgeld-(Zähler*0,50)
Zähler=0

Wechselgeld>=0,20:
Wechselgeld=Wechselgeld-0,20
Zähler=Zähler+1
Drucken(Zähler, "20-Cent-Münzen")

Wechselgeld=Wechselgeld-(Zähler*0,20)
Zähler=0

Wechselgeld>=0,20:
Wechselgeld=Wechselgeld-0,20
Zähler=0 Wechselgeld>=0,10:
Wechselgeld=Wechselgeld-0,10
Zähler=Zähler+1
Drucken(Zähler, "10-Cent-Münzen Cent")

Wechselgeld=Wechselgeld-(Zähler*0,10)
Zähler=0

Wechselgeld>=0,05:
Wechselgeld=Wechselgeld-0,05
Zähler=Zähler+1
Drucken(Zähler, "5-Cent-Münzen")

Wechselgeld=Wechselgeld-(Zähler*0,05)
Zähler=0

Wechselgeld>=0,02:
Wechselgeld=Wechselgeld-0,02
Zähler=Zähler+1
Drucken(Zähler, "2-Cent-Münzen")

Wechselgeld=Wechselgeld-(Zähler*0,02)
Zähler=0

Wechselgeld>=0,01:
Wechselgeld=Wechselgeld-0,01
Zähler=Zähler+1
Drucken(Zähler, "1-Cent-Münzen")

Wechselgeld=Wechselgeld-(Zähler*0,01)
Zähler=0

[oldboyJR]

das ist wie bit auflösen bzw- zahl zu bit

Code: Alles auswählen

fallSchulden = float((input ("Geben Sie den zu zahlenden Betrag ein:")))
gegeBetr = float((input ("Geben Sie den vom Käufer gegebenen Betrag ein:")))
Wechsg= float(0)
Wechsg = gegeBetr-fallSchulden 
if __name__ == '__main__':
    print (("sie müssen") , Wechsg , ("zurück geben"))
    Hund_ert = 0
    Fünf_zger = 0
    Zanz_ger = 0
    Zeh_ner = 0
    Fünf_er = 0 
    Zwei_er = 0
    Einer = 0 
    cent_50 = 0
    cent_20 = 0
    cent_10 = 0   
    cent_5 = 0
    cent_2 = 0
    cent_1 = 0
    
    
    if Wechsg >= 100.:
        Wechsg = Wechsg - 100.00
        Hund_ert = Hund_ert + 1
        
    if Wechsg >= 100.00:
         Wechsg = Wechsg - 100.00
         Hund_ert = Hund_ert + 1
            
    if Wechsg >= 100.00:
        Wechsg = Wechsg - 100.00
        Hund_ert = Hund_ert + 1   
    if Wechsg >= 100.00:
         Wechsg = Wechsg - 100.00
         Hund_ert = Hund_ert + 1
    if Wechsg >= 50: 
          Wechsg = Wechsg - 50
          Fünf_zger = Fünf_zger + 1
    if Wechsg >= 20: 
          Wechsg = Wechsg - 20
          Zanz_ger = Zanz_ger + 1 
    if Wechsg >= 20: 
          Wechsg = Wechsg - 20
          Zanz_ger = Zanz_ger + 1 
    if Wechsg >= 10: 
          Wechsg = Wechsg - 10
          Zeh_ner = Zeh_ner + 1    
    if Wechsg >= 5: 
          Wechsg = Wechsg - 5
          Fünf_er = Fünf_er + 1    
    if Wechsg >= 2: 
           Wechsg = Wechsg - 2
           Zwei_er = Zwei_er + 1     
    if Wechsg >= 2: 
           Wechsg = Wechsg - 2
           Zwei_er = Zwei_er + 1     
    if Wechsg >= 1: 
           Wechsg = Wechsg - 1
           Einer = Einer + 1      
    if Wechsg >= 0.5: 
          Wechsg = Wechsg - 0.5
          cent_50 = cent_50 + 1    
    if Wechsg >= 0.2: 
           Wechsg = Wechsg - 0.2
           cent_20 = cent_20 + 1     
    if Wechsg >= 0.2: 
           Wechsg = Wechsg - 0.2
           cent_20 = cent_20 + 1     
    if Wechsg >= 0.1: 
           Wechsg = Wechsg - 0.1
           cent_10 = cent_10 + 1  
    if Wechsg >= 0.05: 
          Wechsg = Wechsg - 0.05
          cent_5 = cent_5 + 1    
    if Wechsg >= 0.02: 
           Wechsg = Wechsg - 0.02
           cent_2 = cent_2 + 1     
    if Wechsg >= 0.02: 
           Wechsg = Wechsg - 0.02
           cent_2 = cent_2 + 1     
    if Wechsg >= 0.01: 
           Wechsg = Wechsg - 0.01
           cent_1 = cent_1 + 1                 
          
    print ("sie geben",Hund_ert ,"* 100€+ ",Fünf_zger ,"* 50€+ " ,Zanz_ger ,
           "* 20€+ ", Zeh_ner,"* 10€+ " ,Fünf_er , "* 5€+ ",Zwei_er ,"* 2€+ ", Einer,"* 1€+", 
           cent_50, "* 50cent+" ,cent_20, "* 20cen+" ,cent_10, "* 10cent+" ,cent_5, "* 5cent+" ,
           cent_2, "* 2cent+" ,cent_1 ,"* 1cent" )

[ThomasL]

So sieht dann ab jetzt wohl die Zukunft aus.
Chatbots füttern sich gegenseitig mit Slop.
Wie lange wollt ihr das hier tolerieren?

[mechanicalStore]

Nur weil's mich mal gereizt hat

Code: Alles auswählen

def calculate_atomic(index, betrag, data):
    keys = list(data.keys())
    key = keys[index]
    value = data[key]
    if betrag <= 0 or betrag < value[0]:
        return betrag
    else:
        value[1] += 1
        betrag -= value[0]
        return calculate_atomic(index, betrag, data)


def calculate(betrag, index, data):
    if betrag <= 0 or index == len(data):
        return
    next_betrag = calculate_atomic(index, betrag, data)
    return calculate(next_betrag, index + 1, data)


def main():
    data = {
        "1€-Stück(e)": [100, 0],
        "50-Cent-Stück(e)": [50, 0],
        "20-Cent-Stück(e)": [20, 0],
        "10-Cent-Stück(e)": [10, 0],
        "5-Cent-Stück(e)": [5, 0],
        "2-Cent-Stück(e)": [2, 0],
        "1-Cent-Stück(e)": [1, 0]
    }

    betrag = 242
    calculate(betrag, 0, data)
    print('Rückgeld für den Kunden:')
    for key, value in data.items():
        if value[1] > 0:
            print(f'{value[1]}*  {key}')


if __name__ == '__main__':
    main()

[Sirius3]

@ThomasL: Ceauzey7 hat sich die Frage einfach von seiner/ihrer Sprache ins Deutsche übersetzen lassen. Da wurde der Pythoncode auch verhunzt.
Bei olfboyR frage ich mich, ob eine KI so einen Quatsch dchreiben kann und trotzdem alle Variablennamen konsistent verhuntzt.

[Sirius3]

@mechanicalStore: über einen Index auf den Key und dann auf den Wert eines Wörtebuchs zuzugreifen, ist reichlich kompliziert:

Code: Alles auswählen

value = list(data.values())[index]

Aber auch das ist nicht pythonisch. Eigentlich solltest Du den key als Argument übergeben, oder gleich nur die Einheit.
Man sollteden Inhalt von Listen, die man als Argument ;ekommt, nicht ändern. Das führt oft zu schwer lokalisierbaren Fehlern.
Rekursion ist nur dann sinnvoll, wenn es das Problem deutlich verständlicher löst. Hier ist aber eine Schleife viel einfacher.

Code: Alles auswählen

def calculate_atomic(betrag, einheit):
    anzahl = 0
    while betrag >= einheit:
        anzahl += 1
        betrag -= einheit
        return anzahl, betrag

oder kurz, Teilen mit Rest:

Code: Alles auswählen

def calculate_atomic(betrag, einheit):
    return divmod(betrag, einheit)

[__blackjack__]

Lösung zu so einer Aufgabe in BASIC mit amerikanischer Währung die mittlerweile über ein halbes Jahrhundert alt ist:

Code: Alles auswählen

2 PRINT "I, YOUR FRIENDLY EDUSYSTEM COMPUTER, WILL DETERMINE"
3 PRINT "THE CORRECT CHANGE FOR ITEMS COSTING UP TO $100,"
4 PRINT\PRINT
10 PRINT "COST OF ITEM";\INPUT A\PRINT "AMOUNT OF PAYMENT";\INPUT P
20 C=P-A\M=C\IF C<>0 THEN 90 \PRINT "CORRECT AMOUNT,THANK YOU"
30 GO TO 10
90 IF C>0 THEN 90 \PRINT "SORRY,YOU HAVE SHORT CHANGED ME $";A-P
100 GO TO 10
120 PRINT "YOUR CMANGE,$";C\D=INT(C/10)\IF D=0 THEN 155
150 PRINT D;"TEN DOLLAR BILL(S)"
155 C=M-(D*10)\E=INT(C/5)\IF E=0 THEN 185
180 PRINT E;"FIVE DOLLAR BILL(S)"
185 C=M-(D*10+E*5)\F=INT(C)\IF F=0 THEN 215
210 PRINT F;"ONE DOLLAR BILL(S)"
215 C=M-(D*10+E*5+F)\C=C*100\N=C\G=INT(C/50)\IF G=0 THEN 255
250 PRINT G;"ONE-HALF DOLLAR(S)"
255 C=N-(G*50)\H=INT(C/25)\IF H=0 THEN 285
280 PRINT H;"QUARTER(S)"
285 C=N-(G*50+H*25)\I=INT(C/10)\IF I=0 THEN 315
310 PRINT I;"DIME(S)"
315 C=N-(G*50+H*25+I*10)\J=INT(C/5)\IF J=0 THEN 345
340 PRINT J;"NICKEL(S)"
345 C=N-(G*50+H*25+I*10+J*5)\K=INT(C+.5)\IF K=0 THEN 380
370 PRINT K;"PENNY(S)"
380 PRINT "THANK VOU,COME AGAIN"\PRINT \PRINT \GO TO 10
999 END

Quelle ist „101 BASIC Computer Games“ das 1973 erschienen ist. Lief vermutlich i Original auf einer PDP-8. Mehrere Anweisungen innerhalb einer Zeile werden durch `\` getrennt und `IF` hat die Besonderheit, dass man nach einem `THEN zeilennummer` noch Code schreiben kann, der im ”ELSE”-Fall ausgeführt wird.

Die immer länger werdenden Berechnungen für `C` wären vermeidbar gewesen, und DEC BASIC kennt auch `READ` und `DATA`, das heisst man hätte die Schein- und Münzwerte und die Namen der Scheine/Münzen als Daten herausziehen können, was das Programm deutlich einfacher anpassbar machen würde. Zum Beispiel um es auf andere Währungen umzuschreiben.

@Ceauzey7: Bitte den tatsächlichen Code zeigen, in einen Code-Block gesetzt, damit die Einrückung erhalten bleibt, die bei Python wichtiger Bestandteil der Syntax ist.

Dann wäre es auch hilfreich wenn Du den Fehler beschreiben würdest. Was erwartest Du und was macht das Programm stattdessen. Am besten von Beispieleingaben. Falls eine Fehlermeldung kommt, auch diese bitte 1:1 in einem Code-Block zeigen.

Was man als Algorithmus erahnen kann, sieht an sich richtig aus. Allerdings können Gleitkommazahlen Probleme machen, weil der Rechner viele Dezimalbrüche nur angenähert speichern kann. Das betrifft beispielsweise auch Werte wie 0.1, weil das intern im Binärsystem gespeichert wird, und dort hat 1/10 eine Periode. Wiederholtes addieren oder subtrahieren akkumuliert den Fehler. Es ist darum sicherer in Cent zu rechnen, also nur mit ganzen Zahlen.

Namen wie `a` und `b` sind zu nichtssagend. Da sollte man sprechendere Bezeichner verwenden.

Im Quelltext steht 11 mal nahezu identischer Code, der sich nur um einen Zahlwert und einen Text unterscheidet. Das sollte eine Schleife über Paare von Wert und Text sein, die den Code nur *einmal* im Schleifenkörper stehen hat.

[oldboyJR]

Erstmal Danke für das Profilisting: ich habe es mir gleich Kopiert und probiert. Die Anfrage des Ursprungs war in float und beginnt mit 50€ Scheine/n wobei dann 50 cent mit 0.5 zu buche schlägt. Um das lästige "." zu vermeiden könnte man mit 50000 Cent beginnen Und die Eingaben natürlich in int(cent_betrag) umformulieren. Aber als guter Programmierer kennt man das besser oder? Das mit dem wörterbuch kombiniert mit Schleife ist komplizierter und als unterdurchschnillicher Programmierer erlernungssbedürftig. Daran arbeite ich noch!!

[oldboyJR]

Den ersten teil verstehe ich so

Code: Alles auswählen

def calculate_atomic(index, betrag, data):
    keys = list(data.keys())
    key = keys[index]# Instanz von index(arreyZeilenargument beginnend mit 0  
    #nicht sichtbarer teil (außer im Variablenmanager )
    value = data[key]#der inhalt der Zeile des augenblicklichen key
    if betrag <= 0 or betrag < value[0]:#ist der Restbetrag aus betrag <= 0 
    #oder < als das erste Element in im augenblicklichen Value endet die Funktion hier und..
        return betrag #gebe Endergebnis Variable betrag zurück und macht unten unten??
    else:#if Bedingung ist nicht wahr
        value[1] += 1 #erhöht das zweite element im key um 1
        betrag -= value[0]# betrag ist nichtgleich dem ersten Element aus dem augenblicklichen value
        return calculate_atomic(index, betrag, data)# die Bedingung vor dem 
    #Return trift nicht zu und löst nochmals die Funktion calculate_atomic(index, betrag, data)
    

wie geht es weiter?? wenn er den betrag zurückgibt ist unten die zuweisung betrag ungültig und geht dann in die funktion calculate(betrag, index, data)??

[DeaD_EyE]

Code: Alles auswählen

#!/usr/bin/env python3

from collections import defaultdict
from decimal import Decimal, InvalidOperation


def change_money(
    basket: dict[int, int],
    amount: int,
) -> tuple[dict[int, int], dict[int, int], int]:
    """
    Im basket ist der Schlüssel ein int, der Cent representiert und
    der Wert repräsentiert die Menge des Wechselgeldes.

    amount wird als Cent interpretiert

    Zurückgegeben wird der veränderte basket, das wechselgeld und der Restbetrag
    Der Restbertrag sollte immer 0 sein, wenn genügend Wechselgeld vorhanden ist.
    """
    # kopie von basket, um das original nicht zu verändern
    basket = basket.copy()
    result: defaultdict[int, int] = defaultdict(int)

    for key in sorted(basket, reverse=True):
        n = min(amount // key, basket[key])

        if n != 0:
            basket[key] -= n
            result[key] += n
            amount -= n * key

    return basket, dict(result), int(amount)


basket = {
    1: 1000,
    2: 1000,
    5: 1000,
    10: 1000,
    20: 1000,
    50: 1000,
    1_00: 1000,
    2_00: 1000,
    5_00: 1000,
    10_00: 1000,
    20_00: 1000,
    50_00: 1000,
    100_00: 1000,
    500_00: 1000,
}


def show_basket(basket: dict[int, int]) -> None:
    for key, value in sorted(basket.items(), reverse=True):
        print(f"{key / 100:<6.2f} € => {value:>5}")


while True:
    try:
        user_input = input("Bitte Betrag in € angeben (q/Q): ").replace(",", ".")
    except KeyboardInterrupt:
        print()
        break
    if not user_input or user_input.lower() == "q":
        break

    try:
        betrag_cent = int(Decimal(user_input) * 100)
    except InvalidOperation:
        print(f"Ungültige Eingabe: '{user_input}'\n")
        continue

    new_basket, wechselgeld, rest = change_money(basket, betrag_cent)
    basket = new_basket

    print("Vorhandenes Wechselgeld:")
    show_basket(basket)

    print("\nWechselgeld:")
    show_basket(wechselgeld)

    print(f"\nRest: {rest / 100:.2f} €\n")

[Sirius3]

@DeaD_EyE: statt einer Kopie erzeugt man einfach ein neues Wörterbuch. Das defaultdict ist überflüssig, da jeder key nur einmal vorkommt. amount sollte bereits ein int sein.
Bleibt also das übrig:

Code: Alles auswählen

def change_money(basket, amount):
    """
    Im basket ist der Schlüssel ein int, der Cent representiert und
    der Wert repräsentiert die Menge des Wechselgeldes.

    amount wird als Cent interpretiert

    Zurückgegeben wird der veränderte basket, das wechselgeld und der Restbetrag
    Der Restbertrag sollte immer 0 sein, wenn genügend Wechselgeld vorhanden ist.
    """
    # kopie von basket, um das original nicht zu verändern
    result_basket = dict()
    return_money = dict()

    for key in sorted(basket, reverse=True):
        n = min(amount // key, basket[key])
        result_basket[key] = basket[key] - n
        if n != 0:
            return_money[key] = n
            amount -= n * key

    return result_basket, return_money, amount

[oldboyJR]

DeaD_EyE Danke, Das ist ein super tolles Listing. Man kann angeben wieviel Wechselgeld in welchen werten man im Geldbeutel hat. Wenn man nur zwei Hunderter hat dafür aber jede Menge Fünfziger dann wird mit mehr Fünzigern gerechnet. Das ist viel schicker als erwartet. Das ..

Code: Alles auswählen

user_input = input("Bitte Betrag in € angeben (q/Q): ").replace(",", ".")

ist etwas wo ein unterdurchschnittlicher nicht so schnell hinkommt!! Das mit dem mal 100 und wieder zurück hatte ich in Java ähnlich behandelt wegen den unendlichen Nachkommastellen in BigDezimal und der Genauigkeit.

[oldboyJR]

Damit das dem ersten Post noch näher kommt fehlten noch zwei Vorgaben

Code: Alles auswählen

"""
Created on Sat Oct 25 21:59:12 2025

@author: DeaD_EyE
"""

from collections import defaultdict
from decimal import Decimal, InvalidOperation


def change_money(
    basket: dict[int, int],
    amount: int,
) -> tuple[dict[int, int], dict[int, int], int]:
    """
    Im basket ist der Schlüssel ein int, der Cent representiert und
    der Wert repräsentiert die Menge des Wechselgeldes.

    amount wird als Cent interpretiert

    Zurückgegeben wird der veränderte basket, das wechselgeld und der Restbetrag
    Der Restbertrag sollte immer 0 sein, wenn genügend Wechselgeld vorhanden ist.
    """
    # kopie von basket, um das original nicht zu verändern
    basket = basket.copy()
    result: defaultdict[int, int] = defaultdict(int)

    for key in sorted(basket, reverse=True):
        n = min(amount // key, basket[key])

        if n != 0:
            basket[key] -= n
            result[key] += n
            amount -= n * key

    return basket, dict(result), int(amount)


basket = {
    1: 1000,
    2: 1000,
    5: 1000,
    10: 1000,
    20: 1000,
    50: 1000,
    1_00: 1000,
    2_00: 1000,
    5_00: 1000,
    10_00: 1000,
    20_00: 1000,
    50_00: 1000,
    100_00: 1000,
    500_00: 1000,
}

user_input = int( 0)
def show_basket(basket: dict[int, int]) -> None:
    for key, value in sorted(basket.items(), reverse=True):
        print(f"{key / 100:<6.2f} € => {value:>5}")


while True:
    try:
        
        user_input1 = input("Bitte die Rechnungssumme  in € angeben (q/Q): ").replace(",", ".")
        betrag_cent1 = int(Decimal(user_input1) * 100)
        user_input2 = input("Bitte den vom Kunden erhaltenen Betrag in € angeben (q/Q): ").replace(",", ".")
        betrag_cent2 = int(Decimal(user_input2) * 100)
        user_input = betrag_cent2-betrag_cent1
        print ("Sie müssen ", user_input/100 ,(" Wechselgeld herausgeben"))
    except KeyboardInterrupt:
        print()
        break
    if not user_input1 or user_input1.lower() == "q":
        break

    try:
        betrag_cent = user_input
    except InvalidOperation:
        print(f"Ungültige Eingabe: '{user_input}'\n")
        continue

    new_basket, wechselgeld, rest = change_money(basket, betrag_cent)
    basket = new_basket

    print("Vorhandenes Wechselgeld:")
    show_basket(basket)
    print ("Sie müssen ", user_input/100 ,(" Wechselgeld herausgeben"))
    print("\nWechselgeld:")
    show_basket(wechselgeld)

    print(f"\nRest: {rest / 100:.2f} €\n")

[DeaD_EyE]

@DeaD_EyE: statt einer Kopie erzeugt man einfach ein neues Wörterbuch. Das defaultdict ist überflüssig, da jeder key nur einmal vorkommt. amount sollte bereits ein int sein.
Bleibt also das übrig:

Manchmal sieht man den Code vor lauter Bäumen nicht.

[Pedroski55]

In Spanien, die meisten Cafes heutzutge haben ein Tresor, man steckt Geld hinein und der Tresor berechnet dann das Rückgeld. Ich war in Spanien als der "Apagon" geschah, ganz Spanien ohne Strom, wo ich war 24 Stunden lang. Die Cafe Besitzer waren hilflos, sie können nicht mehr mit Bargeld umgehen!

Mache alles zu Cent, das vereinfacht die Sache!

Code: Alles auswählen

import regex

def myApp():
    # e = regex.compile(r'(\d+,\d+)|(\d+.\d+)|(\d+)')
    # gibt eins von den Dreien zurück, die zwei anderen werden None sein
    # res = e.search(preis) # res.groups() = ('51,51', None, None)

    # Geldspeicher
    euros_list = [200, 100, 50, 20,  10,  5,  2, 1]
    cents_list = [50, 20, 10, 5, 2, 1]
    # alles ist cent
    cents = [e * 100 for e in euros_list]
    cents = cents + cents_list
     # fange mit 100 der jeweiligen Scheine odeer Münzen an
    cents_dict = {c: 100 for c in cents}
    ##for item in cents_dict.items():
    ##    print(item)
        
    # ist die Zahl einfach, dies gleicht mal 100
    def num_is_int(num):
        num = num + '00'
        return int(num)

    # dezimal mit comma für die Deutschen
    def num_comma(num):
        num_list = num.split(',')
        if len(num_list[1]) == 2:
            cents = ''.join(num_list)
            return int(cents)
        elif len(num_list[1]) > 2:
            # 2 Stellen nach dem , muss gut sein hier
            # auf dem Finanzmarkt hätte man vielleicht 6 of 8 stellen nach dem ,
            # kann geändert werden
            print(f'num_list[1] before {num_list[1]}')
            num_list[1] = num_list[1][0:2]
            print(f'num_list[1] after {num_list[1]}')
            cents = ''.join(num_list)
            return int(cents)
        elif len(num_list[1]) < 2:
            while  len(num_list[1]) < 2:
                    num_list[1] = num_list[1] + '0'
            cents = ''.join(num_list)
            return int(cents)

    # dezimal mit Punkt für Andersartigen
    def num_punkt(num):    
        num_list = num.split('.')
        if len(num_list[1]) == 2:
            cents = ''.join(num_list)
            return int(cents)
        elif len(num_list[1]) > 2:
            # 2 Stellen nach dem . muss gut sein hier
            # auf dem Finanzmarkt hätte man vielleicht 6 of 8 stellen nach dem . 
            # kann geändert werden
            num_list[1] = num_list[1][0:2]
            cents = ''.join(num_list)
            return int(cents)
        elif len(num_list[1]) < 2:
            while  len(num_list[1]) < 2:
                num_list[1] = num_list[1] + '0'
            cents = ''.join(num_list)
            return int(cents)

    # num hat Format Integer or Dezimal mit , oder Dezimal mit .
    def sort_nums(num):
        if ',' in num:
            res = num_comma(num)
            print(res)
            return res
        elif '.' in num:
            res = num_punkt(num)
            return res
        else:
            res = num_is_int(num)
            return res

    def get_cents(cents):
        possible = []
        for key in cents_dict.keys():
            if key <= cents:
                print(key, cents)
                possible.append(key)
        return possible

    # preis sollte eigentlich irgendwo gespeichert sein
    # wenn ein Tolpatsch mit dicken Fingern Unsin schreibt, solange die Zahlen zusammen sind, kriegen wir die heraus
    # zB $b31.67bbb
    preis = input("Geben Sie den zu zahlenden Betrag ein: ")
    # eine Grupppe sollte wohl vorhanden sein, zwei nicht
    e = regex.compile(r'(\d+,\d+)|(\d+.\d+)|(\d+)')
    res = e.search(preis)
    preis = [p for p in res.groups() if p != None][0] # eingegeben $$25.75yyy, nun preis = '25.75'

    bargeld = input("Geben Sie den vom Käufer  überreichten Betrag ein: ") # zB #$%100
    res = e.search(bargeld)
    bargeld = [b for b in res.groups() if b != None][0] # 100
    restgeld = sort_nums(bargeld) - sort_nums(preis)

    nums = get_cents(restgeld) # preis 51.51 bargeld 100 restgeld 4849 ergibt volgenden Zahlen
    ##"""2000 4849
    ##1000 4849
    ##500 4849
    ##200 4849
    ##100 4849
    ##50 4849
    ##20 4849
    ##10 4849
    ##5 4849
    ##2 4849
    ##1 4849
    ##[2000, 1000, 500, 200, 100, 50, 20, 10, 5, 2, 1] """

    tuples = []
    for num in nums:
        if num > restgeld:
            print(f'num {num} > restgeld {restgeld} wir verzichten auf {num} ... ')
            continue
        else:
            multiplier = restgeld // num
            restgeld= restgeld - (num * multiplier)
            print(f'num  = {num}, multiplier = {multiplier}  restgeld = {restgeld} ... ')
            tup = (num / 100, multiplier)
            tuples.append(tup)
            # ziehe mulitiplier vom cents_dict[num] eventuell wird nichts mehr sein. Was dann tun?
            cents_dict[num] = cents_dict[num] - multiplier
            if restgeld == 0:
                break

     # welche Scheine oder Münzen nötig sind, und wie viele davon    
    for tup in tuples:
        print(f'Zurückzugeben ist €{tup[0]} mal {tup[1]}.')

    # wenn eine Sorte nicht mehr vorhanden ist, muss man ausweichen, oder nachladen. Bleibt noch zu tun
    print('\nSoviel bleibt noch über \n
    for item in cents_dict.items():
        print(item)