Flusskontrolle

Flusskontrolle#

Schaltjahr#

Um zu ermitteln, ob ein Jahr ein Schaltjahr ist, gibt es 3 Regelungen.

  • Ein Jahr ist ein Schaltjahr, wenn die Jahreszahl restlos durch 4 teilbar ist.

  • Ein Jahr ist kein Schaltjahr, wenn es durch 4 und 100 restlos teilbar ist.

  • Ein Jahr ist ein Schaltjahr, wenn es sowohl durch 4, durch 100 und durch 400 teilbar ist.

Aufgabenteil A#

Erstellen Sie ein Flussdiagramm, das j als Jahreszahl entgegen nimmt und als Rückgabe entweder True oder False ausgibt, je nach dem ob es sich um ein Schaltjahr handelt oder nicht

Lösung#

Aufgabenteil B#

Handelt es sich bei den Jahren 1800, 1996, 1997, 2000, 2016 um ein Schaltjahr?

Lösung#

Jahr

Ist Schaltjahr

1800

False

1996

True

1997

False

2000

True

2016

False

Aufgabenteil C#

Überfuhren sie das Flussdiagramm in ein Python Programm

Lösung#

Hide code cell content 
def ist_schaltjahr(jahr):
    if jahr % 4 == 0:
        if jahr % 100 == 0:
            if jahr % 400 == 0:
                return True
            else:
                return False
        else:
            return True
    else:
        return False

Augabenteil D#

Wie viele Tage ein Monat hat, hängt immer vom jeweiligen Monat selbst ab und im Falle vom Februar auch vom Jahr. Schreiben Sie eine weitere Funktion, die tag, monat und jahr entgegen nimmt und anschließend True oder False zurück gibt, je nach dem ob es sich um ein valides Datum handelt. Benutzen Sie dazu die zuvor geschriebene Methode.

Lösung#

Hide code cell content 
def datum_valide(tag, monat, jahr):
    if tag < 1 or monat < 1 or monat > 12:
        return False

    if monat == 2:
        if ist_schaltjahr(jahr):
            if tag > 29:
                return False
        else:
            if tag > 28:
                return False
    elif monat in [4, 6, 9, 11]:
        if tag > 30:
            return False
    else:
        if tag > 31:
            return False

    return True

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#

Hide code cell content 
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#

Hide code cell source 
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

(2.2)#\[\begin{equation} a² + b² =c² \end{equation}\]

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#

Hide code cell content 
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\).

Spannungs-Dehnungs-Diagramm#

Führt man mit Stahl einen Strecktest durch so erhält man folgendes idealisiertes Diagramm:

Dabei sind volgende Stellen von Bedeutung:

  1. Obere Streckgrenze

  2. Untere Streckgrenze

  3. Einschnürungspunkt

  4. Bruch

Für die folgende Aufgabe soll nur von idealisierten Werten ausgegangen werden.

Aufgabenteil A#

Erstellen Sie ein Flussdiagramm das sigma = σ [ 𝑁/𝑚𝑚2 ] als Liste entgegen nimmt und anhand dieser die Spannung der oberen Steckgrenze ermittelt und ausgibt.

Lösung#

Aufgabenteil B#

Überführen Sie das Flussdiagramm in ein Python Programm.

Lösung#

Hide code cell content 
def obere_streckgrenze(sigma):
    s1 = sigma[0]
    for s in sigma:
        if s < s1:
            return s1
        else:
            s1 = s

Aufgabenteil C#

Erstellen Sie ein Flussdiagramm das sigma = σ [ \(N/mm^2\) ] als Liste entgegen nimmt und anhand dieser alle relevanten Spannungen ausgibt.

Lösung#

Aufgabenteil D#

Überführen Sie das neue Flussdiagramm in ein Python Programm.

Lösung#

Hide code cell content 
def relevante_werte(sigma):
    n = len(sigma)
    s1 = sigma[0]
    i = 1
    while i < n:
        s2 = sigma[i]
        i += 1
        if s2 < s1:
            break
        else:
            s1 = s2
            
    while i < n:
        s3 = sigma[i]
        i += 1
        if s3 > s2:
            break
        else:
            s2 = s3
            
    while i < n:
        s4 = sigma[i]
        i += 1
        if s4 < s3:
            s4 = sigma[-1]
            return s1, s2, s3, s4
        else:
            s3 = s4

Wurzel ziehen#

Viele Algorithmen wirken auf dem ersten Blick sehr kompliziert und überwältigend. Doch bricht man sie in ihre Einzelteile auf, so erscheinen sie einem nicht mehr so schwer.

Der in dieser Aufgabe beschriebene Algorithmus kann aus allen N\(\space \in \mathbb{N}_{+}\{/0\}\) die Wurzel ziehen. In den folgenden Aufgaben soll dieser implementiert werden. Das Flussdiagramm sieht wie folgt aus:

Eine genauere Erklärung dieses Verfahrens ist in diesem Video zu finden.

Aufgabenteil A#

Führen Sie die Funktion Wurzel händisch für die Zahl N = 121 und N = 71289 durch und schreiben Sie die Werte für P, q und r der Hauptfunktion auf.

Lösung#

Für 121:
\(P = [1, 21]\)
\(p = 1\)
\(q = 1\)
\(r = 1 - 1² = 0\)

\(p = 21\) \(r = 0 \cdot 100 + 21 = 21\)
\(\space \space \space \space v = 1 \cdot 20 = 20\)
\(\space \space \space \space n = 21 // 20 = 1\)
\(\space \space \space \space 1 \cdot (20 + 1) = 21 \le 21\)
\(r = 21 - 21 = 0\)
\(q = 1 \cdot 10 + 1 = 11\)

Für 71289:
\(P = [7, 12, 89]\)
\(p = 7\)
\(q = 2\) \(r = 7 - 2² = 3\)

\(p = 12\)
\(r = 3 \cdot 100 + 12 = 312\)
\(\space \space \space \space v = 2 \cdot 20 = 40\)
\(\space \space \space \space n = 312 // 40 = 7\)
\(\space \space \space \space 7 \cdot (40 + 7) = 329 > 312\)
\(\space \space \space \space n = 7 - 1 = 6\)
\(\space \space \space \space 6 \cdot (40 + 6) = 276 \le 312\)
\(r = 312 - 276 = 36\) \(q = 2 \cdot 10 + 6 = 26\)

\(p = 89\)
\(r = 36 \cdot 100 + 89 = 3689\)
\(\space \space \space \space v = 26 \cdot 20 = 520\)
\(\space \space \space \space n = 3689 // 520 = 7\)
\(\space \space \space \space 7 \cdot (520 + 7) = 3689 \le 3689\)
\(r = 3689 - 3689 = 0\)
\(q = 26 \cdot 10 + 7 = 267\)

Aufgabenteil B#

Implementieren Sie die Funktion Päckchen und berechnen Sie mit dieser Funktion die Werte 20, 120, 1203 und 12035. Beschreiben Sie, was diese Funktion macht.

Lösung#

Hide code cell content 
def paeckchen(N):
    P = []
    n = N
    
    while n > 0:
        p = n % 100
        P.append(p)
        n = n // 100
    
    P.reverse()
    
    return P

print(paeckchen(20))
print(paeckchen(120))
print(paeckchen(1203))
print(paeckchen(12035))

[20]
[1, 20]
[12, 3]
[1, 20, 35]

Aufgabenteil C#

Implementieren Sie die Funktion Quadrat und berechnen Sie mit dieser Funktion die Werte 99, 30, 36 und 17. Beschreiben Sie, was diese Funktion macht.

Lösung#

Hide code cell content 
def quadrat(p):
    for v in [9,8,7,6,5,4,3,2,1,0]:
        if v ** 2 <= p:
            return v

print(quadrat(99))
print(quadrat(30))
print(quadrat(36))
print(quadrat(17))

9
5
6
4

Aufgabenteil D#

Implementieren Sie die Funktion Rest und berechnen Sie mit dieser Funktion die Werte (128, 4), (128, 2), (1289, 17) und (61289, 425). Beschreiben Sie, was diese Funktion macht.

Lösung#

Hide code cell content 
def rest(r, q):
    v = q * 20
    n = r // v
    
    while r < n * (v + n):
        n -= 1
    
    return r - n * (v + n), n

print(rest(128, 4))
print(rest(128, 2))
print(rest(1289, 17))
print(rest(61289, 425))

(47, 1)
(44, 2)
(260, 3)
(1740, 7)

Aufgabenteil E#

Implementieren Sie die Funktion Wurzel und berechnen Sie mit dieser Funktion die Werte 17, 476, 1097 und 6027341. Beschreiben Sie, was diese Funktion macht. Vergleichen Sie die errechneten Werte mit denen von einem Taschenrechner.

Lösung#

Hide code cell content 
def Wurzel(N):
    P = paeckchen(N)

    p = P[0]
    q = quadrat(p)
    r = p - q**2
    i = 1
    l = len(P)

    while (r > 0 or i < l) and i < l + 100:
        if i < l:
            p = P[i]
            r = r * 100 + p
        else:
            r = r * 100

        r, n = rest(r, q)
        q = q * 10 + n
        i += 1
    
    q = q / (10 ** (i - l))

    return q

print(Wurzel(17))
print(Wurzel(476))
print(Wurzel(1097))
print(Wurzel(6027341))

4.123105625617661
21.817424229271428
33.12099032335839
2455.064357608574