Flusskontrolle¶
Schaltjahr¶
Schreiben Sie eine Funktion, die überprüft, ob das übergebene Jahr ein Schaltjahr ist und entsprechend eine boolsche Variable zurück gibt. Ein Jahr ist ein Schaltjahr, wenn es durch 4 teilbar ist, aber nicht durch 100 oder wenn es durch 400 teilbar ist.
Lösung¶
def ist_schaltjahr(jahr):
if jahr % 400 == 0:
return True
if jahr % 4 == 0 and jahr % 100 != 0:
return True
return False
Schreiben Sie nun eine Funktion, die bestimmt, ob ein übergegebenes Datum tatsächlich existiert. Benutzen Sie dazu die soeben geschriebene Funktion.
Am simpelsten ist es, wenn Sie einfach jeweils einen Integer für Tag, Monat und Jahr übergeben.
Lösung¶
def datum_valide(tag, monat, jahr):
valide = True
if monat < 1 or monat > 12:
valide = False
if tag < 1 or tag > 31:
valide = False
if monat in [4, 6, 9, 11]:
if tag > 30:
valide = False
if monat == 2:
if ist_schaltjahr(jahr):
if tag > 29:
valide = False
elif tag > 28:
valide = False
return valide
Wechselgeld¶
Schreiben Sie eine Funktion, die einen Preis und einen bezahlten Geldbetrag entgegen nimmt, das zurückzuzahlende Wechselgeld berechnet und ausgibt, welche Scheine und Münzen zurück gegeben werden müssen, sodass die Anzahl der zurückgegebenen Scheine und Münzen minimal ist. Rechnen Sie mit Integern und ignorieren Sie Centbeträge.
Lösung¶
def berechne_wechselgeld(preis, bezahlt):
wechselgeld = bezahlt - preis
for banknote in [200, 100, 50, 20, 10, 5, 2, 1]:
print(f'{banknote:3d}€:', wechselgeld // banknote)
wechselgeld = wechselgeld % banknote
berechne_wechselgeld(127, 200)
200€: 0
100€: 0
50€: 1
20€: 1
10€: 0
5€: 0
2€: 1
1€: 1
Einstellige Quersumme¶
Schreiben Sie eine Funktion, die die einstellige Quersumme für eine übergebene natürliche Zahl berechnet. Um die einstellige Quersumme zu berechnen, bilden sie so lange die Quersumme der Quersumme der Quersumme etc. einer Zahl, bis das Ergebnis zwischen 1 und 9 liegt.
Lösung¶
def zaehl_ziffern(zahl):
'''Berechnet die Anzahl der Ziffern des übergebenen Integers'''
ziffern_anzahl = 0
while zahl // 10 != 0:
zahl //= 10
ziffern_anzahl += 1
return ziffern_anzahl
def quersumme(zahl):
quersumme = 0
ziffern_anzahl = zaehl_ziffern(zahl)
for dezimalstelle in range(ziffern_anzahl, -1, -1):
quersumme += zahl // (10**dezimalstelle)
zahl %= 10**dezimalstelle
return quersumme
def einstellige_quersumme(zahl):
einst_quersumme = zahl
while einst_quersumme > 9:
einst_quersumme = quersumme(einst_quersumme)
return einst_quersumme
# manche Probleme können auch rekursiv gelöst werden, was bedeutet, dass die ausführende Funktion sich selbst aufruft:
def einstellige_quersumme_rekursiv(zahl):
einst_quersumme = quersumme(zahl)
if einst_quersumme > 9:
einst_quersumme = einstellige_quersumme_rekursiv(einst_quersumme)
return einst_quersumme
Pythagoras¶
Schreiben Sie ein Programm, dass alle Integer Triplets \(a, b, c\) zwichen 1 und einer beliebigen Grenze findet, die die Gleichung
erfüllen. Was ist die Komplexität des Algorithmus? Spielen Sie ein bisschen mit der Grenze und achten Sie auf die Laufzeit ihres Programms um ein Gefühl dafür zu bekommen, was Komplexität bedeutet.
Lösung¶
def ist_pythagoreisches_trippel(a, b, c):
if a**2+b**2 == c**2:
return True
return False
grenze = 11
for a in range(1, grenze):
for b in range(1, grenze):
for c in range(1, grenze):
if ist_pythagoreisches_trippel(a, b, c):
print(f'{a}² + {b}² = {c}²')
3² + 4² = 5²
4² + 3² = 5²
6² + 8² = 10²
8² + 6² = 10²
Die Komplexität des obigen Algorithmus ist \(n^3\).