mirror of
https://github.com/JonasunderscoreJones/EPI-2324.git
synced 2025-10-23 19:19:21 +02:00
Compare commits
No commits in common. "main" and "ue00" have entirely different histories.
29 changed files with 1 additions and 2212 deletions
11
.gitignore
vendored
11
.gitignore
vendored
|
@ -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
|
||||
|
|
|
@ -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.
|
|
@ -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.
|
|
@ -1,5 +0,0 @@
|
|||
a = 5
|
||||
b = 10
|
||||
if b:
|
||||
print("b gibt True")
|
||||
else: print("b gibt False")
|
|
@ -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).
|
209
EPR/ue02/main.py
209
EPR/ue02/main.py
|
@ -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:
|
|
@ -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.
|
|
@ -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...")
|
|
@ -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.")
|
|
@ -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).
|
||||
|
192
EPR/ue04/main.py
192
EPR/ue04/main.py
|
@ -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()
|
|
@ -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.
|
|
@ -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()
|
290
EPR/ue05/main.py
290
EPR/ue05/main.py
|
@ -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
|
176
EPR/ue07/main.py
176
EPR/ue07/main.py
|
@ -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)
|
|
@ -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)
|
|
@ -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
|
|
@ -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.")
|
|
@ -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.
|
Binary file not shown.
|
@ -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
|
|
@ -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.
|
@ -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.
|
@ -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.
|
|
@ -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
|
|
@ -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
|
|
@ -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()
|
Loading…
Add table
Add a link
Reference in a new issue