Python :: Aufgabe #276

4 Lösungen Lösungen öffentlich

Zahlen in Wörtern ausdrücken

Anfänger - Python von Gisbert5020 - 30.04.2020 um 15:17 Uhr
Schreiben Sie ein Programm, das Zahlen von 0 bis 99 in Wörtern fasst.
Zusatzaufgabe : Erweitern Sie das Programm von 0 bis 1000.

Lösungen:

1x
vote_ok
von torstenkn (150 Punkte) - 02.05.2020 um 00:00 Uhr
Einmal eine mögliche Lösung unter Verwendung von Rekursion (Methode ruft sich selbst auf um bei Zahlen über 100 die Wörter der letzten beiden Ziffern zu finden).

Quellcode ausblenden Python-Code
numberWord = {0: "null", 1: "ein", 2: "zwei", 3: "drei", 4: "vier",
              5: "fünf", 6: "sechs", 7: "sieben", 8: "acht",
              9: "neun", 10: "zehn", 11: "elf", 12: "zwölf",
              17: "siebzehn", 20: "zwanzig", 30: "dreißig", 40: "vierzig",
              50: "fünfzig", 60: "sechzig", 70: "siebzig",
              80: "achtzig", 90: "neunzig",
              100: "einhundert", 1000: "eintausend" }

def getNumberAsWord(number):
    if number == 1:
        return "eins"
    elif number == 0 or (number > 1 and number < 13) or number == 17 or (len(str(number)) == 2 and int(str(number)[1]) == 0) or number == 100 or number == 1000:
        return numberWord[number]
    elif number > 12 and number < 20:
        return numberWord[int(str(number)[1])] + numberWord[10 * int(str(number)[0])]
    elif number > 20 and number < 100:
        return numberWord[int(str(number)[1])] + "und" + numberWord[10 * int(str(number)[0])]
    elif number > 100 and number < 1000:
        return numberWord[int(str(number)[0])] + "hundert" + getNumberAsWord(int(str(number)[1:3]))
    
for i in range(1, 299):
    print(getNumberAsWord(i))

vote_ok
von daVinci (320 Punkte) - 13.05.2020 um 21:08 Uhr
Quellcode ausblenden Python-Code
###########################################################################################
# Aufgabe #276 - Wörter in Zahlen ausdrücken                                 [Hauptaufgabe]
###########################################################################################
#     ___________________________________
#____|  A u f g a b e n s t e l l u n g  |_________________________________________________
#
#       Schreiben Sie ein Programm, das Zahlen von 0 bis 99 in Wörtern fasst.
#                   Zusatzaufgabe: Erweitern Sie das Programm von 0 bis 1000.
#     _____________________________
#____|  I n f o r m a t i o n e n  |_______________________________________________________
#
#       Der "unausgeschmückte" Programmcode befindet sich ganz unten als Kommentar.
#
###########################################################################################
#=========================================================================| code by daVinci
###########################################################################################
#------------------------------------------------------------------------------------------
# Funktion für Wiederholungsabfrage
def wiederholen ():
    nochmal = input("Möchtest du noch eine Zahl als Wort ausgeben? [J]a / [N]ein: ")
    if not (nochmal == "j" or nochmal == "J"):
        return 1
#------------------------------------------------------------------------------------------
# Liste mit Einerstellen
LE = ["null", "ein", "zwei", "drei", "vier", "fünf", "sechs", "sieben", "acht",
      "neun"]
#------------------------------------------------------------------------------------------
# Liste mit Zehnerstellen
LZ = ["", "zehn", "zwanzig", "dreißig", "vierzig", "fünfzig", "sechzig",
      "siebzig", "achtzig", "neunzig"]
#------------------------------------------------------------------------------------------
# Liste/Dictonary mit "Sonderzahlen" - 0,11,12,13,14,15,16,17,18,19
LSZ = {"11": "elf", "12": "zwölf", "13": "dreizehn", "14": "vierzehn",
       "15": "fünfzehn", "16": "sechzehn", "17": "siebzehn", "18": "achtzehn",
       "19": "neunzehn"}
#------------------------------------------------------------------------------------------
# Variablen (Zeichenketten)
txt_zahl = "Deine Eingabe ist die Zahl ===> "
txt_ausgabe = "AUSGABE ALS WORT =============> "
#------------------------------------------------------------------------------------------
# Title und Beschreibung
print ("\n=====================================================================")
print ("                  -   WÖRTER IN ZAHLEN AUSDRÜCKEN   -")
print ("=====================================================================\n")
print ("Programm gibt die eingegebene Zahl als Wort aus. Die eingegebene Zahl")
print ("muss im Bereich von 0 bis einschließlich 1000 liegen.\n")
#------------------------------------------------------------------------------------------
# Schleife für erneute Eingabe (wenn gewünscht)
while True:
    print ("=====================================================================")
    eingabe_zahl = eval(input("Bitte eine Zahl (0 bis 1000) eingeben: "))
    print ("=====================================================================\n")
    #--------------------------------------------------------------------------------------
    # Eingabe außerhalb des Gültigkleitsbereiches
    if (eingabe_zahl < 0 or eingabe_zahl > 1000):
        print ("                    !     F  E  H  L  E  R     !")
        print ("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -")
        print ("Die eingegebene Zahl liegt nicht im Gültigkeitsbereich!")
        print ("Die Zahl muss im Bereich von 0 bis 1000 liegen.")
        print ("Versuchen Sie es nocheinmal...\n")
        continue
    #--------------------------------------------------------------------------------------
    # Eingabe liegt zwischen 0 und 10
    elif (eingabe_zahl < 10 and eingabe_zahl >= 0):
        print (txt_zahl, eingabe_zahl)
        print (txt_ausgabe, LE[eingabe_zahl], "\n")

        if wiederholen() == 1:
            break
        continue
    #--------------------------------------------------------------------------------------
    # Eingabe liegt zwischen 10 und 99
    elif (eingabe_zahl <= 99 and eingabe_zahl >= 10):
        zahl1_konvert = str(eingabe_zahl) [0:1]
        zahl2_konvert = str(eingabe_zahl) [1:]
        zk1 = int(zahl1_konvert)
        zk2 = int(zahl2_konvert)

        # Eingabe ist eine "Sonderzahl"
        if zk1 == 1:
            szk = str(eingabe_zahl)
            print (txt_zahl, eingabe_zahl)
            print (txt_ausgabe, LSZ[szk], "\n")

            if wiederholen() == 1:
                break
            continue

        # Eingabe ist eine 2-stellige Zahl und eine glatte Zehnerstelle
        elif zk2 == 0:
            #szk = str(eingabe_zahl)
            print (txt_zahl, eingabe_zahl)
            print (txt_ausgabe, LZ[zk1], "\n")

            if wiederholen() == 1:
                break
            continue

        # Eingabe ist eine 2-stellige Zahl, aber keine glatte Zehnerstelle
        else:
            print (txt_zahl, eingabe_zahl)
            print (txt_ausgabe, LE[zk2] + "und" + LZ[zk1], "\n")

            if wiederholen() == 1:
                break
            continue
    #--------------------------------------------------------------------------------------
    # Eingabe liegt zwischen 100 und 999
    elif (eingabe_zahl <= 999 and eingabe_zahl >= 100):
        zahl1_konvert = str(eingabe_zahl) [0:1]
        zahl2_konvert = str(eingabe_zahl) [1:2]
        zahl3_konvert = str(eingabe_zahl) [2:]
        sonder_konvert = str(eingabe_zahl) [1:]
        zk1 = int(zahl1_konvert)
        zk2 = int(zahl2_konvert)
        zk3 = int(zahl3_konvert)

        # Eingabe mit Sonderzahl (im Hunderter-Bereich)
        if zk2 == 1:
            szk = str(sonder_konvert)
            print (txt_zahl, eingabe_zahl)
            print (txt_ausgabe, LE[zk1] + "hundertund" + LSZ[szk], "\n")

            if wiederholen() == 1:
                break
            continue

        # Eingabe Glatte-Zehner-Zahl im Hunderter-Bereich
        elif (zk3 == 0 and zk2 == 0):
            print (txt_zahl, eingabe_zahl)
            print (txt_ausgabe, LE[zk1] + "hundert\n")

            if wiederholen() == 1:
                break
            continue

        # Eingabe Glatter Hunderter
        elif zk3 == 0:
            print (txt_zahl, eingabe_zahl)
            print (txt_ausgabe, LE[zk1] + "hundertund" + LZ[zk2], "\n")

            if wiederholen() == 1:
                break
            continue

        # Eingabe ist eine 3-stellige Zahl, aber keine glatte Zehnerstelle
        # und/oder Sonderzahl
        else:
            print (txt_zahl, eingabe_zahl)
            print (txt_ausgabe, LE[zk1] + "hundertund" + LE[zk3] + "und" + LZ[zk2], "\n")

            if wiederholen() == 1:
                break
            continue
    #--------------------------------------------------------------------------------------
    # Eingabe ist 1000
    elif eingabe_zahl == 1000:
        print (txt_zahl, eingabe_zahl)
        print ("AUSGABE ALS WORT =============>  eintausend\n")

        if wiederholen() == 1:
            break
        continue



###########################################################################################
# Unausgeschmückter Programmcode
###########################################################################################
# def wiederholen ():
#    nochmal = input("Möchtest du noch eine Zahl als Wort ausgeben? [J]a / [N]ein: ")
#    if not (nochmal == "j" or nochmal == "J"):
#        return 1
#
# LE = ["null", "ein", "zwei", "drei", "vier", "fünf", "sechs", "sieben", "acht",
#      "neun"]
#
# LZ = ["", "zehn", "zwanzig", "dreißig", "vierzig", "fünfzig", "sechzig",
#      "siebzig", "achtzig", "neunzig"]
#
# LSZ = {"11": "elf", "12": "zwölf", "13": "dreizehn", "14": "vierzehn",
#       "15": "fünfzehn", "16": "sechzehn", "17": "siebzehn", "18": "achtzehn",
#       "19": "neunzehn"}
#
# txt_zahl = "Deine Eingabe ist die Zahl ===> "
# txt_ausgabe = "AUSGABE ALS WORT =============> "
#
# while True:
#    eingabe_zahl = eval(input("Bitte eine Zahl (0 bis 1000) eingeben: "))
#
#    if (eingabe_zahl < 0 or eingabe_zahl > 1000):
#        print ("Die eingegebene Zahl liegt nicht im Gültigkeitsbereich!")
#        continue
#
#    elif (eingabe_zahl < 10 and eingabe_zahl >= 0):
#        print (txt_zahl, eingabe_zahl)
#        print (txt_ausgabe, LE[eingabe_zahl], "\n")
#
#        if wiederholen() == 1:
#            break
#        continue
#
#    elif (eingabe_zahl <= 99 and eingabe_zahl >= 10):
#        zahl1_konvert = str(eingabe_zahl) [0:1]
#        zahl2_konvert = str(eingabe_zahl) [1:]
#        zk1 = int(zahl1_konvert)
#        zk2 = int(zahl2_konvert)
#
#        if zk1 == 1:
#            szk = str(eingabe_zahl)
#            print (txt_zahl, eingabe_zahl)
#            print (txt_ausgabe, LSZ[szk], "\n")
#
#            if wiederholen() == 1:
#                break
#            continue
#
#        elif zk2 == 0:
#            #szk = str(eingabe_zahl)
#            print (txt_zahl, eingabe_zahl)
#            print (txt_ausgabe, LZ[zk1], "\n")
#
#            if wiederholen() == 1:
#                break
#            continue
#
#        else:
#            print (txt_zahl, eingabe_zahl)
#            print (txt_ausgabe, LE[zk2] + "und" + LZ[zk1], "\n")
#
#            if wiederholen() == 1:
#                break
#            continue
#
#    elif (eingabe_zahl <= 999 and eingabe_zahl >= 100):
#        zahl1_konvert = str(eingabe_zahl) [0:1]
#        zahl2_konvert = str(eingabe_zahl) [1:2]
#        zahl3_konvert = str(eingabe_zahl) [2:]
#        sonder_konvert = str(eingabe_zahl) [1:]
#        zk1 = int(zahl1_konvert)
#        zk2 = int(zahl2_konvert)
#        zk3 = int(zahl3_konvert)
#
#        if zk2 == 1:
#            szk = str(sonder_konvert)
#            print (txt_zahl, eingabe_zahl)
#            print (txt_ausgabe, LE[zk1] + "hundertund" + LSZ[szk], "\n")
#
#            if wiederholen() == 1:
#                break
#            continue
#
#        elif (zk3 == 0 and zk2 == 0):
#            print (txt_zahl, eingabe_zahl)
#            print (txt_ausgabe, LE[zk1] + "hundert\n")
#
#            if wiederholen() == 1:
#                break
#            continue
#
#        elif zk3 == 0:
#            print (txt_zahl, eingabe_zahl)
#            print (txt_ausgabe, LE[zk1] + "hundertund" + LZ[zk2], "\n")
#
#            if wiederholen() == 1:
#                break
#            continue
#
#        else:
#            print (txt_zahl, eingabe_zahl)
#            print (txt_ausgabe, LE[zk1] + "hundertund" + LE[zk3] + "und" + LZ[zk2], "\n")
#
#            if wiederholen() == 1:
#                break
#            continue
#
#    elif eingabe_zahl == 1000:
#        print (txt_zahl, eingabe_zahl)
#        print ("AUSGABE ALS WORT =============>  eintausend\n")
#
#        if wiederholen() == 1:
#            break
#        continue
#
###########################################################################################
###########################################################################################
vote_ok
von Nachbar (2810 Punkte) - 27.05.2020 um 20:58 Uhr
Quellcode ausblenden Python-Code
# -*- coding: utf-8 -*-

single = {"0":"null", "1":"eins", "2":"zwei", "3":"drei", "4":"vier", "5":"fünf", "6":"sechs", "7":"sieben", "8":"acht", "9":"neun"}
teens = {"10":"zehn", "11":"elf", "12":"zwölf", "13":"dreizehn", "14":"vierzehn", "15":"fünfzehn", "16":"sechzehn", "17":"siebzehn", "18":"achtzehn", "19":"neunzehn"}
tenner = {"2":"zwanzig", "3":"dreißig", "4":"vierzig", "5":"fünfzig", "6":"sechzig", "7":"siebzig", "8":"achtzig", "9":"neunzig"}

n = input("Zahl: ")

# 0 bis 99
def two_digit(n):
    # 1 - 9
    if len(n) == 1:
        output = single.get(n)
    elif len(n) == 2:
        # 01, 02, ..., 09 abfangen
        if n[0] == "0":
            return
        # 10 - 19
        elif n[0] == "1":
            output = teens.get(n)
        # 20, 30, ..., 90
        elif n[1] == "0":
            output = tenner.get(n[0])
        else:
            # 21, 31, ..., 91
            if n[1] == "1":
                output = "einund" + tenner.get(n[0])
            # alle anderen
            else:
                output = single.get(n[1]) + "und" + tenner.get(n[0])
    return output

# 100 bis 999
if len(n) == 3:
    last_two = two_digit(n[1:])
    # 100
    if n == "100":
        output = "einhundert"
    # 200, 300, ..., 900
    elif n[0] != "1":
        output = single.get(n[0]) + "hundert"
    # 101 - 109
    elif n[0] == "1" and n[1] == "0":
        output = single.get(n[0])[:-1] + "hundert" + single.get(n[2])
    elif n[1] == "0":
        output = single.get(n[0]) + "hundert" + single.get(n[2])
    else:
        # 110 - 999
        if n[0] == "1":
            output = single.get(n[0])[:-1] + "hundert" + last_two
        elif n[0] != "1":
            output = single.get(n[0]) + "hundert" + last_two
else:
    output = two_digit(n)

print(output)


vote_ok
von owl_curry (20 Punkte) - 25.07.2020 um 22:24 Uhr
Quellcode ausblenden Python-Code
""" AUFGABENSTELLUNG:
Schreiben Sie ein Programm, das Zahlen von 0 bis 99 in Woerter
fasst / uebersetzt.
Beispiel:
57 => siebenundfünfzig

Welche Zahl uebersetzt wird, ist via Usereingabe zu ermitteln

Zusatzaufgabe:
Erweitern Sie das Programm von 0 bis 1000

Eigener Zusatz:
Eingabekontrolle und Vorzeichen beachten
"""

# Dictionaries
einstellig = {"1":"ein","2":"zwei","3":"drei",
              "4":"vier","5":"fünf","6":"sechs",
              "7":"sieben","8":"acht","9":"neun"}

zig = {"2":"zwanzig","3":"dreizig","4":"vierzig",
       "5":"fünfzig","6":"sechzig","7":"siebzig",
       "8":"achtzig","9":"neunzig"}

hundert = {"1":"einhundert","2":"zweihundert","3":"dreihundert",
           "4":"vierhundert","5":"fünfhundert","6":"sechshundert",
           "7":"siebenhundert", "8":"achthundert","9":"neunhundert"}

special = {"1":"eins","11":"elf","12":"zwölf",
           "16":"sechzehn","17":"siebzehn","0":"null",
           "1000":"tausend"}

#Funktionen
def isitSpecial(zahl):
    #Teste Zahl
    if zahl in special:
        #Gib entsprechenden Wert zurueck
        return special[zahl]
    else:
        #Keine Special Zahl
        return "no"

def umwandlung(zahl):
    laenge = len(zahl)
    
    if laenge == 3:
        #Hole erstes Segment der Zahl
        abschnitt = hundert[zahl[0]]+"und"
        #Pruefe zweiten Abschnitt der Zahl auf Specialzahlen
        test = isitSpecial(zahl[1]+zahl[2])
        if test!="no": #Wenn Special
            #Kombiniere Abschnitt mit Specialsegment
            return abschnitt+test
        else: #Nichts Special
            #Teste ob reine hunderter Zahl, wenn nein
            if zahl[1] != "0" and zahl[2] != "0":
                #Kombiniere Abschnitt mit zweiten Segment
                return abschnitt+zweistellig(zahl[1],zahl[2])
            else: #wenn ja
                return hundert[zahl[0]]
    elif laenge == 2:
        #Weiterleitung an Funktion zweistellig
        return zweistellig(zahl[0],zahl[1])
    elif laenge == 1:
        #direkt in der Dict suchen
        return einstellig[zahl[0]]
    else:
        return "Es können bisher nur Zahlen von 0-1000 verarbeitet werden."


def zweistellig(stelle1,stelle2):
    if stelle1 != "1":
        if stelle1 in zig and stelle2 == "0":
            return zig[stelle1]
        elif stelle1 == "0" and stelle2 != "0":
            return einstellig[stelle2]
        else:
            return einstellig[stelle2] + "und" + zig[stelle1]
    else:
        return einstellig[stelle2]+"zehn"

def main():
    #Failsafe
    while True:
        #Frage nach Eingabe
        usereingabe=input("Gib eine Zahl von 0-1000 ein: ")
        try:
            #Versuche in Int umzuwandeln
            usereingabe = int(usereingabe)
            #Wandle zurueck in String um
            usereingabe = str(usereingabe)
            #Wenn Erfolgreich breche aus dem While aus
            break
        except:
            #Wenn nicht erfolgreich, gebe Fehlermeldung
            print("Die Eingabe konnte nicht verarbeitet werden.\nNur Zahlen bitte!")
    
    #Vorzeichenabdeckung
    vorzeichen = ""
    if usereingabe[0] == "-":
        vorzeichen = "minus "
        usereingabe = usereingabe.replace("-","")

    test = isitSpecial(usereingabe)
    if test == "no":
        ausgabe = umwandlung(usereingabe)
    else:
        ausgabe = test
    #Ausgabe der Uebersetzung
    print(vorzeichen + ausgabe.capitalize())


# Mainpart auslösen
if __name__ == "__main__":
    main()