Aufgaben

Hier sind alle Aufgaben des Kurses an einem Ort. Zuerst 50 eigenständige Aufgaben von „Hallo, Welt“ bis zum kürzesten Weg in einem Raster, jede mit einem Beispiel und einer Lösung in Python, geprüft mit einem echten Compiler. Danach die Aufgaben aus den Lektionen, nach Modulen: Jede führt zu der Lektion, die erklärt, was du brauchst.

50 Aufgaben zum Üben

1. Hello World
Gib den Text Hello, World! auf der Konsole aus. Das Programm hat keine Eingabe.
Keine Eingabe.
Ausgabe
```
Hello, World!
```
Was du brauchst, steht in der Lektion: Dein erstes Programm
Lösung
```
print("Hello, World!")
```
2. Begrüße den Benutzer
Lies einen Namen aus einer Zeile und begrüße die Person mit ihrem Namen in der Form „Hallo, <Name>!“.
Eingabe
```
Maria
```
Ausgabe
```
Hallo, Maria!
```
Was du brauchst, steht in der Lektion: Eingabe und Ausgabe
Lösung
```
name = input()
print("Hallo, " + name + "!")
```
3. Das Alter ausgeben
Lies das Alter des Benutzers (eine ganze Zahl), speichere es in einer Variablen und gib es in einem Satz aus.
Eingabe
```
17
```
Ausgabe
```
Du bist 17 Jahre alt.
```
Was du brauchst, steht in der Lektion: Variablen und Typen
Lösung
```
age = int(input())
print("Du bist " + str(age) + " Jahre alt.")
```
4. Einheitenumrechner
Lies eine Länge in Zoll (sie kann eine Dezimalzahl sein) und rechne sie in Zentimeter um: 1 Zoll = 2,54 cm. Gib das Ergebnis mit 2 Nachkommastellen aus.
Eingabe
```
12.5
```
Ausgabe
```
31.75 cm
```
Was du brauchst, steht in der Lektion: Operatoren und Arithmetik
Lösung
```
inches = float(input())
print(f"{inches * 2.54:.2f} cm")
```

5. Gerade oder ungerade

Lies eine ganze Zahl und gib aus, ob sie gerade oder ungerade ist.

7 ist ungerade.

Was du brauchst, steht in der Lektion: Bedingungen

Lösung

number = int(input())
if number % 2 == 0:
    print(str(number) + " ist gerade.")
else:
    print(str(number) + " ist ungerade.")

6. Summe zweier Zahlen
Lies zwei ganze Zahlen, jede in einer eigenen Zeile, und gib ihre Summe aus.
Eingabe
```
12
30
```
Ausgabe
```
Die Summe ist 42.
```
Was du brauchst, steht in der Lektion: Operatoren und Arithmetik
Lösung
```
first = int(input())
second = int(input())
print("Die Summe ist " + str(first + second) + ".")
```
7. Fläche eines Quadrats
Lies die Seitenlänge eines Quadrats (eine ganze Zahl) und gib seinen Flächeninhalt aus.
Eingabe
```
5
```
Ausgabe
```
Der Flächeninhalt ist 25.
```
Was du brauchst, steht in der Lektion: Operatoren und Arithmetik
Lösung
```
side = int(input())
print("Der Flächeninhalt ist " + str(side * side) + ".")
```
8. Volumen einer Kugel
Lies den Radius r (er kann eine Dezimalzahl sein) und gib das Volumen der Kugel V = 4/3 · π · r³ mit 2 Nachkommastellen aus.
Eingabe
```
3
```
Ausgabe
```
Das Volumen ist 113.10.
```
Was du brauchst, steht in der Lektion: Operatoren und Arithmetik
Lösung
```
import math

r = float(input())
volume = 4 / 3 * math.pi * r ** 3
print(f"Das Volumen ist {volume:.2f}.")
```
9. Zwei Zahlen vergleichen
Lies zwei ganze Zahlen, jede in einer eigenen Zeile, und gib die größere aus (wenn sie gleich sind, egal welche).
Eingabe
```
8
15
```
Ausgabe
```
Die größere Zahl ist 15.
```
Was du brauchst, steht in der Lektion: Bedingungen
Lösung
```
a = int(input())
b = int(input())
if a > b:
    print("Die größere Zahl ist " + str(a) + ".")
else:
    print("Die größere Zahl ist " + str(b) + ".")
```
10. Dreiecksprüfung
Lies drei ganze Zahlen, jede in einer eigenen Zeile, und prüfe, ob sie die Seiten eines Dreiecks sein können: Die Summe von je zwei muss größer sein als die dritte.
Eingabe
```
3
4
5
```
Ausgabe
```
Sie können ein Dreieck bilden.
```
Was du brauchst, steht in der Lektion: Bedingungen
Lösung
```
a = int(input())
b = int(input())
c = int(input())
if a + b > c and a + c > b and b + c > a:
    print("Sie können ein Dreieck bilden.")
else:
    print("Sie können kein Dreieck bilden.")
```
11. Note in Worten
Lies eine Note von 2 bis 6 (6 ist die beste; die Note kann eine Dezimalzahl sein) und gib sie in Worten aus: ab 5,50 Ausgezeichnet, ab 4,50 Sehr gut, ab 3,50 Gut, ab 3,00 Ausreichend, unter 3,00 Ungenügend.
Eingabe
```
4.75
```
Ausgabe
```
Sehr gut
```
Was du brauchst, steht in der Lektion: Bedingungen
Lösung
```
grade = float(input())
if grade >= 5.5:
    print("Ausgezeichnet")
elif grade >= 4.5:
    print("Sehr gut")
elif grade >= 3.5:
    print("Gut")
elif grade >= 3:
    print("Ausreichend")
else:
    print("Ungenügend")
```
12. Stunden in Sekunden
Lies eine Anzahl Stunden (eine ganze Zahl) und gib aus, wie viele Sekunden das sind.
Eingabe
```
2
```
Ausgabe
```
7200 Sekunden
```
Was du brauchst, steht in der Lektion: Operatoren und Arithmetik
Lösung
```
hours = int(input())
print(str(hours * 3600) + " Sekunden")
```
13. Zählen bis N
Lies eine ganze Zahl N und gib die Zahlen von 1 bis N aus, jede in einer neuen Zeile.
Eingabe
```
5
```
Ausgabe
```
1
2
3
4
5
```
Was du brauchst, steht in der Lektion: Schleifen
Lösung
```
n = int(input())
for i in range(1, n + 1):
    print(i)
```
14. ASCII-Wert
Lies ein Zeichen (das erste Zeichen der Zeile) und gib seinen ASCII-Code aus, also die Zahl, als die der Computer es speichert.
Eingabe
```
A
```
Ausgabe
```
Der Code von A ist 65.
```
Was du brauchst, steht in der Lektion: Strings: mit Text arbeiten
Lösung
```
symbol = input()[0]
print("Der Code von " + symbol + " ist " + str(ord(symbol)) + ".")
```

15. Quadratische Gleichung

Lies a, b und c, jeweils in einer eigenen Zeile, und löse die Gleichung ax² + bx + c = 0. Bei zwei Lösungen gib „x1 = …, x2 = …“ aus (x1 ist die mit +√D), bei einer „x = …“, jeweils mit 2 Nachkommastellen; wenn es keine reellen Lösungen gibt oder a gleich 0 ist, sag es.

1
-3
2

x1 = 2.00, x2 = 1.00

Was du brauchst, steht in der Lektion: Bedingungen

Lösung

import math

a = float(input())
b = float(input())
c = float(input())
if a == 0:
    print("Das ist keine quadratische Gleichung")
else:
    d = b * b - 4 * a * c
    if d > 0:
        x1 = (-b + math.sqrt(d)) / (2 * a)
        x2 = (-b - math.sqrt(d)) / (2 * a)
        print(f"x1 = {x1:.2f}, x2 = {x2:.2f}")
    elif d == 0:
        print(f"x = {-b / (2 * a):.2f}")
    else:
        print("Keine reellen Lösungen")

16. Positiv oder negativ
Lies eine ganze Zahl und gib aus, ob sie positiv, negativ oder null ist.
Eingabe
```
-4
```
Ausgabe
```
Negativ
```
Was du brauchst, steht in der Lektion: Bedingungen
Lösung
```
number = int(input())
if number > 0:
    print("Positiv")
elif number < 0:
    print("Negativ")
else:
    print("Null")
```

17. Jahreszeiten

Lies die Nummer eines Monats (1–12) und gib die Jahreszeit aus: 12, 1, 2 Winter, 3–5 Frühling, 6–8 Sommer, 9–11 Herbst. Bei jeder anderen Zahl gib „Ungültiger Monat“ aus.

Frühling

Was du brauchst, steht in der Lektion: Bedingungen

Lösung

month = int(input())
if month < 1 or month > 12:
    print("Ungültiger Monat")
elif month == 12 or month <= 2:
    print("Winter")
elif month <= 5:
    print("Frühling")
elif month <= 8:
    print("Sommer")
else:
    print("Herbst")

18. Zahl umdrehen
Lies eine positive ganze Zahl und gib die Zahl mit ihren Ziffern in umgekehrter Reihenfolge aus: Aus 123 wird 321. Nullen, die dabei nach vorne kommen, verschwinden (aus 1200 wird 21). Nimm die letzte Ziffer mit % 10 und entferne sie, indem du durch 10 teilst.
Eingabe
```
9071
```
Ausgabe
```
1709
```
Was du brauchst, steht in der Lektion: Schleifen
Lösung
```
n = int(input())
reversed_n = 0
while n > 0:
    reversed_n = reversed_n * 10 + n % 10
    n //= 10
print(reversed_n)
```
19. Temperaturumrechner
Lies eine Temperatur in Grad Celsius (sie kann eine Dezimalzahl mit Punkt sein) und gib sie in Fahrenheit mit zwei Nachkommastellen aus. Die Formel ist F = C * 9 / 5 + 32.
Eingabe
```
36.6
```
Ausgabe
```
97.88 °F
```
Was du brauchst, steht in der Lektion: Operatoren und Arithmetik
Lösung
```
celsius = float(input())
fahrenheit = celsius * 9 / 5 + 32
print(f"{fahrenheit:.2f} °F")
```
20. Längster Name
In der ersten Zeile steht die Anzahl der Namen n, in den nächsten n Zeilen je ein Name. Gib den Namen mit den meisten Buchstaben und deren Anzahl in Klammern aus; sind zwei Namen gleich lang, gib den ersten davon aus.
Eingabe
```
4
Mia
Alexandra
Jonas
Charlotte
```
Ausgabe
```
Alexandra (9 Buchstaben)
```
Was du brauchst, steht in der Lektion: Strings: mit Text arbeiten
Lösung
```
n = int(input())
longest = ""
for i in range(n):
    name = input()
    if len(name) > len(longest):
        longest = name
print(f"{longest} ({len(longest)} Buchstaben)")
```
21. Wörter zählen
Lies eine Zeile Text und gib aus, wie viele Wörter sie hat. Die Wörter sind durch ein oder mehrere Leerzeichen getrennt, die leeren Stücke zwischen zwei Leerzeichen sind also keine Wörter.
Eingabe
```
Ich schreibe  jeden Tag Code und   werde besser
```
Ausgabe
```
8
```
Was du brauchst, steht in der Lektion: Strings: mit Text arbeiten
Lösung
```
line = input()
words = line.split()
print(len(words))
```

22. Primzahl

Lies eine ganze Zahl n und prüfe, ob sie eine Primzahl ist: größer als 1 und nur durch 1 und sich selbst teilbar. Es reicht, die Teiler i zu probieren, für die i * i <= n gilt.

91 ist keine Primzahl

Was du brauchst, steht in der Lektion: Schleifen

Lösung

n = int(input())
prime = n > 1
i = 2
while i * i <= n:
    if n % i == 0:
        prime = False
        break
    i += 1
if prime:
    print(f"{n} ist eine Primzahl")
else:
    print(f"{n} ist keine Primzahl")

23. Wochentag
Lies eine Zahl von 1 bis 7 und gib den Namen des Wochentags auf Deutsch aus, wobei 1 Montag ist. Halte die Namen in einem Array; bei jeder anderen Zahl gib „Diesen Tag gibt es nicht“ aus.
Eingabe
```
5
```
Ausgabe
```
Freitag
```
Was du brauchst, steht in der Lektion: Listen
Lösung
```
day = int(input())
days = ["Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag", "Samstag", "Sonntag"]
if 1 <= day <= 7:
    print(days[day - 1])
else:
    print("Diesen Tag gibt es nicht")
```
24. Fakultät
Lies eine ganze Zahl n von 0 bis 15 und gib n! = 1 * 2 * … * n aus (0! ist 1). Schon 13! passt nicht in einen int, deshalb speicherst du das Produkt in Java und C# in einem long.
Eingabe
```
15
```
Ausgabe
```
15! = 1307674368000
```
Was du brauchst, steht in der Lektion: Schleifen
Lösung
```
n = int(input())
factorial = 1
for i in range(2, n + 1):
    factorial *= i
print(f"{n}! = {factorial}")
```
25. Gültiges Datum
Lies einen Tag, einen Monat und ein Jahr, jeweils in einer eigenen Zeile, und gib „Gültiges Datum“ oder „Ungültiges Datum“ aus. Das Jahr ist mindestens 1, der Monat liegt zwischen 1 und 12 und der Tag zwischen 1 und der Anzahl der Tage in diesem Monat; der Februar hat in einem Schaltjahr 29 Tage (durch 4 teilbar, aber nicht durch 100, außer es ist durch 400 teilbar).
Eingabe
```
29
2
2100
```
Ausgabe
```
Ungültiges Datum
```
Was du brauchst, steht in der Lektion: Bedingungen
Lösung
```
day = int(input())
month = int(input())
year = int(input())
leap = (year % 4 == 0 and year % 100 != 0) or year % 400 == 0
if month == 2:
    days = 29 if leap else 28
elif month in (4, 6, 9, 11):
    days = 30
else:
    days = 31
if year >= 1 and 1 <= month <= 12 and 1 <= day <= days:
    print("Gültiges Datum")
else:
    print("Ungültiges Datum")
```
26. Buchstabenhäufigkeit
Lies eine Zeile Text und gib aus, wie oft jeder Buchstabe darin vorkommt, egal ob groß oder klein geschrieben. Gib die Buchstaben in alphabetischer Reihenfolge aus, einen pro Zeile, in der Form „a: 5“; Leerzeichen und Satzzeichen werden nicht gezählt.
Eingabe
```
Banane und Ananas!
```
Ausgabe
```
a: 5
b: 1
d: 1
e: 1
n: 5
s: 1
u: 1
```
Was du brauchst, steht in der Lektion: dict und set
Lösung
```
text = input().lower()
counts = {}
for c in text:
    if c.isalpha():
        counts[c] = counts.get(c, 0) + 1
for c in sorted(counts):
    print(f"{c}: {counts[c]}")
```

27. Minimum und Maximum in einem Array

In der ersten Zeile steht die Anzahl n, in den nächsten n Zeilen je eine ganze Zahl. Lies sie in ein Array und gib die kleinste und die größte aus: Beginne beim ersten Element und vergleiche es mit den übrigen.

Kleinste Zahl: -3
Größte Zahl: 12

Was du brauchst, steht in der Lektion: Listen

Lösung

n = int(input())
numbers = []
for i in range(n):
    numbers.append(int(input()))
smallest = numbers[0]
largest = numbers[0]
for number in numbers:
    if number < smallest:
        smallest = number
    if number > largest:
        largest = number
print(f"Kleinste Zahl: {smallest}")
print(f"Größte Zahl: {largest}")

28. Array sortieren
In der ersten Zeile steht die Anzahl n, in den nächsten n Zeilen je eine ganze Zahl. Sortiere sie selbst aufsteigend mit Bubblesort (n - 1 Durchläufe, in jedem tauschst du Nachbarn, die in der falschen Reihenfolge stehen) und gib sie in einer Zeile aus, getrennt durch Leerzeichen.
Eingabe
```
6
5
2
9
1
5
6
```
Ausgabe
```
1 2 5 5 6 9
```
Was du brauchst, steht in der Lektion: Listen
Lösung
```
n = int(input())
numbers = []
for i in range(n):
    numbers.append(int(input()))
for p in range(n - 1):
    for i in range(n - 1 - p):
        if numbers[i] > numbers[i + 1]:
            numbers[i], numbers[i + 1] = numbers[i + 1], numbers[i]
print(*numbers)
```
29. Vokale ersetzen
Lies eine Zeile Text und gib sie aus, wobei jeder Vokal, groß oder klein, durch das Zeichen * ersetzt ist. Die Vokale sind a, e, i, o, u, ä, ö, ü.
Eingabe
```
Übung macht den Meister
```
Ausgabe
```
*b*ng m*cht d*n M**st*r
```
Was du brauchst, steht in der Lektion: Strings: mit Text arbeiten
Lösung
```
text = input()
vowels = "aeiouäöü"
result = ""
for c in text:
    if c.lower() in vowels:
        result += "*"
    else:
        result += c
print(result)
```
30. Quersumme
Lies eine nicht negative ganze Zahl und gib die Summe ihrer Ziffern aus. Die letzte Ziffer ist n % 10, und n / 10 entfernt sie (in Python n // 10).
Eingabe
```
9875
```
Ausgabe
```
29
```
Was du brauchst, steht in der Lektion: Schleifen
Lösung
```
n = int(input())
total = 0
while n > 0:
    total += n % 10
    n //= 10
print(total)
```
31. Palindrom
Lies eine Zeile Text und prüfe, ob sie ein Palindrom ist, sich also rückwärts genauso liest. Groß- und Kleinbuchstaben gelten als gleich, Leerzeichen werden übersprungen. Gib „Palindrom“ oder „Kein Palindrom“ aus.
Eingabe
```
Lagerregal
```
Ausgabe
```
Palindrom
```
Was du brauchst, steht in der Lektion: Strings: mit Text arbeiten
Lösung
```
text = input().lower().replace(" ", "")
if text == text[::-1]:
    print("Palindrom")
else:
    print("Kein Palindrom")
```

32. Sicheres Passwort

Lies Passwörter, eines pro Zeile, bis ein sicheres kommt: mindestens 8 Zeichen, mindestens eine Ziffer, ein Großbuchstabe und ein Kleinbuchstabe. Gib für jedes schwache die erste nicht erfüllte Regel in dieser Reihenfolge aus („Zu kurz“, „Keine Ziffer“, „Kein Großbuchstabe“, „Kein Kleinbuchstabe“), für das sichere „Passwort akzeptiert“, und hör dann auf.

katze
katzemiau
katzemiau7
Katzemiau7

Zu kurz
Keine Ziffer
Kein Großbuchstabe
Passwort akzeptiert

Was du brauchst, steht in der Lektion: Strings: mit Text arbeiten

Lösung

while True:
    password = input()
    digit = False
    upper = False
    lower = False
    for c in password:
        if c.isdigit():
            digit = True
        elif c.isupper():
            upper = True
        elif c.islower():
            lower = True
    if len(password) < 8:
        print("Zu kurz")
    elif not digit:
        print("Keine Ziffer")
    elif not upper:
        print("Kein Großbuchstabe")
    elif not lower:
        print("Kein Kleinbuchstabe")
    else:
        print("Passwort akzeptiert")
        break

33. Array umdrehen
In der ersten Zeile steht die Anzahl n, in den nächsten n Zeilen je eine ganze Zahl. Lies sie in ein Array und gib sie in umgekehrter Reihenfolge in einer Zeile aus, getrennt durch Leerzeichen: Durchlaufe das Array vom letzten Index bis zum Index 0.
Eingabe
```
4
10
-2
7
3
```
Ausgabe
```
3 7 -2 10
```
Was du brauchst, steht in der Lektion: Listen
Lösung
```
n = int(input())
numbers = []
for i in range(n):
    numbers.append(int(input()))
line = ""
for i in range(n - 1, -1, -1):
    line += str(numbers[i])
    if i > 0:
        line += " "
print(line)
```
34. Elemente zählen
Lies eine Zeile mit Wörtern, getrennt durch je ein Leerzeichen, und gib aus, wie oft jedes Wort vorkommt, in der Form „Wort: Anzahl“. Die Wörter erscheinen in der Reihenfolge, in der sie zum ersten Mal vorkamen.
Eingabe
```
Apfel Birne Apfel Pflaume Birne Apfel
```
Ausgabe
```
Apfel: 3
Birne: 2
Pflaume: 1
```
Was du brauchst, steht in der Lektion: dict und set
Lösung
```
line = input()
counts = {}
for word in line.split(" "):
    counts[word] = counts.get(word, 0) + 1
for word in counts:
    print(f"{word}: {counts[word]}")
```

35. Primzahlen

Lies eine Zahl N und gib alle Primzahlen von 2 bis N in einer Zeile aus, getrennt durch Leerzeichen.

2 3 5 7 11 13 17 19 23 29

Was du brauchst, steht in der Lektion: Schleifen

Lösung

n = int(input())
primes = []
for i in range(2, n + 1):
    prime = True
    d = 2
    while d * d <= i:
        if i % d == 0:
            prime = False
            break
        d += 1
    if prime:
        primes.append(str(i))
print(" ".join(primes))

36. Durchschnitt
In einer Zeile stehen ganze Zahlen, getrennt durch Leerzeichen. Gib ihren Durchschnitt mit zwei Nachkommastellen aus.
Eingabe
```
5 8 12 6
```
Ausgabe
```
Durchschnitt: 7.75
```
Was du brauchst, steht in der Lektion: Listen
Lösung
```
parts = input().split()
total = 0
for part in parts:
    total += int(part)
average = total / len(parts)
print(f"Durchschnitt: {average:.2f}")
```

37. Nach Länge sortieren

In einer Zeile stehen Wörter, getrennt durch Leerzeichen. Sortiere sie nach Länge vom kürzesten zum längsten (Wörter gleicher Länge behalten ihre Reihenfolge aus der Eingabe) und gib sie in einer Zeile aus.

Kirsche Feige Banane Kiwi Pflaume

Kiwi Feige Banane Kirsche Pflaume

Was du brauchst, steht in der Lektion: Strings: mit Text arbeiten

Lösung

words = input().split()
for i in range(len(words) - 1):
    for j in range(len(words) - 1 - i):
        if len(words[j]) > len(words[j + 1]):
            words[j], words[j + 1] = words[j + 1], words[j]
print(" ".join(words))

38. Sätze zählen

Lies eine Zeile Text und gib aus, wie viele Sätze sie hat. Ein Satz endet mit einem Punkt, einem Ausrufezeichen oder einem Fragezeichen; eine Folge solcher Zeichen (wie „...“ oder „?!“) ist ein einziges Ende.

Hallo! Wie geht es dir? Mir geht es gut... Und dir?!

Sätze: 4

Was du brauchst, steht in der Lektion: Strings: mit Text arbeiten

Lösung

text = input()
ends = ".!?"
count = 0
for i in range(len(text)):
    is_end = text[i] in ends
    next_is_end = i + 1 < len(text) and text[i + 1] in ends
    if is_end and not next_is_end:
        count += 1
print(f"Sätze: {count}")

39. Fibonacci-Zahlen
Die Fibonacci-Folge beginnt mit 1, 1, und jede weitere Zahl ist die Summe der beiden vorherigen. Lies N (von 1 bis 50) und gib die N-te Zahl der Folge aus.
Eingabe
```
40
```
Ausgabe
```
102334155
```
Was du brauchst, steht in der Lektion: Schleifen
Lösung
```
n = int(input())
previous = 0
current = 1
for i in range(1, n):
    previous, current = current, previous + current
print(current)
```
40. Den Median finden
In einer Zeile stehen ganze Zahlen, getrennt durch Leerzeichen. Gib ihren Median mit einer Nachkommastelle aus: die mittlere Zahl nach dem Sortieren oder, bei einer geraden Anzahl, den Mittelwert der beiden mittleren.
Eingabe
```
12 3 7 9 1 8
```
Ausgabe
```
Median: 7.5
```
Was du brauchst, steht in der Lektion: Listen: append, remove und sort
Lösung
```
numbers = []
for part in input().split():
    numbers.append(int(part))
numbers.sort()
n = len(numbers)
if n % 2 == 1:
    median = numbers[n // 2]
else:
    median = (numbers[n // 2 - 1] + numbers[n // 2]) / 2
print(f"Median: {median:.1f}")
```

41. Zeichendiagramm

Lies eine Zeile Text. Gib für jedes Zeichen außer dem Leerzeichen, in der Reihenfolge seines ersten Auftretens, eine Zeile „Zeichen | Sternchen“ aus, mit einem Sternchen für jedes Vorkommen im Text.

Banane Brot

B | **
a | **
n | **
e | *
r | *
o | *
t | *

Was du brauchst, steht in der Lektion: Strings: mit Text arbeiten

Lösung

text = input()
for i in range(len(text)):
    c = text[i]
    if c != " " and text.index(c) == i:
        count = 0
        for other in text:
            if other == c:
                count += 1
        print(c + " | " + "*" * count)

42. Matrix transponieren

In der ersten Zeile stehen die Anzahl der Zeilen R und die Anzahl der Spalten C, danach folgen R Zeilen mit je C Zahlen, getrennt durch Leerzeichen. Gib die transponierte Matrix aus: C Zeilen mit je R Zahlen, wobei die Zeilen zu Spalten werden.

2 3
1 2 3
4 5 6

1 4
2 5
3 6

Was du brauchst, steht in der Lektion: Zweidimensionale Arrays

Lösung

size = input().split()
rows = int(size[0])
cols = int(size[1])
matrix = []
for r in range(rows):
    row = []
    for part in input().split():
        row.append(int(part))
    matrix.append(row)
for c in range(cols):
    line = []
    for r in range(rows):
        line.append(str(matrix[r][c]))
    print(" ".join(line))

43. Wege im Labyrinth

In der ersten Zeile stehen R und C, danach folgen R Zeilen mit je C Zeichen: „.“ ist eine freie Zelle, „#“ eine Wand. Du gehst nur nach rechts oder nach unten und trittst nie auf eine Wand. Gib die Anzahl aller Wege von der oberen linken zur unteren rechten Ecke aus.

4 5
.....
.#.#.
...#.
#....

Wege: 4

Was du brauchst, steht in der Lektion: Rekursion

Lösung

def count_paths(maze, r, c):
    if r >= len(maze) or c >= len(maze[0]) or maze[r][c] == "#":
        return 0
    if r == len(maze) - 1 and c == len(maze[0]) - 1:
        return 1
    return count_paths(maze, r + 1, c) + count_paths(maze, r, c + 1)


size = input().split()
rows = int(size[0])
maze = []
for r in range(rows):
    maze.append(input())
print(f"Wege: {count_paths(maze, 0, 0)}")

44. Notenstatistik

In einer Zeile stehen Noten von 2 bis 6 (6 ist die beste), getrennt durch Leerzeichen. Gib aus, wie viele davon Ausgezeichnet, Sehr gut, Gut, Ausreichend und Ungenügend sind, jede Kategorie in einer eigenen Zeile.

6 4 5 6 3 5 2 6 5 4

Ausgezeichnet (6): 3
Sehr gut (5): 3
Gut (4): 2
Ausreichend (3): 1
Ungenügend (2): 1

Was du brauchst, steht in der Lektion: Listen

Lösung

names = ["", "", "Ungenügend", "Ausreichend", "Gut", "Sehr gut", "Ausgezeichnet"]
counts = [0] * 7
for part in input().split():
    counts[int(part)] += 1
for grade in range(6, 1, -1):
    print(f"{names[grade]} ({grade}): {counts[grade]}")

45. Römische Zahlen

Lies eine ganze Zahl von 1 bis 3999 und gib sie in römischen Zahlen aus (I, V, X, L, C, D, M, wobei 4 IV ist, 9 IX, 40 XL und so weiter).

MCMXCIV

Was du brauchst, steht in der Lektion: Listen

Lösung

number = int(input())
values = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1]
symbols = ["M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"]
roman = ""
for i in range(len(values)):
    while number >= values[i]:
        roman += symbols[i]
        number -= values[i]
print(roman)

46. Münzwurf-Simulation
Lies einen Startwert (Seed) x (von 1 bis 2147483646) und eine Anzahl Würfe N, jeweils in einer eigenen Zeile. Setze bei jedem Wurf x = x * 16807 % 2147483647; ein gerades x ist Kopf (K), ein ungerades Zahl (Z). Gib die Würfe in einer Zeile aus, danach, wie oft Kopf und wie oft Zahl gefallen ist.
Eingabe
```
42
10
```
Ausgabe
```
KZZZKZZKKZ
Kopf: 4
Zahl: 6
```
Was du brauchst, steht in der Lektion: Schleifen
Lösung
```
x = int(input())
n = int(input())
tosses = ""
heads = 0
for i in range(n):
    x = x * 16807 % 2147483647
    if x % 2 == 0:
        tosses += "K"
        heads += 1
    else:
        tosses += "Z"
print(tosses)
print(f"Kopf: {heads}")
print(f"Zahl: {n - heads}")
```

47. Symmetrisches Array

In einer Zeile stehen ganze Zahlen, getrennt durch Leerzeichen. Prüfe, ob das Array symmetrisch ist, sich also von links nach rechts und von rechts nach links gleich liest.

1 2 3 2 1

Symmetrisch

Was du brauchst, steht in der Lektion: Listen

Lösung

numbers = []
for part in input().split():
    numbers.append(int(part))
symmetric = True
for i in range(len(numbers) // 2):
    if numbers[i] != numbers[len(numbers) - 1 - i]:
        symmetric = False
        break
print("Symmetrisch" if symmetric else "Nicht symmetrisch")

48. Balancierte Klammern

Lies eine Zeile Text und prüfe, ob die Klammern (), [] und {} darin balanciert sind: Jede öffnende Klammer hat ihre schließende derselben Art, und die Paare überkreuzen sich nicht. Andere Zeichen zählen nicht.

(a + [b) * c]

Nicht balanciert

Was du brauchst, steht in der Lektion: Stack, Queue und verkettete Liste

Lösung

text = input()
opening = "([{"
closing = ")]}"
stack = []
balanced = True
for c in text:
    if c in opening:
        stack.append(c)
    elif c in closing:
        if not stack or opening.index(stack.pop()) != closing.index(c):
            balanced = False
            break
if balanced and not stack:
    print("Balanciert")
else:
    print("Nicht balanciert")

49. Folge gleicher Elemente

In einer Zeile stehen ganze Zahlen, getrennt durch Leerzeichen. Finde die längste Folge gleicher benachbarter Zahlen und gib sie in einer Zeile aus; gibt es mehrere gleich lange, gib die erste aus.

2 1 1 3 3 3 2 2 2 5

3 3 3

Was du brauchst, steht in der Lektion: Listen

Lösung

numbers = []
for part in input().split():
    numbers.append(int(part))
best_value = numbers[0]
best_length = 1
length = 1
for i in range(1, len(numbers)):
    if numbers[i] == numbers[i - 1]:
        length += 1
    else:
        length = 1
    if length > best_length:
        best_length = length
        best_value = numbers[i]
print(" ".join([str(best_value)] * best_length))

50. Kürzester Weg in einer Matrix

In der ersten Zeile stehen R und C, danach folgen R Zeilen mit je C Zeichen: „.“ ist eine freie Zelle, „#“ eine Wand, „S“ der Start und „E“ das Ziel. Du darfst nach oben, unten, links und rechts gehen. Gib die kleinste Anzahl Schritte von S nach E aus oder „Kein Weg“, wenn E nicht erreichbar ist.

5 6
S.#...
.##.#.
...#..
#.#..#
...E.#

Was du brauchst, steht in der Lektion: Stack, Queue und verkettete Liste

Lösung

from collections import deque

size = input().split()
rows = int(size[0])
cols = int(size[1])
grid = []
for r in range(rows):
    grid.append(input())
dist = []
queue = deque()
for r in range(rows):
    dist.append([-1] * cols)
    for c in range(cols):
        if grid[r][c] == "S":
            dist[r][c] = 0
            queue.append((r, c))
moves = [(-1, 0), (1, 0), (0, -1), (0, 1)]
answer = "Kein Weg"
while queue:
    r, c = queue.popleft()
    if grid[r][c] == "E":
        answer = str(dist[r][c])
        break
    for dr, dc in moves:
        nr = r + dr
        nc = c + dc
        if 0 <= nr < rows and 0 <= nc < cols and grid[nr][nc] != "#" and dist[nr][nc] == -1:
            dist[nr][nc] = dist[r][c] + 1
            queue.append((nr, nc))
print(answer)

Aufgaben aus den Lektionen

Sprachgrundlagen

Dein erstes Programm: Hello World · Visitenkarte · Rahmen
Variablen und Typen: Tausch · Alter · Eine Hotelkarte
Eingabe und Ausgabe: Begrüßung mit Namen · Summe zweier Zahlen · Zwei Texte in einem · π mit zwei Stellen
Operatoren und Arithmetik: Durchschnitt von drei Zahlen · Sekunden in Stunden · Volumen einer Kugel · Celsius in Fahrenheit
Bedingungen: Eine Kinokarte · Ein Mini-Taschenrechner · Eine quadratische Gleichung · Ein gültiges Datum
Schleifen: Einmaleins · Primzahl · Die Ziffern einer Zahl · Zahlenraten
Listen: Summe, gerade, ungerade · Umgekehrt · Kleinste, größte, Durchschnitt
Listen: Sortieren · Längste Folge · Notenstatistik
Zweidimensionale Arrays: Diagonalen und Zeilen · Dreh die Tabelle um
Zweidimensionale Arrays: Wie viele Wege gibt es? · Der kürzeste Weg
Strings: mit Text arbeiten: Der Name rückwärts · Anzahl der Wörter · Palindrom
Strings: mit Text arbeiten: Sicheres Passwort

Funktionen

Funktionen: Kassenbon · Dreieck
Parameter und return: Durchschnitt · Primzahl · Temperaturen · Taschenrechner · Ein Dreieck mit Parameter
Parameter und return
Standardwerte: Die größte · Notendurchschnitt · Eine Zeile auf dem Bon · Kostenlose Lieferung
Rekursion: Fakultät auf zwei Arten · Quersumme · Fibonacci · Palindrom

Klassen und Objekte

Klassen und Objekte: Buch · Auto · Der Warenkorb · Das Teuerste zuerst
Konstruktoren und self: Person · Tier · Tanzschritt
Instanzmethoden
Instanzmethoden
Kapselung: Person · Ein Konto ohne Minus · Tier
Was alle Objekte teilen: Klassenattribute: Bestellungen · Taschenrechner · Wechselstube

Vererbung und Polymorphie

Vererbung: Familienauto · Studentin · Breakdance · Elektroauto
Polymorphie: Tierheim · Die Studentin stellt sich vor · Party
Abstrakte Klassen: Fläche und Umfang · Tiere
Abstrakte Klassen: Fahrzeuge · Auftritte
Interfaces als abstrakte Klassen: Hupe · Angaben · Tanz · DJ · Der Teich
Typprüfungen: Parkplatz · Tänze · Fuhrpark · Zoo
OOP-Prinzipien
OOP-Prinzipien: Ein freier Mitarbeiter · Die Terrasse ohne if

Fehler und Exceptions

Exceptions: Text zu Zahl · Kein solches Produkt · Durchschnittliche Bestellung
try, except und finally: Preis pro Person · Taschenrechner
Werfen und eigene Exceptions: Musikgeschäft · Ein Konto mit Regeln · Ungültiges Alter

Text und Dateien

Strings: Palindrom · Ein Kassenbon mit Spalten · Wörter rückwärts
Reguläre Ausdrücke: Datum · Handynummer · E-Mail · Einkaufsliste
Reguläre Ausdrücke: Gruppen und Ersetzen: Suchen und ersetzen · Wörter mit einem Präfix · Adressen im Text · Daten nach ISO
Dateien: Eine Konfigurationsdatei · Ein Filter für eine Logdatei · Der Inhalt eines Ordners · Eine Indexdatei
Daten in Dateien: CSV-Auswertung · Den Helden speichern · Doppelter Text

Collections

Listen: append, remove und sort: Ein Bücherregal · Ein Ereignisprotokoll · Ein Notizbuch · Kopfrechnen
Stack, Queue und verkettete Liste: Ein Spielzeugzug · Eine Buslinie · Ein Börsenticker · Ausgeglichene Klammern · Deine eigene verkettete Liste
dict und set: Eine Benutzertabelle · Worthäufigkeit · Dokumente nach Stichwort · Ein Kontaktnetz
Hashcodes und Hashfunktionen: Ein Hash für eine Person · Der Roboter im Lager · Ein Hash einer Datei
Klassen und Daten in Klassen: Warenkorb · Monitor für einen Webserver · Hausverwaltung · Rangliste

Modernes Python

Lambdas: Sortieren nach mehreren Feldern · Bestellungen filtern · Rabatte nacheinander
List Comprehensions und Generatoren: Verkäufe nach Kategorie · Die Top 3 der Produkte · Die Durchschnittsnote · Die Wörter in einem Text
dataclass, match und Muster: Formen · Lieferpreis · Ein Punkt als Schlüssel
Entwurfsmuster: Rabatte als Strategien · „Benachrichtige mich, wenn es wieder da ist“ · Eine Fabrik für Benachrichtigungen · Ein altes Thermometer

Programme in der echten Welt

Tests mit unittest: Der Rabattrechner · Das Konto · Der Fehler im Notendurchschnitt
Threads: Parallele Summe · Herunterladen mit einem Pool · Ein Zähler ohne Verluste
Netzwerkprogrammierung: Echo-Server · Ein Server mit Befehlen · Ein Chat für zwei
Datenbanken: Katalog · Suche nach einem Teil des Namens · Eine Überweisung, die mittendrin fehlschlägt
Reflection und Dekoratoren: Alle Felder, Klasse für Klasse · Mini-JSON · Dein eigener Test-Runner

Wir bauen ein Spiel

Wie du über ein Spiel nachdenkst: Ein Rennen für zwei · Zahl raten · Wer hat Tic-Tac-Toe gewonnen?
RPG 1: die Helden: Ein sechster Held · Die Liste der Gruppe · Wer ist der Stärkste?
RPG 2: die Schlacht: Ein neues Monster · Ein Heiltrank · Ein Kampfbericht
RPG 3: das ganze Spiel: Ein Menü · Fortschritt · Ein Boss
Epic Cosmos 1: die Objekte im All: Das Sonnensystem · Abstand · Der ganze Baum
Epic Cosmos 2: Ressourcen, Gebäude, Schiffe: 100 Metall so schnell wie möglich · Ein Frachter · Eine Simulation über 10 Züge
Das verschlossene Labor 1: Räume und Befehle: Inventar · Ein neuer Raum · Synonyme
Das verschlossene Labor 2: Rätsel und der Ausweg: Der dunkle Keller · Ein Timer · Ein Hinweis für einen Zug

Die Chroniken von Arkanum

Epic Cosmos: das Imperium

Projekt

Hotelbuchungen: Zimmerwechsel

Erstellt von Ivo Gergov im Rahmen der Kampagne von Evo Tech für zugängliche Programmierausbildung ·

Aufgaben

50 Aufgaben zum Üben

1. Hello World

2. Begrüße den Benutzer

3. Das Alter ausgeben

4. Einheitenumrechner

5. Gerade oder ungerade

6. Summe zweier Zahlen

7. Fläche eines Quadrats

8. Volumen einer Kugel

9. Zwei Zahlen vergleichen

10. Dreiecksprüfung

11. Note in Worten

12. Stunden in Sekunden

13. Zählen bis N

14. ASCII-Wert

15. Quadratische Gleichung

16. Positiv oder negativ

17. Jahreszeiten

18. Zahl umdrehen

19. Temperaturumrechner

20. Längster Name

21. Wörter zählen

22. Primzahl

23. Wochentag

24. Fakultät

25. Gültiges Datum

26. Buchstabenhäufigkeit

27. Minimum und Maximum in einem Array

28. Array sortieren

29. Vokale ersetzen

30. Quersumme

31. Palindrom

32. Sicheres Passwort

33. Array umdrehen

34. Elemente zählen

35. Primzahlen

36. Durchschnitt

37. Nach Länge sortieren

38. Sätze zählen

39. Fibonacci-Zahlen

40. Den Median finden

41. Zeichendiagramm

42. Matrix transponieren

43. Wege im Labyrinth

44. Notenstatistik

45. Römische Zahlen

46. Münzwurf-Simulation

47. Symmetrisches Array

48. Balancierte Klammern

49. Folge gleicher Elemente

50. Kürzester Weg in einer Matrix

Aufgaben aus den Lektionen

Sprachgrundlagen

Funktionen

Klassen und Objekte

Vererbung und Polymorphie

Fehler und Exceptions

Text und Dateien

Collections

Modernes Python

Programme in der echten Welt

Wir bauen ein Spiel

Die Chroniken von Arkanum

Epic Cosmos: das Imperium

Projekt

Cookies