Compare commits

..

No commits in common. "main" and "ue00" have entirely different histories.
main ... ue00

29 changed files with 1 additions and 2212 deletions

11
.gitignore vendored
View file

@ -1,12 +1 @@
__pycache__
/EPR/ue00/7987847_epr-blatt00.zip
/EPR/ue01/7987847_epr-blatt01.zip
/EPR/ue02/7987847_epr-blatt02.zip
/EPR/ue03/7987847_epr-blatt03.zip
/EPR/ue04/7987847_epr-blatt04.zip
/EPR/ue05/7987847_epr-blatt05.zip
/GPR/ue03/gpr_blatt03_7987847_werner.zip
/GPR/ue05/7987847_gpr-blatt05.zip
/GPR/ue05/7987847_gpr-blatt10.zip

View file

@ -1,65 +0,0 @@
author: 7987847, Werner
Aufgabe 1
---
a. Lauffähig: ja, Ausgabe: Größer als 5
b. Lauffähig: nein, Fehlerklasse: TypeError, Begründung: 4,2 wird zu einem Tupel, da ein Komma und kein Punkt verwendet wird. Tupel können nicht mit einem Integer verglichen werden.
c. Lauffähig: nein, Fehlerklasse: NameError, Begründung: Die Variable "b" wurde nicht definiert.
d. Lauffähig: ja, Ausgabe: b gibt True
Aufgabe 2
---
Das Programm berechnet die für die Klausur angerechneten Bonuspunkte von EPR und GPR.
Zur Nutzung muss eine kompatible Python version installiert sein.
Akzeptiert werden alle Python 3.x Versionen.
Das Programm kann mit dem Befehl `python3 main.py` im Ordner gestartet werden.
Nach dem Aufrufen wird zunächst nach der Anzahl der EPR, GPR und Zur Klausur notwendige Bonus-Punkten gefragt.
Diese müssen als Integer angegeben werden.
Hinweis: Es kommt zu einem Fehler, wenn kein Integer angegeben wird und das Programm wird abgebrochen.
Hinweis: Es kommt zu einem Fehler wenn die Anzahl der Bonuspunkte für EPR oder GPR nicht im Bereich 0-110 liegt. oder die Zur Klausur notwendigen Bonuspunkte nicht im positiven Zahlenbereich liegt.
Das Programm berechnet dann die Anzahl der Bonuspunkte, die für die Klausur angerechnet werden.
Testfälle:
Im Programmcode sind zu jeder der beiden Mittel jeweils 3 Testfälle angegeben.
PEP8:
Der Programmcode ist soweit wie möglich nach PEP8 abgestimmt.
Von der Aufgabe vorgegebene Funktions- und Variablennamen wurden beibehalten.
Aufgabe 3
---
Das Programm üperprüft, ob die kleinere von zwei Zahlen durch 2, 4 oder 8 teilbar.
Zur Nutzung muss eine kompatible Python version installiert sein.
Akzeptiert werden alle Python 3.x Versionen.
Das Programm kann mit dem Befehl `python3 main.py` im Ordner gestartet werden.
Nach dem Aufrufen wird Aufgabe 2 ausgeführt.
Danach wird nach zwei Zahlen nacheinander gefragt.
Diese müssen als Integer angegeben werden.
Hinweis: Es kommt zu einem Fehler, wenn kein Integer angegeben wird und das Programm wird abgebrochen.
Das Programm überprüft dann, ob die kleinere der beiden Zahlen durch 2, 4 oder 8 teilbar ist.
Es wird dann ausgegeben, ob die Zahl durch 2, 4 oder 8 teilbar ist.
Testfälle:
Im Programmcode sind zu jeder der beiden Mittel jeweils 3 Testfälle angegeben.
PEP8:
Der Programmcode ist soweit wie möglich nach PEP8 abgestimmt.
Von der Aufgabe vorgegebene Funktions- und Variablennamen wurden beibehalten.

View file

@ -1,84 +0,0 @@
'''EPR Übungsblatt 01'''
__author__ = "7987847, Werner"
# Aufgabe 2
def bonuspunkte_rechner(bp_epr: int, bp_gpr: int, zbnp: int) -> int:
'''
Berechnet die Anzahl der Bonuspunkte
:param bonuspunkte_epr: Bonuspunkte EPR
:param bonuspunkte_gpr: Bonuspunkte GPR
:param zbnp: Zum bestehen benötigte Punkte
:return: Anzahl der Bonuspunkte
'''
# Überprüfung, ob die Werte im erlaubten Bereich liegen
if bp_epr not in range(0, 111) or bp_gpr not in range(0, 111) or zbnp < 0:
raise ValueError("Die Werte sind nicht im erlaubten Bereich.")
return int(min(zbnp/4, (bp_epr+bp_gpr)/14))
print("Rechner zur Berechnung der Bonuspunkte für EPR und GPR")
epr_bp = int(input('Bitte geben Sie die Bonuspunkte EPR ein: '))
epr_bp = int(input('Bitte geben Sie die Bonuspunkte GPR ein: '))
zbnp_ = int(input('Bitte geben Sie die zum Bestehen benötigten Punkte ein: '))
bonuspunkte = bonuspunkte_rechner(epr_bp, epr_bp, zbnp_)
ergebnis_text = f"Die Anzahl der Bonuspunkte für die Klausur: {bonuspunkte}"
print(ergebnis_text)
# Testfälle
# Einfacher Aufruf mit 0
# bonuspunkte_rechner(0, 0, 0)
# Ausgabe: 0
# Aufruf mit Dezimalzahlen und negativen Zahlen
# bonuspunkte_rechner(-3.6, 3.14, 0)
# Ausgabe: ValueError: Die Werte sind nicht im erlaubten Bereich.
# Aufruf mit realen Werten
# bonuspunkte_rechner(89, 102, 50)
# Ausgabe: 12
# Aufgabe 3
def aufgabe_3(zahl_1:int, zahl_2:int) -> None:
'''
Prüft ob die kleinere Zahl durch 2, 4 oder 8 teilbar ist
'''
kleinere_zahl = min(zahl_1, zahl_2)
ist_teilbar = False
# Überprüfung, ob die kleinere Zahl durch 2, 4 oder 8 teilbar ist
if kleinere_zahl % 8 == 0:
print(f"{kleinere_zahl} ist durch 8 teilbar.")
ist_teilbar = True
if kleinere_zahl % 4 == 0:
print(f"{kleinere_zahl} ist durch 4 teilbar.")
ist_teilbar = True
if kleinere_zahl % 2 == 0:
print(f"{kleinere_zahl} ist durch 2 teilbar.")
ist_teilbar = True
if not ist_teilbar:
print(f"{kleinere_zahl} ist weder durch 2, 4 noch 8 teilbar.")
print("Rechner zur Prüfung ob die kleinere Zahl durch 2, 4 oder 8 teilbar ist")
aufgabe_3(int(input("Bitte geben Sie die erste Zahl ein: ")),
int(input("Bitte geben Sie die zweite Zahl ein: ")))
# Testfälle
# Einfacher Aufruf mit 0
# aufgabe_3(0, 0)
# Ausgabe: 0 ist durch 8 teilbar.
# 0 ist durch 4 teilbar.
# 0 ist durch 2 teilbar.
# Aufruf mit Dezimalzahlen und negativen Zahlen
# aufgabe_3(-3.6, 3.14)
# Ausgabe: ValueError: Es muss ein Integer übergeben werden.
# Aufruf mit natürlichen Werten
# aufgabe_3(89, 102)
# Ausgabe: 89 weder durch 2, 4 noch 8 teilbar.

View file

@ -1,5 +0,0 @@
a = 5
b = 10
if b:
print("b gibt True")
else: print("b gibt False")

View file

@ -1,113 +0,0 @@
author: 7987847, Werner
Aufgabe 1
---
a.
Ausgabe:
0
3
6
9
42
b.
Ausgabe:
0.1 : 1
0.2 : 1.2
0.30000000000000004 : 1.4
0.4 : 1.5999999999999999
c.
Ausgabe:
0.1 : 1
0.2 : 1.2
0.30000000000000004 : 1.4
0.4 : 1.5999999999999999
0.5 : 1.5999999999999999
0.6 : 1.5999999999999999
0.7 : 1.5999999999999999
0.7999999999999999 : 1.5999999999999999
0.8999999999999999 : 1.5999999999999999
0.9999999999999999 : 1.5999999999999999
1.0999999999999999 : 1.5999999999999999
1.2 : 1.5999999999999999
1.3 : 1.5999999999999999
1.4000000000000001 : 1.5999999999999999
1.5000000000000002 : 1.5999999999999999
1.6000000000000003 : 1.5999999999999999
B
d.
Ausgabe:
n
Die Funktion f1 wird ein mal aufgerufen und gibt None zurück, da weder die Bedingung der ersten, noch der zweiten if-Anweisung erfüllt ist. Daher gibt es kein vordefinierten return-Wert und es wird automatisch None zurückgegeben.
e.
Ausgabe:
17
Die Funktion f2 gibt den Wert von m zurück, wenn wenn n kleiner m nicht erfüllt ist. Im Code-Fragment ist n kleiner m jedoch erfüllt, da 17 < 19. Dadurch wird f2 rekursiv aufgerufen mit vertauschten Eingabewerten. Nun ist n = 19 und m = 17. Da 19 > 17 ist, wird 19 zurückgegeben und die Rekursion beendet. f2 wird insgesamt 2 mal aufgerufen.
f.
Ausgabe:
10
Die Funktion f3 wird insgesamt 1 mal aufgerufen und der Wert von a wird mit n addiert. 'a' ist bei der Definition von f3 noch nicht definiert, aber bei der Ausführung von f3 wird a initialisiert. Da n = 0 ist, wird 10 zurückgegeben.
Aufgabe 2
---
Zur Nutzung muss eine kompatible Python version installiert sein.
Akzeptiert werden alle Python 3.x Versionen.
Das Programm kann mit dem Befehl `python3 main.py` im Ordner gestartet werden.
Nach dem Aufrufen des Programms wird zunächst die Summe der Zahlen zwischen n und m berechnet. Hierzu wird der Nutzer aufgefordert die beiden Zahlen einzugeben.
Das Ergebnis wird daraufhin ausgegeben.
Als nächstes wird der Nutzer aufgefordert eine Zahl einzugeben, die so lange halbiert wird, bis sie kleiner als 1 ist. Die Anzahl der Halbierungen wird ausgegeben.
Daraufhin wird der Nutzer aufgefordert 2 Zahlen n und m einzugeben welche die Zeile und Spalten eines daraufhin ausgegebenen Schachbretts darstellen.
Folgenden wird der Nutzer aufgefordert eine Zahl anzugeben welche die Approximationsstufe der Catalanschen Konstante darstellt. Die Zahl inidziert die Anzahl der Terme der Berechnung und dadurch auch die Genauigkeit der Approximation.
Als letztes wird der Nutzer aufgefordert 3 Zahlen einzugeben. Hier wird Differenz zwischen verschiedenen Approximationen der Catalanschen Konstante berechnet. Die erste Zahl gibt die Anzahl der Terme der ersten Approximation an, die zweite Zahl die Anzahl der Terme der letzten Approximation und die dritte Zahl die Schrittweite zwischen den Approximationen. Es wird die Differenz zwischen jedem Schritt ausgegeben.
Hinweis: Es kommt in allen Eingaben zu einem Fehler, wenn kein Integer eingegeben wird. Es wird dann eine Fehlermeldung ausgegeben und das Programm beendet sich.
Nach der Ausgabe des letzten Ergebnisses wird das Programm beendet.
Testfälle
---
Im Programmcode sind zu jeder der beiden Mittel jeweils 3 Testfälle angegeben.
PEP8
---
Der Programmcode ist soweit wie möglich nach PEP8 abgestimmt.
Von der Aufgabe vorgegebene Funktions- und Variablennamen wurden beibehalten.
Diese sind nicht PEP8 konform (snake_case naming).

View file

@ -1,209 +0,0 @@
'''EPR Übungsblatt 02'''
__author__ = "7987847, Werner"
# Aufgabe 2
# a)
def sum_range(start:int, end:int) -> int:
'''Summe aller Zahlen von m bis n
m: Startwert
n: Endwert
'''
if start > end:
start, end = end, start
return sum(range(start, end+1))
print("Es wird die Summe aller Zahlen von m bis n berechnet.")
print("Geben Sie m und n ein.")
print(sum_range(int(input("m: ")), int(input("n: "))))
# Testfälle
# sum_range(0, 0)
# Ausgabe: 0
# sum_range(0, 1)
# Ausgabe: 1
# sum_range(-2, 234534634737)
# b)
def halbiere_bis_null(zahl:int) -> int:
'''Anzahl der Schritte, bis n <= 1
n: Zahl, die halbiert werden soll
'''
schritte = 0
while zahl != 0:
zahl /= 2
schritte += 1
return schritte
print("Es wird die Anzahl der Schritte berechnet, bis n <= 1 ist.")
print("Geben Sie n ein.")
print(halbiere_bis_null(int(input("n: "))))
# Testfälle
# halbiere_bis_null(0)
# Ausgabe: 0
# halbiere_bis_null(1)
# Ausgabe: 1
# halbiere_bis_null(2)
# Ausgabe: 2
# c)
def erzeuge_schachfeld(zeilen:int, spalten:int):
'''Erzeugt ein Schachfeld mit n Zeilen und m Spalten
n: Anzahl der Zeilen
m: Anzahl der Spalten
'''
for i in range(zeilen):
for j in range(spalten):
# Wenn sowohl die Zeile als auch die Spalte gerade oder ungerade
# ist, ist es Schwarz (1),
# ansonsten ist es Weiß (0).
if (i + j) % 2 == 0:
print("0", end=" ")
else:
print("1", end=" ")
print()
print("Es wird ein Schachfeld erzeugt.")
print("Geben Sie die Anzahl der Zeilen (n) und Spalten (m) ein.")
erzeuge_schachfeld(int(input("n: ")), int(input("m: ")))
# Testfälle
# erzeuge_schachfeld(0, 0)
# Ausgabe:
# erzeuge_schachfeld(1, 1)
# Ausgabe: 0
# erzeuge_schachfeld(7, 7)
# Ausgabe:
# 0 1 0 1 0 1 0
# 1 0 1 0 1 0 1
# 0 1 0 1 0 1 0
# 1 0 1 0 1 0 1
# 0 1 0 1 0 1 0
# 1 0 1 0 1 0 1
# 0 1 0 1 0 1 0
# d
def catalansche_konstante_approximation(anzahl_terme:int) -> float:
'''Approximation der catalanschen Konstante
anzahl_terme: Anzahl der Terme, die zur Approximation verwendet werden sollen
'''
catalan_summe = 0.0
for zahl in range(anzahl_terme):
term = 1 / ((2 * zahl + 1) ** 2)
catalan_summe += term
return catalan_summe
print("Es wird die catalansche Konstante approximiert.")
print("Geben Sie die Anzahl der Terme ein, um die Konstante zu approximieren.")
print(catalansche_konstante_approximation(int(input("Anzahl Terme: "))))
# Testfälle
# catalansche_konstante_approximation(0)
# Ausgabe: 0.0
# catalansche_konstante_approximation(1)
# Ausgabe: 1.0
# catalansche_konstante_approximation(1000)
# Ausgabe: 1.2334505501570059
# e
def differenz_zwischen_approximationen(start:int, ende:int, schrittweite:int) -> float:
'''Gibt die Differenz zwischen zwei Approximationen der catalanschen Konstante aus
start: Startwert
ende: Endwert
schrittweite: Schrittweite
'''
for zahl in range(start, ende, schrittweite):
erster_wert = catalansche_konstante_approximation(zahl)
zweiter_wert = catalansche_konstante_approximation(zahl + schrittweite)
differenz = zweiter_wert - erster_wert
print(f"n = {zahl} : {erster_wert} ; n = {zahl + schrittweite} : {zweiter_wert}")
print(f"Differenz: {differenz}\n")
print("Es wird die Differenz zwischen zwei Approximationen der catalanschen Konstante ausgegeben.")
print("Geben Sie den Startwert, Endwert und die Schrittweite ein.")
differenz_zwischen_approximationen(int(input("Startwert: ")),
int(input("Endwert: ")),
int(input("Schrittweite: ")))
# Testfälle
# differenz_zwischen_approximationen(0, 1000, 100)
# Ausgabe:
# n = 0 : 0.0 ; n = 100 : 1.231200570968774
# Differenz: 1.231200570968774
# n = 100 : 1.231200570968774 ; n = 200 : 1.2324505527403138
# Differenz: 0.0012499817715396766
# n = 200 : 1.2324505527403138 ; n = 300 : 1.2328672175744397
# Differenz: 0.000416664834125946
# n = 300 : 1.2328672175744397 ; n = 400 : 1.2330755504616913
# Differenz: 0.00020833288725152777
# n = 400 : 1.2330755504616913 ; n = 500 : 1.2332005503028372
# Differenz: 0.0001249998411458897
# n = 500 : 1.2332005503028372 ; n = 600 : 1.2332838835659545
# Differenz: 8.333326311737999e-05
# n = 600 : 1.2332838835659545 ; n = 700 : 1.233343407339766
# Differenz: 5.952377381146512e-05
# n = 700 : 1.233343407339766 ; n = 800 : 1.2333880501768604
# Differenz: 4.464283709437744e-05
# n = 800 : 1.2333880501768604 ; n = 900 : 1.2334227723869715
# Differenz: 3.472221011113774e-05
# n = 900 : 1.2334227723869715 ; n = 1000 : 1.2334505501570059
# Differenz: 2.7777770034376204e-05
# differenz_zwischen_approximationen(-3, 5, 1)
# Ausgabe:
# n = -3 : 0.0 ; n = -2 : 0.0
# Differenz: 0.0
# n = -2 : 0.0 ; n = -1 : 0.0
# Differenz: 0.0
# n = -1 : 0.0 ; n = 0 : 0.0
# Differenz: 0.0
# n = 0 : 0.0 ; n = 1 : 1.0
# Differenz: 1.0
# n = 1 : 1.0 ; n = 2 : 1.1111111111111112
# Differenz: 0.11111111111111116
# n = 2 : 1.1111111111111112 ; n = 3 : 1.1511111111111112
# Differenz: 0.040000000000000036
# n = 3 : 1.1511111111111112 ; n = 4 : 1.1715192743764173
# Differenz: 0.020408163265306145
# n = 4 : 1.1715192743764173 ; n = 5 : 1.183864953388763
# Differenz: 0.012345679012345734
# differenz_zwischen_approximationen(0, 0, 1)
# Ausgabe:

View file

@ -1,35 +0,0 @@
author: 7987847, Werner
Das Programm ist eine Konsole für das epr_functions Modul.
Zur Nutzung muss eine kompatible Python version installiert sein.
Akzeptiert werden alle Python 3.x Versionen.
Das Programm kann mit dem Befehl `python3 main.py` im Ordner gestartet werden.
Beim Starten wird dem Nutzer einen Tipp gegeben, wie eine Liste der Befehle angezeigt werden kann und wie das Programm beendet werden kann.
## Befehle
### `help`
Zeigt eine Liste aller Befehle an.
### `exit`
Beendet das Programm.
### `decimal_to_octal`
Konvertiert eine Dezimalzahl in eine Oktalzahl.
Nimmt ein Argument entgegen: Die Dezimalzahl.
### `decimal_to_basis`
Konvertiert eine Dezimalzahl in eine Zahl mit einer beliebigen Basis.
Nimmt zwei Argumente entgegen: Die Dezimalzahl und die Basis.
### `chaos_turtle`
Zeichnet eine Dreieck-Struktur mit turtle-graphics.
Nimmt ein Argument entgegen: Die Anzahl der Ecken.

View file

@ -1,119 +0,0 @@
'''EPR Übungsblatt 03, Python Modul'''
__author__ = "7987847, Werner"
import turtle
import random
class InvalidInputError(Exception):
'''Exception for invalid input'''
pass
def decimal_to_octal(decimal:int) -> str:
'''Converts a decimal number to an octal number
decimal: decimal number
'''
if decimal == 0:
return "0"
if decimal < 0:
raise InvalidInputError("Negative numbers are not allowed")
octal = ""
while decimal > 0:
octal = str(decimal % 8) + octal
decimal //= 8
print("Octal Conversion:",decimal*8,
"/ 8 =", decimal,
" Rest:", decimal % 8,
"Octal: ", octal)
return octal
# Alternativ:
# def decimal_to_octal(decimal:int) -> str:
# '''Converts a decimal number to an octal number
# decimal: decimal number
# '''
# return decimal_to_basis(decimal, 8)
# Testfälle
# decimal_to_octal(0)
# Ausgabe: 0
# decimal_to_octal(39)
# Ausgabe: 47
# decimal_to_octal(-10)
# Ausgabe: Exception
def decimal_to_basis(decimal:int, basis:int) -> str:
'''Converts a decimal number to a number with a given base
decimal: decimal number
basis: base
'''
if decimal == 0:
return "0"
if decimal < 0 or basis < 0:
raise InvalidInputError("Negative numbers are not allowed")
converted = ""
while decimal != 0:
converted = str(decimal % basis) + converted
decimal //= basis
print("Basis Conversion:", decimal*basis, "/",
basis, "=", decimal,
"Rest:", decimal % basis,
"Converted:", converted)
return converted
# Testfälle
# decimal_to_basis(0, 2)
# Ausgabe: 0
# decimal_to_basis(39, 2)
# Ausgabe: 100111
# decimal_to_basis(-10, 2)
# Ausgabe: Exception
def chaos_turtle(iterationen, startpunkt=(0, 0)):
'''Draws a random triangle-like pattern with turtle
iterationen: number of iterations
startpunkt: start point of the turtle
'''
turtle.penup()
turtle.goto(startpunkt)
turtle.speed(0)
punkte = [(100, -50), (-100, -50), (0, 100)] # Eckpunkte des Dreiecks
for _ in range(iterationen):
zufallspunkt = random.choice(punkte)
ziel_x = (zufallspunkt[0] + turtle.xcor()) / 2
ziel_y = (zufallspunkt[1] + turtle.ycor()) / 2
turtle.goto(ziel_x, ziel_y)
turtle.dot(5) # Punkt zeichnen
# Testfälle
# zeichne_dreieck(1000, (0, 0))
# Ausgabe: Dreieck mit 1000 Punkten
# zeichne_dreieck(1000, (100, 100))
# Ausgabe: Dreieck mit 1000 Punkten, verschoben um (100, 100)
# zeichne_dreieck(1000, (-100, -100))
# Ausgabe: Dreieck mit 1000 Punkten, verschoben um (-100, -100)
if __name__ == "__main__":
print("Der Rechner rechnet Dezimalzahlen in Oktalzahlen um.")
print("Geben Sie eine Dezimalzahl ein.")
print(decimal_to_octal(int(input("Dezimalzahl: "))))
print("Der Rechner rechnet Dezimalzahlen in Zahlen mit einer beliebigen Basis um.")
print("Geben Sie eine Dezimalzahl und eine Basis ein.")
print(decimal_to_basis(int(input("Decimal: ")), int(input("Basis: "))))
print("Der Rechner zeichnet ein Chaos-Turtle.")
print("In einem Dreieck-pattern werden Punkte gezeichnet.")
print("Geben Sie die Anzahl der Iterationen ein.")
chaos_turtle(int(input("Interationen: ")),
(int(input("Startpunkt X Kooridnate: ")), int(input("Startpunkt Y Kooridnate: "))))
input("Press Enter to close window...")

View file

@ -1,36 +0,0 @@
'''EPR Übungsblatt 03'''
__author__ = "7987847, Werner"
import epr_functions
print("Welcome to the EPR Functions Console.")
print("Type 'help' for a list of commands.")
print("Type 'exit' to exit the console.")
# Main loop of the console
while True:
command = input("> ")
try:
if command == "help":
print("Commands:")
print("help - Shows this help")
print("exit - Exits the console")
print("decimal_to_octal - Converts a decimal number to an octal number")
print("decimal_to_basis - Converts a decimal number to a number with a given base")
print("chaos_turtle - Draws a random pattern with a turtle")
elif command == "exit":
break
elif command == "decimal_to_octal":
print("Der Rechner rechnet Dezimalzahlen in Oktalzahlen um.")
print("Geben Sie eine positive Dezimalzahl ein.")
print(epr_functions.decimal_to_octal(int(input("Dezimalzahl: "))))
elif command == "decimal_to_basis":
print("Der Rechner rechnet Dezimalzahlen in Zahlen mit einer beliebigen Basis um.")
print("Geben Sie eine positive Dezimalzahl und eine positive Basis ein.")
print(epr_functions.decimal_to_basis(int(input("Dezimalzahl: ")), int(input("Basis: "))))
else:
print("Unknown command. Type 'help' for a list of commands.")
# Catch ValueError exceptions, when the user enters invalid input
except epr_functions.InvalidInputError:
print("Invalid input. Please try again.")

View file

@ -1,36 +0,0 @@
author: 7987847, Werner
Zur Nutzung muss eine kompatible Python version installiert sein.
Akzeptiert werden alle Python 3.x Versionen.
Das Programm kann mit dem Befehl `python3 main.py` im Ordner gestartet werden.
Oben ist der code zu sehen der hier nun beschrieben wird:
Zuerst wird der Spieler nach der Anzahl der Spieler gefragt.
Danach wird er nach der Anzahl der Karten gefragt.
Zuletzt wird er nach dem Trumpf gefragt.
Danach wird eine Liste mit allen Karten erstellt.
Diese Liste wird dann gemischt.
Danach werden die Karten an die Spieler verteilt.
Zuletzt werden die Karten ausgegeben und mit dem Trumpf verglichen.
Hinweis: Die Eingaben erlauben nur positive Zahlen und keine Buchstaben (bis auf den Trumpf).
Bei einer falschen Eingabe kommt es zu einem Fehler.
Hinweis: Bei der Eingabe des Trumpfs ist die Groß- und Kleinschreibung wichtig.
Es wird der erste Buchstabe groß geschrieben und der Rest klein.
Testfälle
---
Im Programmcode sind zu jeder der beiden Mittel jeweils 3 Testfälle angegeben.
PEP8
---
Der Programmcode ist soweit wie möglich nach PEP8 abgestimmt.
Von der Aufgabe vorgegebene Funktions- und Variablennamen wurden beibehalten.
Diese sind nicht PEP8 konform (snake_case naming).

View file

@ -1,192 +0,0 @@
'''EPR Übungsblatt 04'''
__author__="7987847, Werner"
import random
# a)
def create_card_list(number_of_cards:int) -> [(int, str)]:
'''Erzeugt eine Liste mit Karten mit den vier Farben
und Zahlen von 1 bis number_of_cards
number_of_cards: Anzahl der Karten
'''
card_list = []
for i in range(1, int((number_of_cards+1)/4)+1):
card_list.append((i, "Kreuz"))
card_list.append((i, "Pik"))
card_list.append((i, "Herz"))
card_list.append((i, "Karo"))
return card_list
# b)
def shuffle_card_list(cards:[(int, str)]) -> [(int, str)]:
'''Mischt eine Liste mit Karten
cards: Liste mit Karten
'''
random.shuffle(cards)
return cards
# c)
def compare_two_cards(card_one:(int, str), card_two:(int, str)) -> int:
'''Vergleicht zwei Karten
card_one: Erste Karte
card_two: Zweite Karte
'''
if card_one[0] < card_two[0]:
return 0
if card_one[0] == card_two[0]:
return 1
return 2
# d)
def compare_two_cards_trump(card_one:(int, str), card_two:(int, str),
trump:str) -> int:
'''Vergleiche Zwei Karten mit dem Trumpf
'''
if card_one[1] == trump and card_two[1] != trump:
return 0
if card_one[1] != trump and card_two[1] == trump:
return 1
return compare_two_cards(card_one, card_two)
# e)
def hand_out_cards(list_cards: [(int, str)], players: int, number_of_cards:
int) -> [[(int, str)]]:
'''Teilt die Karten an die Spieler aus
list_cards: Liste mit Karten
players: Anzahl der Spieler
number_of_cards: Anzahl der Karten pro Spieler
'''
list_players = []
for _ in range(players):
list_players.append([])
for _ in range(number_of_cards):
for j in range(players):
list_players[j].append(list_cards.pop(0))
return list_players
def main():
'''Hauptprogramm'''
# Testfälle
# a)
# create_card_list(0)
# Rückgabe: []
# create_card_list(32)
# Rückgabe: [(1, 'Kreuz'), (1, 'Pik'), (1, 'Herz'), (1, 'Karo'),
# (2, 'Kreuz'), (2, 'Pik'), (2, 'Herz'), (2, 'Karo'), (3, 'Kreuz'),
# (3, 'Pik'), (3, 'Herz'), (3, 'Karo'), (4, 'Kreuz'), (4, 'Pik'),
# (4, 'Herz'), (4, 'Karo'), (5, 'Kreuz'), (5, 'Pik'), (5, 'Herz'),
# (5, 'Karo'), (6, 'Kreuz'), (6, 'Pik'), (6, 'Herz'), (6, 'Karo'),
# (7, 'Kreuz'), (7, 'Pik'), (7, 'Herz'), (7, 'Karo'), (8, 'Kreuz'),
# (8, 'Pik'), (8, 'Herz'), (8, 'Karo')]
# create_card_list(-10)
# Rückgabe: []
# b)
# shuffle_card_list([])
# Rückgabe: []
# shuffle_card_list([(1, 'Kreuz'), (1, 'Pik'), (1, 'Herz'), (1, 'Karo'),
# (2, 'Kreuz'), (2, 'Pik'), (2, 'Herz'), (2, 'Karo'), (3, 'Kreuz'),
# (3, 'Pik'), (3, 'Herz'), (3, 'Karo'), (4, 'Kreuz'), (4, 'Pik'),
# (4, 'Herz'), (4, 'Karo'), (5, 'Kreuz'), (5, 'Pik'), (5, 'Herz'),
# (5, 'Karo'), (6, 'Kreuz'), (6, 'Pik'), (6, 'Herz'), (6, 'Karo'),
# (7, 'Kreuz'), (7, 'Pik'), (7, 'Herz'), (7, 'Karo'), (8, 'Kreuz'),
# (8, 'Pik'), (8, 'Herz'), (8, 'Karo')])
# Rückgabe: [(6, 'Pik'), (1, 'Kreuz'), (4, 'Karo'), (5, 'Kreuz'),
# (8, 'Karo'), (6, 'Herz'), (3, 'Herz'), (1, 'Herz'), (4, 'Pik'),
# (8, 'Pik'), (2, 'Kreuz'), (5, 'Pik'), (3, 'Karo'), (2, 'Herz'),
# (7, 'Pik'), (2, 'Pik'), (7, 'Herz'), (1, 'Pik'), (8, 'Herz'),
# (7, 'Karo'), (6, 'Karo'), (5, 'Herz'), (4, 'Herz'), (3, 'Pik'),
# (2, 'Karo'), (5, 'Karo'), (6, 'Kreuz'), (1, 'Karo'), (8, 'Kreuz'),
# (3, 'Kreuz'), (7, 'Kreuz'), (4, 'Kreuz')]
# (Kann auch anders aussehen)
# shuffle_card_list([(1, 'Kreuz'), (1, 'Pik'), (1, 'Herz'), (1, 'Karo')]
# Rückgabe: [(1, 'Pik'), (1, 'Kreuz'), (1, 'Karo'), (1, 'Herz')]
# (Kann auch anders aussehen)
# c)
# compare_two_cards((1, 'Kreuz'), (1, 'Pik'))
# Rückgabe: 1
# compare_two_cards((1, 'Kreuz'), (2, 'Pik'))
# Rückgabe: 0
# compare_two_cards(('Pik), (1))
# Rückgabe: TypeError: 'int' object is not subscriptable
# d)
# compare_two_cards_trump((1, 'Kreuz'), (1, 'Pik'), 'Kreuz')
# Rückgabe: 1
# compare_two_cards_trump((1, 'Kreuz'), (1, 'Pik'), 'Pik')
# Rückgabe: 0
# compare_two_cards_trump((1, 'Kreuz'), (1, 'Pik'), 'Herz')
# Rückgabe: 0
# e)
# hand_out_cards([(1, 'Kreuz'), (1, 'Pik'), (1, 'Herz'), (1, 'Karo'),
# (2, 'Kreuz'), (2, 'Pik'), (2, 'Herz'), (2, 'Karo'), (3, 'Kreuz'),
# (3, 'Pik'), (3, 'Herz'), (3, 'Karo'), (4, 'Kreuz'), (4, 'Pik'),
# (4, 'Herz'), (4, 'Karo'), (5, 'Kreuz'), (5, 'Pik'), (5, 'Herz'),
# (5, 'Karo'), (6, 'Kreuz'), (6, 'Pik'), (6, 'Herz'), (6, 'Karo'),
# (7, 'Kreuz'), (7, 'Pik'), (7, 'Herz'), (7, 'Karo'), (8, 'Kreuz'),
# (8, 'Pik'), (8, 'Herz'), (8, 'Karo')], 0, 0)
# Rückgabe: []
# hand_out_cards([(1, 'Kreuz'), (1, 'Pik'), (1, 'Herz'), (1, 'Karo'),
# (2, 'Kreuz'), (2, 'Pik'), (2, 'Herz'), (2, 'Karo'), (3, 'Kreuz'),
# (3, 'Pik'), (3, 'Herz'), (3, 'Karo'), (4, 'Kreuz'), (4, 'Pik'),
# (4, 'Herz'), (4, 'Karo'), (5, 'Kreuz'), (5, 'Pik'), (5, 'Herz'),
# (5, 'Karo'), (6, 'Kreuz'), (6, 'Pik'), (6, 'Herz'), (6, 'Karo'),
# (7, 'Kreuz'), (7, 'Pik'), (7, 'Herz'), (7, 'Karo'), (8, 'Kreuz'),
# (8, 'Pik'), (8, 'Herz'), (8, 'Karo')], 4, 0)
# Rückgabe: [[], [], [], []]
# hand_out_cards([], 4, 4)
# Rückgabe: IndexError: pop from empty list
print("Es wird ein Kartenspiel erstellt.")
print("Geben Sie die Anzahl der Spieler ein.")
players = int(input("Anzahl der Spieler: "))
print("Geben Sie die Anzahl der Karten ein.")
number_of_cards = int(input("Anzahl der Karten: "))
print("Geben Sie den Trumpf ein.")
trump = input("Trumpf: ")
card_list = create_card_list(number_of_cards)
card_list = shuffle_card_list(card_list)
player_list = hand_out_cards(card_list, players, number_of_cards)
print("Die Karten werden ausgegeben.")
for i in range(players):
print("Spieler " + str(i + 1) + ":")
for j in range(number_of_cards):
print(player_list[i][j], end=" ")
print()
print("Es werden die Karten mit dem Trumpf verglichen.")
for i in range(players):
print("Spieler " + str(i + 1) + ":")
for j in range(number_of_cards):
if player_list[i][j][1] == trump:
print(player_list[i][j], end=" ")
print()
if __name__ == '__main__':
main()

View file

@ -1,40 +0,0 @@
author: 7987847, Werner
Zur Nutzung muss eine kompatible Python version installiert sein.
Akzeptiert werden alle Python 3.x Versionen.
Das Programm kann mit dem Befehl `python3 main.py` im Ordner gestartet werden.
Das Programm ist ein Kartenspiel für 3-4 Spieler. Es werden 12 Karten (1-4 in Kreuz, herz, Karo) verwendet
## Regeln wie auf dem Übungsblatt beschrieben:
Gespielt wird mit 3 4 Spielern.
Vorbereitung
Es gibt drei verschiedene Farben (Karo, Herz, und Kreuz). Die jeweils höchste Karte einer Farbe ist die 4, die
niedrigste eine 1. Zu Beginn des Spiels werden alle Karten vollständig an die Spieler verteilt.
Ziel des Spiels und Spielablauf
Spieler probieren Stiche zu vermeiden in denen Karten der Farbe Kreuz auftauchen. Jede Karte mit einem
Kreuz gibt einen Strafpunkt. Am Ende des Spiels, d.h. nachdem alle Karten gespielt wurden, werden die
EPR WiSe 2023/2024 2
Strafpunkte notiert. Der Spieler mit den wenigsten Strafpunkten gewinnt. Es können auch mehrere Spieler
gewinnen.
Stiche
Jeder Spieler spielt reihum genau eine Karte aus der Hand aus. Diese Karten bilden den Stich. In einem Spiel
werden so viele Stiche gespielt, wie Spieler Handkarten besitzen. Der beginnende Spieler kann jede Karte aus
der Hand abspielen. Die Farbe der ersten ausgespielten Karte in einem Stich ist Trumpf und muss bedient
werden. Das heißt, hat ein Spieler die Farbe der erstgelegten Karte auf der Hand, muss er diese spielen. Kann
ein Spieler die Trumpffarbe nicht spielen, darf dieser Spieler eine andere Farbe spielen. Am Anfang jedes Stichs
wird die Trumpffarbe neu bestimmt. Die Karte mit dem höchsten Wert der Trumpffarbe gewinnt und der
Spieler, der diese Karte ausgespielt hat, bekommt alle Karten des Stichs. Karten, die eine andere Farbe als die
Trumpffarbe haben, können einen Stich nie gewinnen. Nach jedem Stich werden die Stichkarten ausgewertet
und die Strafpunkte der Spieler aufaddiert. Jede Kreuz-Karte ergibt einen Strafpunkt.
## Durchführung des Programms
Es wird zunächst nach der Anzahl an Spielern gefragt. Es können 3 oder 4 Spieler ausgewählt werden.
Dann wird nach den Namen gefragt. Gibt der Benutzer bei einem der Spieler keinen Namen ein, wird dieser Spieler 'Spieler X' genannt, wobei X die Nummer des Spielers ist.
Dann werden die Karten gemischt, an die Spieler verteilt und es geht los.

View file

@ -1,206 +0,0 @@
'''EPR Übungsblatt 04'''
__author__="7987847, Werner"
import random
# a)
def create_card_list(number_of_cards:int) -> [(int, str)]:
'''Erzeugt eine Liste mit Karten mit den vier Farben
und Zahlen von 1 bis number_of_cards
number_of_cards: Anzahl der Karten
'''
card_list = []
for i in range(1, int((number_of_cards+1)/3)+1):
card_list.append((i, "Kreuz"))
#card_list.append((i, "Pik"))
card_list.append((i, "Herz"))
card_list.append((i, "Karo"))
return card_list
# b)
def shuffle_card_list(cards:[(int, str)]) -> [(int, str)]:
'''Mischt eine Liste mit Karten
cards: Liste mit Karten
'''
random.shuffle(cards)
return cards
# c)
def compare_two_cards(card_one:(int, str), card_two:(int, str)) -> int:
'''Vergleicht zwei Karten
card_one: Erste Karte
card_two: Zweite Karte
'''
if card_one[0] < card_two[0]:
return 0
if card_one[0] == card_two[0]:
return 1
return 2
# d)
def compare_two_cards_trump(card_one:(int, str), card_two:(int, str),
trump:str) -> int:
'''Vergleiche Zwei Karten mit dem Trumpf
'''
if card_one[1] == trump and card_two[1] != trump:
return 0
if card_one[1] != trump and card_two[1] == trump:
return 1
return compare_two_cards(card_one, card_two)
# e)
def hand_out_cards(list_cards: [(int, str)], players: int, number_of_cards:
int) -> [[(int, str)]]:
'''Teilt die Karten an die Spieler aus
list_cards: Liste mit Karten
players: Anzahl der Spieler
number_of_cards: Anzahl der Karten pro Spieler
'''
list_players = []
for _ in range(players):
list_players.append([])
for _ in range(number_of_cards):
for j in range(players):
list_players[j].append(list_cards.pop(0))
return list_players
def hand_out_cards_modified(list_cards: [(int, str)], players: {str: list}, number_of_cards:
int) -> [[(int, str)]]:
'''Teilt die Karten an die Spieler aus
list_cards: Liste mit Karten
players: Anzahl der Spieler
number_of_cards: Anzahl der Karten pro Spieler
'''
for player in players:
for _ in range(number_of_cards):
players[player].append(list_cards.pop(0))
return players
def main():
'''Hauptprogramm'''
# Testfälle
# a)
# create_card_list(0)
# Rückgabe: []
# create_card_list(32)
# Rückgabe: [(1, 'Kreuz'), (1, 'Pik'), (1, 'Herz'), (1, 'Karo'),
# (2, 'Kreuz'), (2, 'Pik'), (2, 'Herz'), (2, 'Karo'), (3, 'Kreuz'),
# (3, 'Pik'), (3, 'Herz'), (3, 'Karo'), (4, 'Kreuz'), (4, 'Pik'),
# (4, 'Herz'), (4, 'Karo'), (5, 'Kreuz'), (5, 'Pik'), (5, 'Herz'),
# (5, 'Karo'), (6, 'Kreuz'), (6, 'Pik'), (6, 'Herz'), (6, 'Karo'),
# (7, 'Kreuz'), (7, 'Pik'), (7, 'Herz'), (7, 'Karo'), (8, 'Kreuz'),
# (8, 'Pik'), (8, 'Herz'), (8, 'Karo')]
# create_card_list(-10)
# Rückgabe: []
# b)
# shuffle_card_list([])
# Rückgabe: []
# shuffle_card_list([(1, 'Kreuz'), (1, 'Pik'), (1, 'Herz'), (1, 'Karo'),
# (2, 'Kreuz'), (2, 'Pik'), (2, 'Herz'), (2, 'Karo'), (3, 'Kreuz'),
# (3, 'Pik'), (3, 'Herz'), (3, 'Karo'), (4, 'Kreuz'), (4, 'Pik'),
# (4, 'Herz'), (4, 'Karo'), (5, 'Kreuz'), (5, 'Pik'), (5, 'Herz'),
# (5, 'Karo'), (6, 'Kreuz'), (6, 'Pik'), (6, 'Herz'), (6, 'Karo'),
# (7, 'Kreuz'), (7, 'Pik'), (7, 'Herz'), (7, 'Karo'), (8, 'Kreuz'),
# (8, 'Pik'), (8, 'Herz'), (8, 'Karo')])
# Rückgabe: [(6, 'Pik'), (1, 'Kreuz'), (4, 'Karo'), (5, 'Kreuz'),
# (8, 'Karo'), (6, 'Herz'), (3, 'Herz'), (1, 'Herz'), (4, 'Pik'),
# (8, 'Pik'), (2, 'Kreuz'), (5, 'Pik'), (3, 'Karo'), (2, 'Herz'),
# (7, 'Pik'), (2, 'Pik'), (7, 'Herz'), (1, 'Pik'), (8, 'Herz'),
# (7, 'Karo'), (6, 'Karo'), (5, 'Herz'), (4, 'Herz'), (3, 'Pik'),
# (2, 'Karo'), (5, 'Karo'), (6, 'Kreuz'), (1, 'Karo'), (8, 'Kreuz'),
# (3, 'Kreuz'), (7, 'Kreuz'), (4, 'Kreuz')]
# (Kann auch anders aussehen)
# shuffle_card_list([(1, 'Kreuz'), (1, 'Pik'), (1, 'Herz'), (1, 'Karo')]
# Rückgabe: [(1, 'Pik'), (1, 'Kreuz'), (1, 'Karo'), (1, 'Herz')]
# (Kann auch anders aussehen)
# c)
# compare_two_cards((1, 'Kreuz'), (1, 'Pik'))
# Rückgabe: 1
# compare_two_cards((1, 'Kreuz'), (2, 'Pik'))
# Rückgabe: 0
# compare_two_cards(('Pik), (1))
# Rückgabe: TypeError: 'int' object is not subscriptable
# d)
# compare_two_cards_trump((1, 'Kreuz'), (1, 'Pik'), 'Kreuz')
# Rückgabe: 1
# compare_two_cards_trump((1, 'Kreuz'), (1, 'Pik'), 'Pik')
# Rückgabe: 0
# compare_two_cards_trump((1, 'Kreuz'), (1, 'Pik'), 'Herz')
# Rückgabe: 0
# e)
# hand_out_cards([(1, 'Kreuz'), (1, 'Pik'), (1, 'Herz'), (1, 'Karo'),
# (2, 'Kreuz'), (2, 'Pik'), (2, 'Herz'), (2, 'Karo'), (3, 'Kreuz'),
# (3, 'Pik'), (3, 'Herz'), (3, 'Karo'), (4, 'Kreuz'), (4, 'Pik'),
# (4, 'Herz'), (4, 'Karo'), (5, 'Kreuz'), (5, 'Pik'), (5, 'Herz'),
# (5, 'Karo'), (6, 'Kreuz'), (6, 'Pik'), (6, 'Herz'), (6, 'Karo'),
# (7, 'Kreuz'), (7, 'Pik'), (7, 'Herz'), (7, 'Karo'), (8, 'Kreuz'),
# (8, 'Pik'), (8, 'Herz'), (8, 'Karo')], 0, 0)
# Rückgabe: []
# hand_out_cards([(1, 'Kreuz'), (1, 'Pik'), (1, 'Herz'), (1, 'Karo'),
# (2, 'Kreuz'), (2, 'Pik'), (2, 'Herz'), (2, 'Karo'), (3, 'Kreuz'),
# (3, 'Pik'), (3, 'Herz'), (3, 'Karo'), (4, 'Kreuz'), (4, 'Pik'),
# (4, 'Herz'), (4, 'Karo'), (5, 'Kreuz'), (5, 'Pik'), (5, 'Herz'),
# (5, 'Karo'), (6, 'Kreuz'), (6, 'Pik'), (6, 'Herz'), (6, 'Karo'),
# (7, 'Kreuz'), (7, 'Pik'), (7, 'Herz'), (7, 'Karo'), (8, 'Kreuz'),
# (8, 'Pik'), (8, 'Herz'), (8, 'Karo')], 4, 0)
# Rückgabe: [[], [], [], []]
# hand_out_cards([], 4, 4)
# Rückgabe: IndexError: pop from empty list
print("Es wird ein Kartenspiel erstellt.")
print("Geben Sie die Anzahl der Spieler ein.")
players = int(input("Anzahl der Spieler: "))
print("Geben Sie die Anzahl der Karten ein.")
number_of_cards = int(input("Anzahl der Karten: "))
print("Geben Sie den Trumpf ein.")
trump = input("Trumpf: ")
card_list = create_card_list(number_of_cards)
card_list = shuffle_card_list(card_list)
player_list = hand_out_cards(card_list, players, number_of_cards)
print("Die Karten werden ausgegeben.")
for i in range(players):
print("Spieler " + str(i + 1) + ":")
for j in range(number_of_cards):
print(player_list[i][j], end=" ")
print()
print("Es werden die Karten mit dem Trumpf verglichen.")
for i in range(players):
print("Spieler " + str(i + 1) + ":")
for j in range(number_of_cards):
if player_list[i][j][1] == trump:
print(player_list[i][j], end=" ")
print()
if __name__ == '__main__':
main()

View file

@ -1,290 +0,0 @@
'''EPR Übungsblatt 05'''
__author__="7987847, Werner"
import random
import blatt04
def load_players() -> [str]:
'''Erstellt die Spieler des Spiels'''
while True:
try:
player_count = int(input("Anzahl der Spieler (3-4): "))
if player_count in [3, 4]:
break
except ValueError:
pass
player_names = []
for i in range(player_count):
print("Spieler", i+1, "Name: ", end='')
name = input()
if name == "":
name = "Spieler " + str(i+1)
player_names.append(name)
return player_names
def initialize_variables(players:[str]) -> ({str: int}, {str: list}):
'''Initialisiert die Variablen für das Spiel'''
score_dict = {}
hand_dict = {}
# Erstelle und mische das Kratenblatt
deck = blatt04.create_card_list(12)
deck = blatt04.shuffle_card_list(deck)
for i in players:
score_dict[i] = 0
hand_dict[i] = []
hand_dict = blatt04.hand_out_cards_modified(deck, hand_dict, 3)
return score_dict, hand_dict
def play_game(players: list, scores: {str: int}, all_hands: {str: list}) -> {str: int}:
'''Spielt das Spiel'''
game_over = False
while not game_over:
# Ermittlung einer zufälligen Reihenfolge der Spieler
random.shuffle(players)
trumpf = "any"
played_cards = []
for player in players:
# Karte spielen
# player hand von dict all_hands holen
player_hand = all_hands.get(player)
print("-------------------")
print("Spieler", player, "ist an der Reihe")
played_card, player_cards = play_card(player_hand, trumpf)
all_hands[player] = player_cards
# Wenn der Spieler an der Reihe ist
if player == players[0]:
trumpf = played_card[1]
print("~~~~~~~~~~~~~~~~~~~")
print("Trumpf ist", trumpf)
print("~~~~~~~~~~~~~~~~~~~")
played_cards.append(played_card)
# Ermittlung des Gewinners
winner = get_winner(played_cards, trumpf)
# Punktevergabe
if winner != -1:
scores[players[winner]] += 1
# Gewinner bekommt die Karten
for card in played_cards:
all_hands[players[winner]].append(card)
print("Punktestand: ", scores)
# Überprüfung ob das Spiel zu Ende ist
for player in players:
if len(all_hands[player]) == 0:
game_over = True
print("Das Spiel ist zu Ende.")
# sortiere die spieler scores nach der höhe
sorted_scores = sorted(scores.items(), key=lambda x: x[1])
players_won = []
players_won.append(sorted_scores[0][0])
for i in range(len(sorted_scores)):
if i == len(sorted_scores) - 1:
break
if sorted_scores[i][1] == sorted_scores[i+1][1]:
players_won.append(sorted_scores[i+1][0])
print("Die Spieler", players_won, "haben gewonnen.")
def check_card(card: (int, str), player_hand: list, trump: str) -> bool:
'''Überprüft ob eine Karte gespielt werden darf'''
if card[1] == trump:
return True
for i in player_hand:
if i[1] == trump:
return False
return True
def play_card(player_hand: list, trump: str) -> ((int, str), list):
'''Spielt eine Karte aus der Hand'''
for i in player_hand:
print(i + 1, player_hand[i])
card_valid = False
while not card_valid:
played_card_index = input(
"Karte wählen. Bei illegalem Zug wird dies wiederholt.\
(Nummer von 1 - " +
str(len(player_hand)) + "): ")
try:
played_card_index = int(played_card_index)
player_hand[played_card_index - 1]
except ValueError:
print("Keine gültige Zahl")
continue
card_valid = check_card(player_hand[played_card_index - 1], player_hand, trump)
print("Karte gespielt: ", player_hand[i-1])
return player_hand.pop(i-1), player_hand
def get_winner(current_trick: list, trump: str) -> int:
'''Ermittelt den Gewinner eines Stiches'''
# Ermittelt die Trumpfkarten der liste current_trick.
trump_cards = list(filter(lambda x: x[1] == trump, current_trick))
if len(trump_cards) > 0:
# Ermittelt die höchste Trumpfkarte
highest_trump = max(trump_cards, key=lambda x: x[0])
return current_trick.index(highest_trump)
# Wenn es keine Trumpkarten gibt, gewinnt niemand
return -1
if __name__ == '__main__':
players = load_players()
scores, hands = initialize_variables(players)
play_game(players, scores, hands)
# Testfälle
# a)
# load_players()
# Ausgabe: Anzahl der Spieler (3-4): 3
# Spieler 1 Name: Spieler 1
# Spieler 2 Name: Spieler 2
# Spieler 3 Name: Spieler 3
# Rückgabe: ['Spieler 1', 'Spieler 2', 'Spieler 3']
# load_players()
# Ausgabe: Anzahl der Spieler (3-4): 4
# Spieler 1 Name: Spieler 1
# Spieler 2 Name: Spieler 2
# Spieler 3 Name: Spieler 3
# Spieler 4 Name: Spieler 4
# Rückgabe: ['Spieler 1', 'Spieler 2', 'Spieler 3', 'Spieler 4']
# load_players()
# Ausgabe: Anzahl der Spieler (3-4): 2
# Anzahl der Spieler (3-4): 5
# Anzahl der Spieler (3-4): 3
# Spieler 1 Name: Spieler 1
# Spieler 2 Name: Spieler 2
# Spieler 3 Name: Spieler 3
# Rückgabe: ['Spieler 1', 'Spieler 2', 'Spieler 3']
# b)
# initialize_variables(['Spieler 1', 'Spieler 2', 'Spieler 3'])
# Rückgabe: ({'Spieler 1': 0, 'Spieler 2': 0, 'Spieler 3': 0},
# {'Spieler 1': [(1, 'Kreuz'), (1, 'Pik'), (1, 'Herz')], 'Spieler 2':
# [(1, 'Karo'), (2, 'Kreuz'), (2, 'Pik')], 'Spieler 3': [(2, 'Herz'),
# (2, 'Karo'), (3, 'Kreuz')]})
# initialize_variables(['Spieler 1', 'Spieler 2', 'Spieler 3', 'Spieler 4'])
# Rückgabe: ({'Spieler 1': 0, 'Spieler 2': 0, 'Spieler 3': 0,
# 'Spieler 4': 0}, {'Spieler 1': [(1, 'Kreuz'), (1, 'Pik'), (1, 'Herz')],
# 'Spieler 2': [(1, 'Karo'), (2, 'Kreuz'), (2, 'Pik')], 'Spieler 3':
# [(2, 'Herz'), (2, 'Karo'), (3, 'Kreuz')], 'Spieler 4': [(3, 'Pik'),
# (3, 'Herz'), (3, 'Karo')]})
# initialize_variables(['Spieler 1', 'Spieler 2'])
# Rückgabe: ({'Spieler 1': 0, 'Spieler 2': 0}, {'Spieler 1': [(1, 'Kreuz'),
# (1, 'Pik'), (1, 'Herz')], 'Spieler 2': [(1, 'Karo'), (2, 'Kreuz'),
# (2, 'Pik')]})
# c)
# play_game(['Spieler 1', 'Spieler 2', 'Spieler 3'], {'Spieler 1': 0,
# 'Spieler 2': 0, 'Spieler 3': 0}, {'Spieler 1': [(1, 'Kreuz'), (1, 'Pik'),
# (1, 'Herz')], 'Spieler 2': [(1, 'Karo'), (2, 'Kreuz'), (2, 'Pik')],
# 'Spieler 3': [(2, 'Herz'), (2, 'Karo'), (3, 'Kreuz')]})
# Spiel wird gespielt
# play_game(['Spieler 1', 'Spieler 2', 'Spieler 3', 'Spieler 4'],
# {'Spieler 1': 0, 'Spieler 2': 0, 'Spieler 3': 0, 'Spieler 4': 0},
# {'Spieler 1': [(1, 'Kreuz'), (1, 'Pik'), (1, 'Herz')], 'Spieler 2':
# [(1, 'Karo'), (2, 'Kreuz'), (2, 'Pik')], 'Spieler 3': [(2, 'Herz'),
# (2, 'Karo'), (3, 'Kreuz')], 'Spieler 4': [(3, 'Pik'), (3, 'Herz'),
# (3, 'Karo')]})
# Spiel wird gespielt
# play_game(['Spieler 1', 'Spieler 2'], {'Spieler 1': 0, 'Spieler 2': 0},
# {'Spieler 1': [(1, 'Kreuz'), (1, 'Pik'), (1, 'Herz')], 'Spieler 2':
# [(1, 'Karo'), (2, 'Kreuz'), (2, 'Pik')]})
# Spiel wird gespielt
# d)
# check_card((1, 'Kreuz'), [(1, 'Kreuz'), (1, 'Pik'), (1, 'Herz')], 'Karo')
# Rückgabe: True
# check_card((1, 'Kreuz'), [(1, 'Kreuz'), (1, 'Pik'), (1, 'Herz')], 'Pik')
# Rückgabe: False
# check_card((1, 'Kreuz'), [(1, 'Kreuz'), (1, 'Pik'), (1, 'Herz')], 'Herz')
# Rückgabe: True
# e)
# play_card([(1, 'Kreuz'), (1, 'Pik'), (1, 'Herz')], 'Karo')
# Ausgabe: 1 (Karte wählen. Bei illegalem Zug wird dies wiederholt. (Nummer von 1 - 3): 1
# Karte gespielt: (1, 'Kreuz')
# Rückgabe: ((1, 'Kreuz'), [(1, 'Pik'), (1, 'Herz')])
# (Kann auch anders aussehen)
# play_card([(1, 'Kreuz'), (1, 'Pik'), (1, 'Herz')], 'Pik')
# Ausgabe: 1 (Karte wählen. Bei illegalem Zug wird dies wiederholt. (Nummer von 1 - 3): 1
# Karte gespielt: (1, 'Kreuz')
# Rückgabe: ((1, 'Kreuz'), [(1, 'Pik'), (1, 'Herz')])
# (Kann auch anders aussehen)
# play_card([(1, 'Kreuz'), (1, 'Pik'), (1, 'Herz')], 'Herz')
# Ausgabe: 1 (Karte wählen. Bei illegalem Zug wird dies wiederholt. (Nummer von 1 - 3): 1
# Karte gespielt: (1, 'Kreuz')
# Rückgabe: ((1, 'Kreuz'), [(1, 'Pik'), (1, 'Herz')])
# (Kann auch anders aussehen)
# f)
# get_winner([(1, 'Kreuz'), (1, 'Pik'), (1, 'Herz')], 'Karo')
# Rückgabe: 0
# get_winner([(1, 'Kreuz'), (1, 'Pik'), (1, 'Herz')], 'Pik')
# Rückgabe: 0
# get_winner([(1, 'Kreuz'), (1, 'Pik'), (1, 'Herz')], 'Herz')
# Rückgabe: 0

View file

@ -1,176 +0,0 @@
'''EPR Übung 7'''
__author__ = "7987847, Werner, 8004356, Gill"
import random
def gen_matrix(width_height: int) -> list[list[(int, int)]]:
'''Generiert eine nxn Matrix mit Zufallszahlen zwischen -9 und 9
Args:
n (int): Dimension der Matrix
Returns:
list(list()): nxn Matrix mit Zufallszahlen zwischen -9 und 9
'''
return [[random.randint(-9, 9) for _ in range(width_height)] for _ in range(width_height)]
def greedy_approach(matrix) -> list((int, int)):
'''Greedy Ansatz für den Weg durch die Matrix
Returns:
list((int, int)): Liste mit den Koordinaten des Weges
'''
width_height = len(matrix)
# Testmatrix
#matrix = [[4, 0, 8], [-3, -4, -7], [-8, -1, 7]]
# Startpunkt
path_list = [(0, 0)]
index = (0, 0)
cost = matrix[0][0]
# Solange der Endpunkt nicht erreicht ist
while index != (width_height-1, width_height-1):
# Aktuelle Position
index_x, index_y = index
best_next_index = None
# Bestimmen des bestmöglichen nächsten Schrittes
# nach Rechts
if index_x+1 < width_height:
# check if best_next_index not in path_list
if (index_x+1, index_y) not in path_list:
best_next_index = (index_x+1, index_y)
best_next_value = matrix[index_y][index_x+1]
# nach Unten
if index_y+1 < width_height:
if matrix[index_y+1][index_x] < best_next_value \
and (index_x, index_y+1) not in path_list:
best_next_index = (index_x, index_y+1)
best_next_value = matrix[index_y+1][index_x]
# nach Links
if index_x-1 >= 0:
if matrix[index_y][index_x-1] < best_next_value \
and (index_x-1, index_y) not in path_list:
best_next_index = (index_x-1, index_y)
best_next_value = matrix[index_y][index_x-1]
# nach Oben
if index_y-1 >= 0:
if matrix[index_y-1][index_x] < best_next_value \
and (index_x, index_y-1) not in path_list:
best_next_index = (index_x, index_y-1)
best_next_value = matrix[index_y-1][index_x]
# Wenn kein Schritt mehr möglich ist
if not best_next_index:
#print("Sackgasse!")
break
# Besten nächsten Schritt zum Weg hinzufügen
path_list.append(best_next_index)
index = best_next_index
cost += best_next_value
return path_list, cost
def recursive_optimal_path(
matrix,
current_position=(0, 0),
current_cost=0,
current_path=[]
):
'''Rekursiver Ansatz für den Weg durch die Matrix
Args:
matrix (list(list())): Matrix
current_position (tuple(int, int)): Aktuelle Position
current_cost (int): Aktuelle Kosten
current_path (list((int, int))): Aktueller Weg'''
rows = len(matrix)
end = (rows - 1, rows - 1)
# Base case: reached the bottom right corner
if current_position == end:
return current_path + [end], current_cost
row, col = current_position
neighbors = []
# Bestimmen des bestmöglichen nächsten Schrittes
if row > 0:
neighbors.append(((row - 1, col), matrix[row - 1][col]))
if row < rows - 1:
neighbors.append(((row + 1, col), matrix[row + 1][col]))
if col > 0:
neighbors.append(((row, col - 1), matrix[row][col - 1]))
if col < rows - 1:
neighbors.append(((row, col + 1), matrix[row][col + 1]))
best_path = None
best_cost = 99
# Alle Nachbarn durchgehen
for next_position, cost in neighbors:
# Wenn der Nachbar nicht im Pfad ist, dann wird der Pfad rekursiv fortgesetzt
# sonst bedeutet es, dass dieses Feld bereits besucht wurde
if next_position not in current_path:
new_path, new_cost = recursive_optimal_path(matrix, next_position,
current_cost + cost,
current_path + [current_position])
# Wenn der neue Pfad besser ist, wird der alte überschrieben
if new_cost < best_cost:
best_path = new_path
best_cost = new_cost
return best_path, best_cost
if __name__ == "__main__":
print("Greedy Ansatz")
print("-------------")
print("Je höher die Dimension der Matrix, desto länger dauert die Berechnung.")
dimension = input("Geben Sie die Dimension der Matrix ein (positive Zahl): ")
try:
dimension = int(dimension)
# Check if the dimension is positive
if dimension <= 0:
raise ValueError("Dimension must be a positive number.")
except (ValueError, TypeError) as e:
print("Bitte geben Sie eine positive Zahl ein.")
exit()
#Test 1 - Positive Number [3] as input --> generates Matrix successfully
#Test 2 - Negative Number [-1] as input --> Value Error
#Test 3 - String (Hello) as input --> Value Error
gened_matrix = gen_matrix(dimension)
print("Matrix:")
for i in gened_matrix:
print(i)
optimal_path, optimal_cost= greedy_approach(gened_matrix)
print("\nGreedy Ansatz")
print("------------------")
print("Weg:", optimal_path)
print("Kosten:", optimal_cost)
print("\nOptimierter Ansatz")
print("------------------")
optimal_path, optimal_cost = recursive_optimal_path(gened_matrix)
print("Weg:", optimal_path)
print("Kosten:", optimal_cost)

View file

@ -1,166 +0,0 @@
'''EPR Übung 7'''
__author__ = "7987847, Werner"
import random
def gen_matrix(width_height: int) -> list[list[(int, int)]]:
'''Generiert eine nxn Matrix mit Zufallszahlen zwischen -9 und 9
Args:
n (int): Dimension der Matrix
Returns:
list(list()): nxn Matrix mit Zufallszahlen zwischen -9 und 9
'''
return [[random.randint(-9, 9) for _ in range(width_height)] for _ in range(width_height)]
def greedy_approach(matrix) -> list((int, int)):
'''Greedy Ansatz für den Weg durch die Matrix
Returns:
list((int, int)): Liste mit den Koordinaten des Weges
'''
width_height = len(matrix)
# Testmatrix
#matrix = [[4, 0, 8], [-3, -4, -7], [-8, -1, 7]]
# Startpunkt
path_list = [(0, 0)]
index = (0, 0)
cost = matrix[0][0]
# Solange der Endpunkt nicht erreicht ist
while index != (width_height-1, width_height-1):
# Aktuelle Position
index_x, index_y = index
best_next_index = None
# Bestimmen des bestmöglichen nächsten Schrittes
# nach Rechts
if index_x+1 < width_height:
# check if best_next_index not in path_list
if (index_x+1, index_y) not in path_list:
best_next_index = (index_x+1, index_y)
best_next_value = matrix[index_y][index_x+1]
# nach Unten
if index_y+1 < width_height:
if matrix[index_y+1][index_x] < best_next_value \
and (index_x, index_y+1) not in path_list:
best_next_index = (index_x, index_y+1)
best_next_value = matrix[index_y+1][index_x]
# nach Links
if index_x-1 >= 0:
if matrix[index_y][index_x-1] < best_next_value \
and (index_x-1, index_y) not in path_list:
best_next_index = (index_x-1, index_y)
best_next_value = matrix[index_y][index_x-1]
# nach Oben
if index_y-1 >= 0:
if matrix[index_y-1][index_x] < best_next_value \
and (index_x, index_y-1) not in path_list:
best_next_index = (index_x, index_y-1)
best_next_value = matrix[index_y-1][index_x]
# Wenn kein Schritt mehr möglich ist
if not best_next_index:
print("Sackgasse!")
break
# Besten nächsten Schritt zum Weg hinzufügen
path_list.append(best_next_index)
index = best_next_index
cost += best_next_value
return path_list, cost
def recursive_optimal_path(
matrix,
current_position=(0, 0),
current_cost=0,
current_path=[]
):
'''Rekursiver Ansatz für den Weg durch die Matrix
Args:
matrix (list(list())): Matrix
current_position (tuple(int, int)): Aktuelle Position
current_cost (int): Aktuelle Kosten
current_path (list((int, int))): Aktueller Weg'''
rows = len(matrix)
end = (rows - 1, rows - 1)
# Base case: reached the bottom right corner
if current_position == end:
return current_path + [end], current_cost
row, col = current_position
neighbors = []
# Bestimmen des bestmöglichen nächsten Schrittes
if row > 0:
neighbors.append(((row - 1, col), matrix[row - 1][col]))
if row < rows - 1:
neighbors.append(((row + 1, col), matrix[row + 1][col]))
if col > 0:
neighbors.append(((row, col - 1), matrix[row][col - 1]))
if col < rows - 1:
neighbors.append(((row, col + 1), matrix[row][col + 1]))
best_path = None
best_cost = 99
# Alle Nachbarn durchgehen
for next_position, cost in neighbors:
# Wenn der Nachbar nicht im Pfad ist, dann wird der Pfad rekursiv fortgesetzt
# sonst bedeutet es, dass dieses Feld bereits besucht wurde
if next_position not in current_path:
new_path, new_cost = recursive_optimal_path(matrix, next_position,
current_cost + cost,
current_path + [current_position])
# Wenn der neue Pfad besser ist, wird der alte überschrieben
if new_cost < best_cost:
best_path = new_path
best_cost = new_cost
return best_path, best_cost
if __name__ == "__main__":
print("Greedy Ansatz")
print("-------------")
print("Je höher die Dimension der Matrix, desto länger dauert die Berechnung.")
dimension = input("Geben Sie die Dimension der Matrix ein (positive Zahl): ")
try:
dimension = int(dimension)
except ValueError:
print("Bitte geben Sie eine positive Zahl ein.")
exit()
gened_matrix = gen_matrix(dimension)
print("Matrix:")
for i in gened_matrix:
print(i)
optimal_path, optimal_cost= greedy_approach(gened_matrix)
print("Weg:", optimal_path)
print("Kosten:", optimal_cost)
print("\nOptimierter Ansatz")
print("------------------")
optimal_path, optimal_cost = recursive_optimal_path(gened_matrix)
print("Weg:", optimal_path)
print("Kosten:", optimal_cost)

View file

@ -1,100 +0,0 @@
'''EPRE Übung 7 Aufgabe 3'''
__author__ = "7987847, Werner, 8004356, Gill"
import concurrent.futures
import timeit
from main import greedy_approach, recursive_optimal_path, gen_matrix
def measure_runtime(function, matrix):
'''Misst die Laufzeit von function mit matrix als Argument
Args:
function (function): Funktion, deren Laufzeit gemessen werden soll
matrix (list(list(int))): Matrix, die als Argument an function übergeben wird
Returns:
float: Laufzeit von function mit matrix als Argument'''
runtime = timeit.timeit(lambda: function(matrix), number=100)
return runtime
def compare_runtimes_parallel(sizes, max_workers=16):
'''Vergleicht die Laufzeiten von greedy_approach und recursive_optimal_path für
verschiedene Matrixgrößen
Args:
sizes (list(int)): Liste mit Matrixgrößen
max_workers (int, optional): Maximale Anzahl an Threads. Defaults to 16.
Returns:
list(float), list(float): Listen mit Laufzeiten von greedy_approach und
recursive_optimal_path
'''
greedy_runtimes = []
recursive_runtimes = []
with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
futures = []
for size in sizes:
matrix = gen_matrix(size)
# Greedy-Ansatz
greedy_future = executor.submit(measure_runtime, greedy_approach, matrix)
futures.append((greedy_future, "Greedy", size))
# Rekursiver optimaler Pfad
recursive_future = executor.submit(measure_runtime, recursive_optimal_path, matrix)
futures.append((recursive_future, "Recursive", size))
for future, label, size in futures:
runtime = future.result()
print(f"Size: {size}, {label} Runtime: {runtime:.6f} seconds")
if label == "Greedy":
greedy_runtimes.append(runtime)
else:
recursive_runtimes.append(runtime)
return greedy_runtimes, recursive_runtimes
def plot_results(sizes, greedy_runtimes, recursive_runtimes):
'''Plottet die Laufzeiten von greedy_approach und recursive_optimal_path für
verschiedene Matrixgrößen
Args:
sizes (list(int)): Liste mit Matrixgrößen
greedy_runtimes (list(float)): Liste mit Laufzeiten von greedy_approach
recursive_runtimes (list(float)): Liste mit Laufzeiten von recursive_optimal_path
'''
plt.plot(sizes, greedy_runtimes, label="Greedy Approach")
plt.plot(sizes, recursive_runtimes, label="Recursive Optimal Path")
plt.xlabel("Matrix Size")
plt.ylabel("Runtime (seconds)")
plt.title("Comparison of Runtimes")
plt.legend()
plt.xticks(range(min(sizes), max(sizes)+1))
plt.show()
if __name__ == "__main__":
matrix_sizes = list(range(1, 6))
greedy_runtimes, recursive_runtimes = compare_runtimes_parallel(matrix_sizes)
print("Greedy runtimes:")
for size, runtime in zip(matrix_sizes, greedy_runtimes):
print(f"Size: {size}, Runtime: {runtime:.6f} seconds")
print("Recursive runtimes:")
for size, runtime in zip(matrix_sizes, recursive_runtimes):
print(f"Size: {size}, Runtime: {runtime:.6f} seconds")
try:
import matplotlib.pyplot as plt
plot_results(matrix_sizes, greedy_runtimes, recursive_runtimes)
except ImportError:
print("matplotlib not installed. Skipping plotting of results.")
# Tests are in Documentation

View file

@ -1,100 +0,0 @@
'''EPRE Übung 7 Aufgabe 3'''
__author__ = "7987847, Werner"
import concurrent.futures
import timeit
from main import greedy_approach, recursive_optimal_path, gen_matrix
def measure_runtime(function, matrix):
'''Misst die Laufzeit von function mit matrix als Argument
Args:
function (function): Funktion, deren Laufzeit gemessen werden soll
matrix (list(list(int))): Matrix, die als Argument an function übergeben wird
Returns:
float: Laufzeit von function mit matrix als Argument'''
runtime = timeit.timeit(lambda: function(matrix), number=100)
return runtime
def compare_runtimes_parallel(sizes, max_workers=16):
'''Vergleicht die Laufzeiten von greedy_approach und recursive_optimal_path für
verschiedene Matrixgrößen
Args:
sizes (list(int)): Liste mit Matrixgrößen
max_workers (int, optional): Maximale Anzahl an Threads. Defaults to 16.
Returns:
list(float), list(float): Listen mit Laufzeiten von greedy_approach und
recursive_optimal_path
'''
greedy_runtimes = []
recursive_runtimes = []
with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
futures = []
for size in sizes:
matrix = gen_matrix(size)
# Greedy-Ansatz
greedy_future = executor.submit(measure_runtime, greedy_approach, matrix)
futures.append((greedy_future, "Greedy", size))
# Rekursiver optimaler Pfad
recursive_future = executor.submit(measure_runtime, recursive_optimal_path, matrix)
futures.append((recursive_future, "Recursive", size))
for future, label, size in futures:
runtime = future.result()
print(f"Size: {size}, {label} Runtime: {runtime:.6f} seconds")
if label == "Greedy":
greedy_runtimes.append(runtime)
else:
recursive_runtimes.append(runtime)
return greedy_runtimes, recursive_runtimes
def plot_results(sizes, greedy_runtimes, recursive_runtimes):
'''Plottet die Laufzeiten von greedy_approach und recursive_optimal_path für
verschiedene Matrixgrößen
Args:
sizes (list(int)): Liste mit Matrixgrößen
greedy_runtimes (list(float)): Liste mit Laufzeiten von greedy_approach
recursive_runtimes (list(float)): Liste mit Laufzeiten von recursive_optimal_path
'''
plt.plot(sizes, greedy_runtimes, label="Greedy Approach")
plt.plot(sizes, recursive_runtimes, label="Recursive Optimal Path")
plt.xlabel("Matrix Size")
plt.ylabel("Runtime (seconds)")
plt.title("Comparison of Runtimes")
plt.legend()
plt.xticks(range(min(sizes), max(sizes)+1))
plt.show()
if __name__ == "__main__":
matrix_sizes = list(range(1, 7))
greedy_runtimes, recursive_runtimes = compare_runtimes_parallel(matrix_sizes)
print("Greedy runtimes:")
for size, runtime in zip(matrix_sizes, greedy_runtimes):
print(f"Size: {size}, Runtime: {runtime:.6f} seconds")
print("Recursive runtimes:")
for size, runtime in zip(matrix_sizes, recursive_runtimes):
print(f"Size: {size}, Runtime: {runtime:.6f} seconds")
print("Recursive runtimes:")
for size, runtime in zip(matrix_sizes, recursive_runtimes):
print(f"Size: {size}, Runtime: {runtime:.6f} seconds")
print(f"Size: {size}, Runtime: {runtime:.6f} seconds")
try:
import matplotlib.pyplot as plt
plot_results(matrix_sizes, greedy_runtimes, recursive_runtimes)
except ImportError:
print("matplotlib not installed. Skipping plotting of results.")

View file

@ -1,20 +0,0 @@
author: 7987847, Werner
Aufgabe 1
---
Zur Nutzung muss eine kompatible Python version installiert sein.
Akzeptiert werden alle Python 3.x Versionen.
Das Programm kann mit dem Befehl `python3 main.py` im Ordner gestartet werden.
Nach dem Start wird der Benutzer aufgefordert, eine natürliche Zahl einzugeben.
Diese wird daraufhin in binär umgewandelt und ausgegeben.
Testfälle
---
Im Programmcode sind zu jeder der beiden Mittel jeweils 3 Testfälle angegeben.
PEP8
---
Der Programmcode ist soweit wie möglich nach PEP8 abgestimmt.

View file

@ -1,30 +0,0 @@
'''GPR Übungsblatt 03'''
__author__ = "7987847, Werner"
def dec_to_bin(zahl:int) -> str:
'''Umwandlung einer Dezimalzahl in eine Binärzahl
zahl: Dezimalzahl
'''
if zahl == 0:
return '0'
binzahl = ''
while zahl > 0:
binzahl = str(zahl % 2) + binzahl
zahl //= 2
return binzahl
print("Es wird eine Dezimalzahl in eine Binärzahl umgewandelt.")
print("Geben Sie eine Dezimalzahl ein.")
print(dec_to_bin(int(input("Dezimalzahl: "))))
# Testfälle
# dec_to_bin(0)
# Ausgabe: 0
# dec_to_bin(1)
# Ausgabe: 1
# dec_to_bin(69)
# Ausgabe: 1000101

View file

@ -1,12 +0,0 @@
author: 7987847, Werner
Das Programm ist eine Konsole für das epr_functions Modul.
Zur Nutzung muss eine kompatible Python version installiert sein.
Akzeptiert werden alle Python 3.x Versionen.
Das Programm kann mit dem Befehl `python3 main.py` im Ordner gestartet werden.
Beim Starten des Programms wird der Benutzer aufgefordert einen Hauptstring und einen Substring nacheinander einzugeben.
Das programm gibt den ersten Index aus, bei dem der Substring im Hauptstring vorkommt. Kommt dieser nicht vor, so wird -1 zurückgegeben.

Binary file not shown.

View file

@ -1,34 +0,0 @@
'''GPR Übungsblatt 05'''
__author__ = "7987847, Werner"
def str_find(string, substring):
"""Returns the index of the first occurrence of substring in string or
-1 if substring is not part of string"""
for i in range(len(string) - len(substring) + 1):
if string[i:i + len(substring)] == substring:
return i
return -1
if __name__ == "__main__":
print("Das Programm sucht nach Teilzeichenketten in Zeichenketten.")
print("Es wird der index der ersten Teilzeichenkette in der Zeichenkette ausgegeben.")
print("Ist die Teilzeichenkette nicht in der Zeichenkette enthalten,wird -1 ausgegeben.")
print("Geben Sie eine Zeichenkette und eine Teilzeichenkette ein.")
print(str_find(input("Zeichenkette: "), input("Teilzeichenkette: ")))
# Testfälle
# str_find("Hello World", "ll")
# Ausgabe: 2
# str_find("Hello", "World")
# Ausgabe: -1
# str_find("Hello", "Hello")
# Ausgabe: 0

Binary file not shown.

View file

@ -1,7 +0,0 @@
Kleopatra (* 69 v. Chr. in Alexandria; † 30 v. Chr. ebenda) war eine der bekanntesten Herrscherinnen des antiken Ägyptens. Als letzte Pharaonin der Ptolemäer-Dynastie erlebte sie dramatische politische Umwälzungen und Intrigen.
Als Geliebte von Gaius Iulius Caesar und später von Marcus Antonius spielte Kleopatra eine entscheidende Rolle in den Machtkämpfen dieser Zeit. Nach dem Tod von Caesar im Jahr 44 v. Chr. kehrte sie nach Ägypten zurück und stand vor der Herausforderung, ihr Reich zu stabilisieren.
Die Schlacht bei Actium im Jahr 31 v. Chr. markierte einen Wendepunkt in ihrem Schicksal, als sie an der Seite von Marcus Antonius gegen Octavian (der spätere Kaiser Augustus) kämpfte und letztendlich unterlag. Nach dem Selbstmord von Antonius im Jahr 30 v. Chr. fiel Ägypten unter die Kontrolle von Augustus, der Kleopatra gefangen nahm.
Kleopatras Tod im Jahr 30 v. Chr. durch den Biss einer Kobra symbolisierte das Ende einer Ära und den Beginn der römischen Vorherrschaft über Ägypten. Ihre Lebensgeschichte bleibt bis heute faszinierend und hat zahlreiche kulturelle und literarische Werke inspiriert.

View file

@ -1,34 +0,0 @@
__author__ = "7987847, Werner"
# Aufgabe 2 a) iii)
Mit Zeichenketten wie '52515' wird wie folgt umgegangen:
- Es werden die strings '52', '525', '25', '251', '51', '515' und '15' erkannt.
- Dies liegt daran, dass es keine Rolle spielt, ob vor oder nach der mehr-als-2-oder-3-stelligen Zahlenkette ein nicht numerisches Zeichen kommt. Somit enthält die Zeichenkette mehrere kürzere Zeichenketten
# Aufgabe 2 b)
Der reguläre Ausdruck stellt eine typische Email Adresse dar:
- ´^[A-Za-z0-9._%+-]+´: Beginnt mit mindestens einem alphanumerischen Zeichen oder den erlaubten Sonderzeichen (. _ % + -)
- `@`: Enthält das "@"-Symbol
- `[A-Za-z0-9.-]+`: Enthält mindestens ein alphanumerisches Zeichen oder einen Punkt zwischen "@" und der Domain
- `\.`: Enthält einen Punkt vor der Top-Level-Domain
- `[A-Z|a-z]{2,}$`: Endet mit mindestens zwei alphanumerischen Zeichen (Top-Level-Domain)
# Dokumentation *main.py*
Zur Nutzung muss eine kompatible Python version installiert sein.
Akzeptiert werden alle Python 3.x Versionen.
Das Programm kann mit dem Befehl `python3 main.py` im Ordner gestartet werden.
Nach dem Start wird die Datei `Kleopatra.txt` eingelesen und Kleopatra's weibliche Pronomen durch mänliche ausgetauscht.
Das Ergebnis wird ind er Konsole Ausgegeben.
Anschließend wird die Datei `Wortgitter_mitZahlen.txt` eingelesen und folgendes in der Konsole Ausgegeben:
i) Das Erste Vorkommen einer 0 gevolgt von einer Zahl und anschließend eines Buchstabens
ii) Alle Vorkommen aus i)
iii) Alle Zeichenfolgen aus 2 oder 3 Ziffern

View file

@ -1,25 +0,0 @@
17I7KJOU8HRUDIJ1P3YFFQX8ILOB46UKP4L7E9CKH94GN6PNKJ
LNBGM8P6WVDKGYOL2ZHBL5JK7DBLZK53S3TBCZRNLAT40S13II
UE8EHJ9VC9FW03YA68E6TUQS9IL56A560CC6YUVZO4ROAXH3SG
KPFS4ZKVVG0HRNC5L4XN1KVG9YYFA66WGBKOO04D0TA9U6363Q
IBSFLZZBM80DSYDN04P69UUZZPNVKD3U9PGFWJ5RY7LX304AOQ
GI7PRJFL5HG2T01WP5EUH7OET3KXLCL51DWJRV8VN9KMK91QQ6
LA1MQHRB9Z1EJ5T1TJR6EP97I9AQ59G6TQ7MZJDPLU2EZQ681C
0YR9CFQWKVKYYQHZ515ZP361UUWT363XYW2LRZLIVY3H3BG12H
GYB9LVGYUN4IYD83ARQQ3O49VA9LFHQF6D5B44YDCTIWVI1I0Z
B0E7BGWNR3GO85C8SO214H126JFB2QTJGVVOI6QTF7HXOCAXOL
1FN3XZKMWTFM5II80STDBIJS69C3GR46EJWHZVQZ8FMI8C4F8Z
LH0LPQBZIVGL6EGWRVNIZ0BWBD3SXKBQ52515QFPW42CIOCDAT
JX02RAYBAWB50CZQ2DPAHM0C3IC798SFWZF8HPVYR58R0QDTKZ
MIUY6R92RY8NSGUQ818VOZILM8XA552GGGTB22EK03OX1WFM8L
Z3DL0CQ1YD67ZSX4J8A3M52DHU0XEM7FSJUW13QMIK57T7IUNI
OJ82EROB735XA0RUGCK8FUAQSA6QKFURPRD6C2T5J0TLMPG4CB
7RSDZ70XZSV8MKMSU4S5Q5W3OWPD4LBM13RWEX2VLKC7ASGLNG
ML5KAQX11SP4VNF2XYT93U63RTMS4TXP09VNY0H4KYLZNQZ4SF
1OARDDAH1E06NN7C095JN5O2RWHB0CEN198I6TEABWPC26WUQR
XJRSDLYJ48I8S0C5VLA3KOM6JQLUB26KVYOW2INU3L58EWDUWH
311ZU721EN2HLE4QBL571NQZJQ0I9Y7GL2T2YWLXA6DO622TJO
2RFXMZLVCKA77LCQUQJ7X5I20NZ5G86EOECTY40R5J8YYBMYFM
KOQ52BOBOMZCNHC2POTRW5FITFU4GIG7J897DLEKBNAUXTNO7U
L06D55N9K6I27LCIOG6VWTH6HOO0ZRXZXQ4YUUPQ3QEMLFBOOC
TPB5C9EP39B8J8BCDJO2X3T3HFHN2055YLYIMCG8BTWI6YG9VO

View file

@ -1,66 +0,0 @@
'''GPR Übung 10 - Reguläre Ausdrücke'''
__author__ = "7987847, Werner"
import re
def cleopatra_change_gender():
'''
Lies den Text aus der Datei "Kleopatra.txt" ein und ersetze alle Vorkommen von "sie" durch "er".
Gib den modifizierten Text auf der Konsole aus.
'''
# Dateipfad zum Text
dateipfad = "Kleopatra.txt"
try:
# Text aus der Datei lesen
with open(dateipfad, 'r', encoding='utf-8') as datei:
text = datei.read()
# Verwende die sub()-Funktion, um "sie" durch "er" zu ersetzen
modifizierter_text = re.sub(r'\bsie\b', 'er', text, flags=re.IGNORECASE)
modifizierter_text = re.sub(r'\bIhre\b', 'Seine', modifizierter_text, flags=re.IGNORECASE)
# Gib den modifizierten Text auf der Konsole aus
print(modifizierter_text)
except FileNotFoundError:
print(f"Die Datei {dateipfad} wurde nicht gefunden.")
def find_patterns_in_text():
'''
Lies den Text aus der Datei "Wortgitter_mitZahlen.txt" ein und finde folgende Muster:
i) Findet das erste Vorkommen von Zeichenfolgen, die mit einer Null starten,
gefolgt von einer Zahl und einem Buchstaben
ii) Findet alle Vorkommen von Zeichenfolgen mit 2 oder 3 Zahlen hintereinander
Gib die gefundenen Muster auf der Konsole aus.
'''
# Dateipfad zum Text
dateipfad = "Wortgitter_mitZahlen.txt"
try:
# Text aus der Datei lesen
with open(dateipfad, 'r', encoding='utf-8') as datei:
text = datei.read()
# i) Findet das erste Vorkommen von Zeichenfolgen, die mit einer Null starten,
# gefolgt von einer Zahl und einem Buchstaben
pattern_i = re.findall(r'0[0-9][A-Za-z]', text)
print("i. Erstes gefundenes Muster:")
print(pattern_i[0] if len(pattern_i) > 0 else "Kein Muster gefunden.")
# ii) Alle vorkommen aus i)
print("\nii. Alle gefundenen Muster:")
print(pattern_i)
# iii) Findet alle Vorkommen von Zeichenfolgen mit 2 oder 3 Zahlen hintereinander
pattern_iii = re.findall(r'\d{2,3}', text)
print("\niii. Gefundene Muster:")
print(pattern_iii)
except FileNotFoundError:
print(f"Die Datei {dateipfad} wurde nicht gefunden.")
if __name__ == "__main__":
cleopatra_change_gender()
find_patterns_in_text()