Compare commits
10
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 nvrl
|
1121c6a171 | ||
 mironov
|
9ea341183d | ||
|
mironov
|
801b641fb2 | ||
|
mironov
|
f3e49c96cd | ||
|
mironov
|
f89435117a | ||
|
nvrl
|
56c0d4bec3 | ||
|
nvrl
|
407389a5cb | ||
|
nvrl
|
da878ec3e6 | ||
|
nvrl
|
8ed82e01aa | ||
|
nvrl
|
23f4c7be52 |
No files matched your search
@@ -1,33 +1,33 @@
|
|||||||
# Übungsaufgaben zur EidP (WS2023) Klausur
|
# Übungsaufgaben zur EidP (WS2023) Klausur
|
||||||
|
|
||||||
Alle Aufgaben hier behandeln Konzepte aus der Vorlesung **Einführung in die Programmierung** von der Albert-Ludwig-Universität Freiburg. Hierbei handelt es sich um selbsterstellte Aufgaben der EidP-Tutoren [**Nils Pukropp**](mailto:nils@narl.io) und [**Daniel Mironow**](mailto:mail@danielmironov.dev) die bei der Vorbereitung auf die Klausur helfen sollen.
|
Alle Aufgaben hier behandeln Konzepte aus der Vorlesung **Einführung in die Programmierung** von der Albert-Ludwig-Universität Freiburg. Hierbei handelt es sich um selbsterstellte Aufgaben der EidP-Tutoren [**Nils Pukropp**](mailto:nils@narl.io) und [**Daniel Mironow**](mailto:mail@danielmironov.dev) die bei der Vorbereitung auf die Klausur helfen sollen. :D
|
||||||
|
|
||||||
## Reihenfolge der Themen
|
## Reihenfolge der Themen
|
||||||
|
|
||||||
Es gibt keine direkte Reihenfolge, lediglich Themen die sich teilweise überschneiden. Dennoch gibt es eine Reihenfolge nach Wichtigkeit der Themen:
|
Es gibt keine direkte Reihenfolge, lediglich Themen die sich teilweise überschneiden. Dennoch gibt es eine Reihenfolge nach Wichtigkeit der Themen:
|
||||||
|
|
||||||
- [Grundkonzept Schleifen (`for`, `while`, ...)](./loops)
|
- [Grundkonzept Schleifen (`for`, `while`, ...)](src/branch/main/loops)
|
||||||
- allgemeine Knobelaufgaben rund um Schleifen
|
- allgemeine Knobelaufgaben rund um Schleifen
|
||||||
- Einfach mit ein paar schwierigeren Aufgaben zum Nachdenken
|
- Einfach mit ein paar schwierigeren Aufgaben zum Nachdenken
|
||||||
- [Zeichenketten (Strings `str`)](./strings)
|
- [Zeichenketten (Strings `str`)](src/branch/main/strings)
|
||||||
- allgemeine Knobelaufgaben rund um `str`
|
- allgemeine Knobelaufgaben rund um `str`
|
||||||
- Einfach mit ein paar schwierigeren Aufgaben zum Nachdenken
|
- Einfach mit ein paar schwierigeren Aufgaben zum Nachdenken
|
||||||
- [Dataclasses (OOP `@dataclass`)](./dataclasses)
|
- [Dataclasses (OOP `@dataclass`)](src/branch/main/dataclasses)
|
||||||
- Objekt orientierte Programmierung mit `@dataclass`
|
- Objekt orientierte Programmierung mit `@dataclass`
|
||||||
- Einfach (Auswendig lernen)
|
- Einfach (Auswendig lernen)
|
||||||
- [Pattern Matching (`match`)](./pattern_matching)
|
- [Pattern Matching (`match`)](src/branch/main/pattern_matching)
|
||||||
- Intensive Übungen zu `match`
|
- Intensive Übungen zu `match`
|
||||||
- Mittel (Auswendig lernen, aber erfordert grundlegende Konzepte)
|
- Mittel (Auswendig lernen, aber erfordert grundlegende Konzepte)
|
||||||
- [Typvariabeln (Generics `[T]`)](./generics)
|
- [Typvariabeln (Generics `[T]`)](src/branch/main/generics)
|
||||||
- Platzhalter Variabeln um generische Typannotation umzusetzen
|
- Platzhalter Variabeln um generische Typannotation umzusetzen
|
||||||
- Mittel (Auswendig lernen, aber erfordert grundlegende Konzepte)
|
- Mittel (Auswendig lernen, aber erfordert grundlegende Konzepte)
|
||||||
- [Rekursion (Tree)](./recursion)
|
- [Rekursion (Tree)](src/branch/main/recursion)
|
||||||
- Sich selbst aufrufende Funktionen
|
- Sich selbst aufrufende Funktionen
|
||||||
- Schwer, da das Konzept etwas verwirrend ist, aber gut für schnelle Punkte in der Klausur!
|
- Schwer, da das Konzept etwas verwirrend ist, aber gut für schnelle Punkte in der Klausur!
|
||||||
- [Generator](./generator)
|
- [Generator](src/branch/main/generator)
|
||||||
- Erzeugen von Iteratoren auf die seltsame Python Art und Weise!
|
- Erzeugen von Iteratoren auf die seltsame Python Art und Weise!
|
||||||
- Mittel, da das Konzept etwas seltsam ist. Muss man einfach ein paar mal machen!
|
- Mittel, da das Konzept etwas seltsam ist. Muss man einfach ein paar mal machen!
|
||||||
- [Funktionale Programmierung](./functional_programming)
|
- [Funktionale Programmierung](src/branch/main/functional_programming)
|
||||||
- Programmieren-Paradigma bei dem der Programmfluss durch Funktionen bestimmt wird!
|
- Programmieren-Paradigma bei dem der Programmfluss durch Funktionen bestimmt wird!
|
||||||
- Schwer, da das Konzept etwas schwer zu verstehen ist und viele Grundlagen vorraussetzt
|
- Schwer, da das Konzept etwas schwer zu verstehen ist und viele Grundlagen vorraussetzt
|
||||||
|
|
||||||
@@ -45,9 +45,11 @@ Es gibt keine direkte Reihenfolge, lediglich Themen die sich teilweise überschn
|
|||||||
- Könnt auch gerne nachfragen wenn was nicht funktioniert!
|
- Könnt auch gerne nachfragen wenn was nicht funktioniert!
|
||||||
- Dann könnt ihr einfach die Tests mit `pytest` in der Konsole aufrufen
|
- Dann könnt ihr einfach die Tests mit `pytest` in der Konsole aufrufen
|
||||||
- Schlagen die Tests fehl sieht das so aus:
|
- Schlagen die Tests fehl sieht das so aus:
|
||||||
|
|
||||||
|
|
||||||
- Hier sagt euch Pytest auch was alles nicht an eurem Code funktioniert
|
- Hier sagt euch Pytest auch was alles nicht an eurem Code funktioniert
|
||||||
- Funktioniert euer Code sieht das so aus:
|
- Funktioniert euer Code sieht das so aus:
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
## Kontakt
|
## Kontakt
|
||||||
|
|||||||
@@ -0,0 +1 @@
|
|||||||
|
# primes generator
|
||||||
Whitespace-only changes.
@@ -0,0 +1,29 @@
|
|||||||
|
from typing import Iterator
|
||||||
|
|
||||||
|
|
||||||
|
def is_prime(n: int) -> bool:
|
||||||
|
if n < 2:
|
||||||
|
return False
|
||||||
|
for d in range(2, n // 2 + 1):
|
||||||
|
if n % d == 0:
|
||||||
|
return False
|
||||||
|
return True
|
||||||
|
|
||||||
|
|
||||||
|
def primes() -> Iterator[int]:
|
||||||
|
num = 2
|
||||||
|
while True:
|
||||||
|
if is_prime(num):
|
||||||
|
yield num
|
||||||
|
num += 1
|
||||||
|
|
||||||
|
|
||||||
|
def prime_factorize(n: int) -> Iterator[int]:
|
||||||
|
it = primes()
|
||||||
|
num = n
|
||||||
|
while num > 1:
|
||||||
|
if num % (prime := next(it)) != 0:
|
||||||
|
continue
|
||||||
|
num //= prime
|
||||||
|
it = primes()
|
||||||
|
yield prime
|
||||||
@@ -0,0 +1,51 @@
|
|||||||
|
from primes import is_prime, prime_factorize, primes
|
||||||
|
from typing import Iterable
|
||||||
|
|
||||||
|
|
||||||
|
PRIMES = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29,
|
||||||
|
31, 37, 41, 43, 47, 53, 59, 61, 67, 71,
|
||||||
|
73, 79, 83, 89, 97, 101, 103, 107, 109, 113,
|
||||||
|
127, 131, 137, 139, 149, 151, 157, 163, 167, 173,
|
||||||
|
179, 181, 191, 193, 197, 199, 211, 223, 227, 229,
|
||||||
|
233, 239, 241, 251, 257, 263, 269, 271, 277, 281,
|
||||||
|
283, 293, 307, 311, 313, 317, 331, 337, 347, 349,
|
||||||
|
353, 359, 367, 373, 379, 383, 389, 397, 401, 409,
|
||||||
|
419, 421, 431, 433, 439, 443, 449, 457, 461, 463,
|
||||||
|
467, 479, 487, 491, 499, 503, 509, 521, 523, 541,
|
||||||
|
547, 557, 563, 569, 571, 577, 587, 593, 599, 601,
|
||||||
|
607, 613, 617, 619, 631, 641, 643, 647, 653, 659,
|
||||||
|
661, 673, 677, 683, 691, 701, 709, 719, 727, 733,
|
||||||
|
739, 743, 751, 757, 761, 769, 773, 787, 797, 809,
|
||||||
|
811, 821, 823, 827, 829, 839, 853, 857, 859, 863,
|
||||||
|
877, 881, 883, 887, 907, 911, 919, 929, 937, 941,
|
||||||
|
947, 953, 967, 971, 977, 983, 991, 997]
|
||||||
|
PRIME_FACTORS = {2: [2], 3: [3], 4: [2, 2], 5: [5], 6: [2, 3], 7: [7], 8: [2, 2, 2], 9: [3, 3], 10: [2, 5], 11: [11], 12: [2, 2, 3], 13: [13], 14: [2, 7], 15: [3, 5], 16: [2, 2, 2, 2], 17: [17], 18: [2, 3, 3], 19: [19], 20: [2, 2, 5], 21: [3, 7], 22: [2, 11], 23: [23], 24: [2, 2, 2, 3], 25: [5, 5], 26: [2, 13], 27: [3, 3, 3], 28: [2, 2, 7], 29: [29], 30: [2, 3, 5], 31: [31], 32: [2, 2, 2, 2, 2], 33: [3, 11], 34: [2, 17], 35: [5, 7], 36: [2, 2, 3, 3], 37: [37], 38: [2, 19], 39: [3, 13], 40: [2, 2, 2, 5], 41: [41], 42: [2, 3, 7], 43: [43], 44: [2, 2, 11], 45: [3, 3, 5], 46: [2, 23], 47: [47], 48: [2, 2, 2, 2, 3], 49: [7, 7], 50: [2, 5, 5], 51: [3, 17], 52: [2, 2, 13], 53: [53], 54: [2, 3, 3, 3], 55: [5, 11], 56: [2, 2, 2, 7], 57: [3, 19], 58: [2, 29], 59: [59], 60: [2, 2, 3, 5], 61: [61], 62: [2, 31], 63: [3, 3, 7], 64: [2, 2, 2, 2, 2, 2], 65: [5, 13], 66: [2, 3, 11], 67: [67], 68: [2, 2, 17], 69: [3, 23], 70: [2, 5, 7], 71: [71], 72: [2, 2, 2, 3, 3], 73: [73], 74: [2, 37], 75: [3, 5, 5], 76: [2, 2, 19], 77: [7, 11], 78: [2, 3, 13], 79: [79], 80: [2, 2, 2, 2, 5], 81: [3, 3, 3, 3], 82: [2, 41], 83: [83], 84: [2, 2, 3, 7], 85: [5, 17], 86: [2, 43], 87: [3, 29], 88: [2, 2, 2, 11], 89: [89], 90: [2, 3, 3, 5], 91: [7, 13], 92: [2, 2, 23], 93: [3, 31], 94: [2, 47], 95: [5, 19], 96: [2, 2, 2, 2, 2, 3], 97: [97], 98: [2, 7, 7], 99: [3, 3, 11], 100: [2, 2, 5, 5], 101: [101], 102: [2, 3, 17], 103: [103], 104: [2, 2, 2, 13], 105: [3, 5, 7], 106: [2, 53], 107: [107], 108: [2, 2, 3, 3, 3], 109: [109], 110: [2, 5, 11], 111: [3, 37], 112: [2, 2, 2, 2, 7], 113: [113], 114: [2, 3, 19], 115: [5, 23], 116: [2, 2, 29], 117: [3, 3, 13], 118: [2, 59], 119: [7, 17], 120: [2, 2, 2, 3, 5], 121: [11, 11], 122: [2, 61], 123: [3, 41], 124: [2, 2, 31], 125: [5, 5, 5], 126: [2, 3, 3, 7], 127: [127], 128: [2, 2, 2, 2, 2, 2, 2], 129: [3, 43], 130: [2, 5, 13], 131: [131], 132: [2, 2, 3, 11], 133: [7, 19], 134: [2, 67], 135: [3, 3, 3, 5], 136: [2, 2, 2, 17], 137: [137], 138: [2, 3, 23], 139: [139], 140: [2, 2, 5, 7], 141: [3, 47], 142: [2, 71], 143: [11, 13], 144: [2, 2, 2, 2, 3, 3], 145: [5, 29], 146: [2, 73], 147: [3, 7, 7], 148: [2, 2, 37], 149: [149], 150: [2, 3, 5, 5], 151: [151], 152: [2, 2, 2, 19], 153: [3, 3, 17], 154: [2, 7, 11], 155: [5, 31], 156: [2, 2, 3, 13], 157: [157], 158: [2, 79], 159: [3, 53], 160: [2, 2, 2, 2, 2, 5], 161: [7, 23], 162: [2, 3, 3, 3, 3], 163: [163], 164: [2, 2, 41], 165: [3, 5, 11], 166: [2, 83], 167: [167], 168: [2, 2, 2, 3, 7], 169: [13, 13], 170: [2, 5, 17], 171: [3, 3, 19], 172: [2, 2, 43], 173: [173], 174: [2, 3, 29], 175: [5, 5, 7], 176: [2, 2, 2, 2, 11], 177: [3, 59], 178: [2, 89], 179: [179], 180: [2, 2, 3, 3, 5], 181: [181], 182: [2, 7, 13], 183: [3, 61], 184: [2, 2, 2, 23], 185: [5, 37], 186: [2, 3, 31], 187: [11, 17], 188: [2, 2, 47], 189: [3, 3, 3, 7], 190: [2, 5, 19], 191: [191], 192: [2, 2, 2, 2, 2, 2, 3], 193: [193], 194: [2, 97], 195: [3, 5, 13], 196: [2, 2, 7, 7], 197: [197], 198: [2, 3, 3, 11], 199: [199], 200: [2, 2, 2, 5, 5], 201: [3, 67], 202: [2, 101], 203: [7, 29], 204: [2, 2, 3, 17], 205: [5, 41], 206: [2, 103], 207: [3, 3, 23], 208: [2, 2, 2, 2, 13], 209: [11, 19], 210: [2, 3, 5, 7], 211: [211], 212: [2, 2, 53], 213: [3, 71], 214: [2, 107], 215: [5, 43], 216: [2, 2, 2, 3, 3, 3], 217: [7, 31], 218: [2, 109], 219: [3, 73], 220: [2, 2, 5, 11], 221: [13, 17], 222: [2, 3, 37], 223: [223], 224: [2, 2, 2, 2, 2, 7], 225: [3, 3, 5, 5], 226: [2, 113], 227: [227], 228: [2, 2, 3, 19], 229: [229], 230: [2, 5, 23], 231: [3, 7, 11], 232: [2, 2, 2, 29], 233: [233], 234: [2, 3, 3, 13], 235: [5, 47], 236: [2, 2, 59], 237: [3, 79], 238: [2, 7, 17], 239: [239], 240: [2, 2, 2, 2, 3, 5], 241: [241], 242: [2, 11, 11], 243: [3, 3, 3, 3, 3], 244: [2, 2, 61], 245: [5, 7, 7], 246: [2, 3, 41], 247: [13, 19], 248: [2, 2, 2, 31], 249: [3, 83], 250: [2, 5, 5, 5], 251: [251], 252: [2, 2, 3, 3, 7], 253: [11, 23], 254: [2, 127], 255: [3, 5, 17], 256: [2, 2, 2, 2, 2, 2, 2, 2], 257: [257], 258: [2, 3, 43], 259: [7, 37], 260: [2, 2, 5, 13], 261: [3, 3, 29], 262: [2, 131], 263: [263], 264: [2, 2, 2, 3, 11], 265: [5, 53], 266: [2, 7, 19], 267: [3, 89], 268: [2, 2, 67], 269: [269], 270: [2, 3, 3, 3, 5], 271: [271], 272: [2, 2, 2, 2, 17], 273: [3, 7, 13], 274: [2, 137], 275: [5, 5, 11], 276: [2, 2, 3, 23], 277: [277], 278: [2, 139], 279: [3, 3, 31], 280: [2, 2, 2, 5, 7], 281: [281], 282: [2, 3, 47], 283: [283], 284: [2, 2, 71], 285: [3, 5, 19], 286: [2, 11, 13], 287: [7, 41], 288: [2, 2, 2, 2, 2, 3, 3], 289: [17, 17], 290: [2, 5, 29], 291: [3, 97], 292: [2, 2, 73], 293: [293], 294: [2, 3, 7, 7], 295: [5, 59], 296: [2, 2, 2, 37], 297: [3, 3, 3, 11], 298: [2, 149], 299: [13, 23], 300: [2, 2, 3, 5, 5], 301: [7, 43], 302: [2, 151], 303: [3, 101], 304: [2, 2, 2, 2, 19], 305: [5, 61], 306: [2, 3, 3, 17], 307: [307], 308: [2, 2, 7, 11], 309: [3, 103], 310: [2, 5, 31], 311: [311], 312: [2, 2, 2, 3, 13], 313: [313], 314: [2, 157], 315: [3, 3, 5, 7], 316: [2, 2, 79], 317: [317], 318: [2, 3, 53], 319: [11, 29], 320: [2, 2, 2, 2, 2, 2,Line truncated
|
||||||
|
2, 2, 2, 5, 13], 521: [521], 522: [2, 3, 3, 29], 523: [523], 524: [2, 2, 131], 525: [3, 5, 5, 7], 526: [2, 263], 527: [17, 31], 528: [2, 2, 2, 2, 3, 11], 529: [23, 23], 530: [2, 5, 53], 531: [3, 3, 59], 532: [2, 2, 7, 19], 533: [13, 41], 534: [2, 3, 89], 535: [5, 107], 536: [2, 2, 2, 67], 537: [3, 179], 538: [2, 269], 539: [7, 7, 11], 540: [2, 2, 3, 3, 3, 5], 541: [541], 542: [2, 271], 543: [3, 181], 544: [2, 2, 2, 2, 2, 17], 545: [5, 109], 546: [2, 3, 7, 13], 547: [547], 548: [2, 2, 137], 549: [3, 3, 61], 550: [2, 5, 5, 11], 551: [19, 29], 552: [2, 2, 2, 3, 23], 553: [7, 79], 554: [2, 277], 555: [3, 5, 37], 556: [2, 2, 139], 557: [557], 558: [2, 3, 3, 31], 559: [13, 43], 560: [2, 2, 2, 2, 5, 7], 561: [3, 11, 17], 562: [2, 281], 563: [563], 564: [2, 2, 3, 47], 565: [5, 113], 566: [2, 283], 567: [3, 3, 3, 3, 7], 568: [2, 2, 2, 71], 569: [569], 570: [2, 3, 5, 19], 571: [571], 572: [2, 2, 11, 13], 573: [3, 191], 574: [2, 7, 41], 575: [5, 5, 23], 576: [2, 2, 2, 2, 2, 2, 3, 3], 577: [577], 578: [2, 17, 17], 579: [3, 193], 580: [2, 2, 5, 29], 581: [7, 83], 582: [2, 3, 97], 583: [11, 53], 584: [2, 2, 2, 73], 585: [3, 3, 5, 13], 586: [2, 293], 587: [587], 588: [2, 2, 3, 7, 7], 589: [19, 31], 590: [2, 5, 59], 591: [3, 197], 592: [2, 2, 2, 2, 37], 593: [593], 594: [2, 3, 3, 3, 11], 595: [5, 7, 17], 596: [2, 2, 149], 597: [3, 199], 598: [2, 13, 23], 599: [599], 600: [2, 2, 2, 3, 5, 5], 601: [601], 602: [2, 7, 43], 603: [3, 3, 67], 604: [2, 2, 151], 605: [5, 11, 11], 606: [2, 3, 101], 607: [607], 608: [2, 2, 2, 2, 2, 19], 609: [3, 7, 29], 610: [2, 5, 61], 611: [13, 47], 612: [2, 2, 3, 3, 17], 613: [613], 614: [2, 307], 615: [3, 5, 41], 616: [2, 2, 2, 7, 11], 617: [617], 618: [2, 3, 103], 619: [619], 620: [2, 2, 5, 31], 621: [3, 3, 3, 23], 622: [2, 311], 623: [7, 89], 624: [2, 2, 2, 2, 3, 13], 625: [5, 5, 5, 5], 626: [2, 313], 627: [3, 11, 19], 628: [2, 2, 157], 629: [17, 37], 630: [2, 3, 3, 5, 7], 631: [631], 632: [2, 2, 2, 79], 633: [3, 211], 634: [2, 317], 635: [5, 127], 636: [2, 2, 3, 53], 637: [7, 7, 13], 638: [2, 11, 29], 639: [3, 3, 71], 640: [2, 2, 2, 2, 2, 2, 2, 5], 641: [641], 642: [2, 3, 107], 643: [643], 644: [2, 2, 7, 23], 645: [3, 5, 43], 646: [2, 17, 19], 647: [647], 648: [2, 2, 2, 3, 3, 3, 3], 649: [11, 59], 650: [2, 5, 5, 13], 651: [3, 7, 31], 652: [2, 2, 163], 653: [653], 654: [2, 3, 109], 655: [5, 131], 656: [2, 2, 2, 2, 41], 657: [3, 3, 73], 658: [2, 7, 47], 659: [659], 660: [2, 2, 3, 5, 11], 661: [661], 662: [2, 331], 663: [3, 13, 17], 664: [2, 2, 2, 83], 665: [5, 7, 19], 666: [2, 3, 3, 37], 667: [23, 29], 668: [2, 2, 167], 669: [3, 223], 670: [2, 5, 67], 671: [11, 61], 672: [2, 2, 2, 2, 2, 3, 7], 673: [673], 674: [2, 337], 675: [3, 3, 3, 5, 5], 676: [2, 2, 13, 13], 677: [677], 678: [2, 3, 113], 679: [7, 97], 680: [2, 2, 2, 5, 17], 681: [3, 227], 682: [2, 11, 31], 683: [683], 684: [2, 2, 3, 3, 19], 685: [5, 137], 686: [2, 7, 7, 7], 687: [3, 229], 688: [2, 2, 2, 2, 43], 689: [13, 53], 690: [2, 3, 5, 23], 691: [691], 692: [2, 2, 173], 693: [3, 3, 7, 11], 694: [2, 347], 695: [5, 139], 696: [2, 2, 2, 3, 29], 697: [17, 41], 698: [2, 349], 699: [3, 233], 700: [2, 2, 5, 5, 7], 701: [701], 702: [2, 3, 3, 3, 13], 703: [19, 37], 704: [2, 2, 2, 2, 2, 2, 11], 705: [3, 5, 47], 706: [2, 353], 707: [7, 101], 708: [2, 2, 3, 59], 709: [709], 710: [2, 5, 71], 711: [3, 3, 79], 712: [2, 2, 2, 89], 713: [23, 31], 714: [2, 3, 7, 17], 715: [5, 11, 13], 716: [2, 2, 179], 717: [3, 239], 718: [2, 359], 719: [719], 720: [2, 2, 2, 2, 3, 3, 5], 721: [7, 103], 722: [2, 19, 19], 723: [3, 241], 724: [2, 2, 181], 725: [5, 5, 29], 726: [2, 3, 11, 11], 727: [727], 728: [2, 2, 2, 7, 13], 729: [3, 3, 3, 3, 3, 3], 730: [2, 5, 73], 731: [17, 43], 732: [2, 2, 3, 61], 733: [733], 734: [2, 367], 735: [3, 5, 7, 7], 736: [2, 2, 2, 2, 2, 23], 737: [11, 67], 738: [2, 3, 3, 41], 739: [739], 740: [2, 2, 5, 37], 741: [3, 13, 19], 742: [2, 7, 53], 743: [743], 744: [2, 2, 2, 3, 31], 745: [5, 149], 746: [2, 373], 747: [3, 3, 83], 748: [2, 2, 11, 17], 749: [7, 107], 750: [2, 3, 5, 5, 5], 751: [751], 752: [2, 2, 2, 2, 47], 753: [3, 251], 754: [2, 13, 29], 755: [5, 151], 756: [2, 2, 3, 3, 3, 7], 757: [757], 758: [2, 379], 759: [3, 11, 23], 760: [2, 2, 2, 5, 19], 761: [761], 762: [2, 3, 127], 763: [7, 109], 764: [2, 2, 191], 765: [3, 3, 5, 17], 766: [2, 383], 767: [13, 59], 768: [2, 2, 2, 2, 2, 2, 2, 2, 3], 769: [769], 770: [2, 5, 7, 11], 771: [3, 257], 772: [2, 2, 193], 773: [773], 774: [2, 3, 3, 43], 775: [5, 5, 31], 776: [2, 2, 2, 97], 777: [3, 7, 37], 778: [2, 389], 779: [19, 41], 780: [2, 2, 3, 5, 13], 781: [11, 71], 782: [2, 17, 23], 783: [3, 3, 3, 29], 784: [2, 2, 2, 2, 7, 7], 785: [5, 157], 786: [2, 3, 131], 787: [787], 788: [2, 2, 197], 789: [3, 263], 790: [2, 5, 79], 791: [7, 113], 792: [2, 2, 2, 3, 3, 11], 793: [13, 61], 794: [2, 397], 795: [3, 5, 53], 796: [2, 2, 199], 797: [797], 798: [2, 3, 7, 19], 799: [17, 47], 800: [2, 2, 2, 2, 2, 5, 5], 801: [3, 3, 89], 802: [2, 401], 803: [11, 73], 804: [2, 2, 3, 67], 805: [5, 7, 23], 806: [2, 13,Line truncated
|
||||||
|
|
||||||
|
|
||||||
|
def test_is_prime():
|
||||||
|
for prime in PRIMES:
|
||||||
|
assert is_prime(prime)
|
||||||
|
for not_prime in [n for n in range(4, 1000) if n not in PRIMES]:
|
||||||
|
assert not is_prime(not_prime)
|
||||||
|
|
||||||
|
|
||||||
|
def test_primes():
|
||||||
|
it = primes()
|
||||||
|
for prime in PRIMES:
|
||||||
|
assert prime == next(it)
|
||||||
|
|
||||||
|
|
||||||
|
def test_prime_factorize():
|
||||||
|
for prime in PRIMES:
|
||||||
|
assert list(prime_factorize(prime)) == [prime]
|
||||||
|
prime_factors: Iterable[tuple[int, Iterable[int]]] = [
|
||||||
|
(n, list(prime_factorize(n))) for n in range(2, 1001)]
|
||||||
|
for n, factors in prime_factors:
|
||||||
|
for factor in factors:
|
||||||
|
assert factor in PRIMES
|
||||||
|
assert PRIME_FACTORS[n] == factors
|
||||||
|
|
||||||
|
assert list(prime_factorize(0)) == []
|
||||||
|
assert list(prime_factorize(1)) == []
|
||||||
|
assert list(prime_factorize(-2)) == []
|
||||||
@@ -0,0 +1 @@
|
|||||||
|
# List Comprehensions
|
||||||
@@ -0,0 +1,36 @@
|
|||||||
|
def divisible_by_7(n: int) -> list[int]:
|
||||||
|
"""
|
||||||
|
Returns a list of all numbers till 'n' that are divisible by '7'
|
||||||
|
"""
|
||||||
|
|
||||||
|
|
||||||
|
def contains_3(n: int) -> list[int]:
|
||||||
|
"""
|
||||||
|
Returns a list of all numbers that contain the digit '3' in them
|
||||||
|
"""
|
||||||
|
|
||||||
|
|
||||||
|
def count_spaces(string: str) -> int:
|
||||||
|
"""
|
||||||
|
Count the spaces in a string
|
||||||
|
"""
|
||||||
|
|
||||||
|
|
||||||
|
def remove_vowels(string: str) -> str:
|
||||||
|
"""
|
||||||
|
Remove all vowels from the string
|
||||||
|
"""
|
||||||
|
|
||||||
|
|
||||||
|
def word_lengths(string: str) -> dict[str, int]:
|
||||||
|
"""
|
||||||
|
Create a dictionary of all words with their lengths
|
||||||
|
"""
|
||||||
|
|
||||||
|
|
||||||
|
def prime_numbers(n: int) -> list[int]:
|
||||||
|
"""
|
||||||
|
Returns a list of all prime numbers till 'n' (HARD)
|
||||||
|
"""
|
||||||
|
|
||||||
|
|
||||||
Whitespace-only changes.
@@ -0,0 +1,41 @@
|
|||||||
|
def divisible_by_7(n: int) -> list[int]:
|
||||||
|
"""
|
||||||
|
Returns a list of all numbers till 'n' that are divisible by '7'
|
||||||
|
"""
|
||||||
|
return [x for x in range(1, n) if x % 7 == 0]
|
||||||
|
|
||||||
|
|
||||||
|
def contains_3(n: int) -> list[int]:
|
||||||
|
"""
|
||||||
|
Returns a list of all numbers that contain the digit '3' in them
|
||||||
|
"""
|
||||||
|
return [x for x in range(1, n) if '3' in str(x)]
|
||||||
|
|
||||||
|
|
||||||
|
def count_spaces(string: str) -> int:
|
||||||
|
"""
|
||||||
|
Count the spaces in a string
|
||||||
|
"""
|
||||||
|
return len([ch for ch in string if ' ' == ch])
|
||||||
|
|
||||||
|
|
||||||
|
def remove_vowels(string: str) -> str:
|
||||||
|
"""
|
||||||
|
Remove all vowels from the string
|
||||||
|
"""
|
||||||
|
return ''.join([ch for ch in string if ch.lower() not in 'aeiou'])
|
||||||
|
|
||||||
|
|
||||||
|
def word_lengths(string: str) -> dict[str, int]:
|
||||||
|
"""
|
||||||
|
Create a dictionary of all words with their lengths
|
||||||
|
"""
|
||||||
|
return {word: len(word) for word in string.split(' ') if len(word) > 0}
|
||||||
|
|
||||||
|
|
||||||
|
def prime_numbers(n: int) -> list[int]:
|
||||||
|
"""
|
||||||
|
Returns a list of all prime numbers till 'n' (HARD)
|
||||||
|
"""
|
||||||
|
return [x for x in range(2, n) if all(x % y != 0 for y in range(2, x))]
|
||||||
|
|
||||||
@@ -0,0 +1,77 @@
|
|||||||
|
import pytest
|
||||||
|
|
||||||
|
# ========================| divisible_by_7 |===========================
|
||||||
|
def test_divisible_by_7():
|
||||||
|
from comprehensions import divisible_by_7
|
||||||
|
assert divisible_by_7(-1) == []
|
||||||
|
assert divisible_by_7(0) == []
|
||||||
|
assert divisible_by_7(43) == [7, 14, 21, 28, 35, 42]
|
||||||
|
assert divisible_by_7(325) == [7, 14, 21, 28, 35, 42, \
|
||||||
|
49, 56, 63, 70, 77, 84, 91, 98, 105, 112, 119, \
|
||||||
|
126, 133, 140, 147, 154, 161, 168, 175, 182, \
|
||||||
|
189, 196, 203, 210, 217, 224, 231, 238, 245, \
|
||||||
|
252, 259, 266, 273, 280, 287, 294, 301, 308, 315, 322]
|
||||||
|
|
||||||
|
|
||||||
|
# ========================| contains_3 |===========================
|
||||||
|
def test_contains_3():
|
||||||
|
from comprehensions import contains_3
|
||||||
|
assert contains_3(-1) == []
|
||||||
|
assert contains_3(0) == []
|
||||||
|
assert contains_3(5) == [3]
|
||||||
|
assert contains_3(24) == [3, 13, 23]
|
||||||
|
assert contains_3(4238) == [3, 13, 23, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 43, 53, 63, 73, 83, 93, 103, 113, 123, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 143, 153, 163, 173, 183, 193, 203, 213, 223, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 243, 253, 263, 273, 283, 293, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 403, 413, 423, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 443, 453, 463, 473, 483, 493, 503, 513, 523, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 543, 553, 563, 573, 583, 593, 603, 613, 623, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 643, 653, 663, 673, 683, 693, 703, 713, 723, 730, 731, 732, 733, 734, 735, 736, 737, 738, 739, 743, 753, 763, 773, 783, 793, 803, 813, 823, 830, 831, 832, 833, 834, 835, 836, 837, 838, 839, 843, 853, 863, 873, 883, 893, 903, 913, 923, 930, 931, 932, 933, 934, 935, 936, 937, 938, 939, 943, 953, 963, 973, 983, 993, 1003, 1013, 1023, 1030, 1031, 1032, 1033, 1034, 1035, 1036, 1037, 1038, 1039, 1043, 1053, 1063, 1073, 1083, 1093, 1103, 1113, 1123, 1130, 1131, 1132, 1133, 1134, 1135, 1136, 1137, 1138, 1139, 1143, 1153, 1163, 1173, 1183, 1193, 1203, 1213, 1223, 1230, 1231, 1232, 1233, 1234, 1235, 1236, 1237, 1238, 1239, 1243, 1253, 1263, 1273, 1283, 1293, 1300, 1301, 1302, 1303, 1304, 1305, 1306, 1307, 1308, 1309, 1310, 1311, 1312, 1313, 1314, 1315, 1316, 1317, 1318, 1319, 1320, 1321, 1322, 1323, 1324, 1325, 1326, 1327, 1328, 1329, 1330, 1331, 1332, 1333, 1334, 1335, 1336, 1337, 1338, 1339, 1340, 1341, 1342, 1343, 1344, 1345, 1346, 1347, 1348, 1349, 1350, 1351, 1352, 1353, 1354, 1355, 1356, 1357, 1358, 1359, 1360, 1361, 1362, 1363, 1364, 1365, 1366, 1367, 1368, 1369, 1370, 1371, 1372, 1373, 1374, 1375, 1376, 1377, 1378, 1379, 1380, 1381, 1382, 1383, 1384, 1385, 1386, 1387, 1388, 1389, 1390, 1391, 1392, 1393, 1394, 1395, 1396, 1397, 1398, 1399, 1403, 1413, 1423, 1430, 1431, 1432, 1433, 1434, 1435, 1436, 1437, 1438, 1439, 1443, 1453, 1463, 1473, 1483, 1493, 1503, 1513, 1523, 1530, 1531, 1532, 1533, 1534, 1535, 1536, 1537, 1538, 1539, 1543, 1553, 1563, 1573, 1583, 1593, 1603, 1613, 1623, 1630, 1631, 1632, 1633, 1634, 1635, 1636, 1637, 1638, 1639, 1643, 1653, 1663, 1673, 1683, 1693, 1703, 1713, 1723, 1730, 1731, 1732, 1733, 1734, 1735, 1736, 1737, 1738, 1739, 1743, 1753, 1763, 1773, 1783, 1793, 1803, 1813, 1823, 1830, 1831, 1832, 1833, 1834, 1835, 1836, 1837, 1838, 1839, 1843, 1853, 1863, 1873, 1883, 1893, 1903, 1913, 1923, 1930, 1931, 1932, 1933, 1934, 1935, 1936, 1937, 1938, 1939, 1943, 1953, 1963, 1973, 1983, 1993, 2003, 2013, 2023, 2030, 2031, 2032, 2033, 2034, 2035, 2036, 2037, 2038, 2039, 2043, 2053, 2063, 2073, 2083, 2093, 2103, 2113, 2123, 2130, 2131, 2132, 2133, 2134, 2135, 2136, 2137, 2138, 2139, 2143, 2153, 2163, 2173, 2183, 2193, 2203, 2213, 2223, 2230, 2231, 2232, 2233, 2234, 2235, 2236, 2237, 2238, 2239, 2243, 2253, 2263, 2273, 2283, 2293, 2300, 2301, 2302, 2303, 2304, 2305, 2306, 2307, 2308, 2309, 2310, 2311, 2312, 2313, 2314, 2315, 2316, 2317, 2318, 2319, 2320, 2321, 2322, 2323, 2324, 2325, 2326, 2327, 2328, 2329, 2330, 2331, 2332, 2333, 2334, 2335, 2336, 2337, 2338, 2339, 2340, 2341, 2342, 2343, 2344, 2345, 2346, 2347, 2348, 2349, 2350, 2351, 2352, 2353, 2354, 2355, 2356, 2357, 2358, 2359, 2360, 2361, 2362, 2363, 2364, 2365, 2366, 2367, 2368, 2369, 2370, 2371, 2372, 2373, 2374, 2375, 2376, 2377, 2378, 2379, 2380, 2381, 2382, 2383, 2384, 2385, 2386, 2387, 2388, 2389, 2390, 2391, 2392, 2393, 2394, 2395, 2396, 2397, 2398, 2399, 2403, 2413, 2423, 2430, 2431, 2432, 2433, 2434, 2435, 2436, 2437, 2438, 2439, 2443, 2453, 2463, 2473, 2483, 2493, 2503, 2513, 2523, 2530, 2531, 2532, 2533, 2534, 2535, 2536, 2537, 2538, 2539, 2543, 2553, 2563, 2573, 2583, 2593, 2603, 2613, 2623, 2630, 2631, 2632, 2633, 2634, 2635, 2636, 2637, 2638, 2639, 2643, 2653, 2663, 2673, 2683, 2693, 2703, 2713, 2723, 2730, 2731, 2732, 2733, 2734, 2735, 2736, 2737, 2738, 2739, 2743, 2753, 2763, 2773, 2783, 2793, 2803, 2813, 2823, 2830, 2831, 2832, 2833, 2834, 2835, 2836, 2837, 2838, 2839, 2843, 2853, 2863, 2873, 2883, 2893, 2903, 2913, 2923, 2930, 2931, 2932, 2933, 2934, 2935, 2936, 2937, 2938, 2939, 2943, 2953, 2963, 2973, 2983, 2993, 3000, 3001, 3002, 3003, 3004, 3005, 3006, 3007, 3008, 3009, 3010, 3011, 3012, 3013, 3014, 3015, 3016, 3017, 3018, 3019, 3020, 3021, 3022, 3023, 3024, 3025, 3026, 3027, 3028, 3029, 3030, 3031, 3032, 3033, 3034, 3035, 3036, 3037, 3038, 3039, 3040, 3041, 3042, 3043, 3044, 3045, 3046, 3047, 3048, 3049, 3050, 3051, 3052, 3053, 3054, 3055, 3056, 3057, 3058, 3059, 3060, 3061, 3062, 30Line truncated
|
||||||
|
|
||||||
|
|
||||||
|
# ========================| count_spaces |===========================
|
||||||
|
def test_count_spaces():
|
||||||
|
from comprehensions import count_spaces
|
||||||
|
assert count_spaces('') == 0
|
||||||
|
assert count_spaces(' ') == 1
|
||||||
|
assert count_spaces(' ') == 5
|
||||||
|
assert count_spaces('this is a test string') == 4
|
||||||
|
|
||||||
|
# ========================| remove_vowels |===========================
|
||||||
|
def test_remove_vowels():
|
||||||
|
from comprehensions import remove_vowels
|
||||||
|
assert remove_vowels('') == ''
|
||||||
|
assert remove_vowels(' ') == ' '
|
||||||
|
|
||||||
|
string = 'this is a test string'
|
||||||
|
assert remove_vowels(string) == ''.join(filter(lambda ch: ch.lower() not in 'aeiou', string))
|
||||||
|
|
||||||
|
string = 'this is a test string'.upper()
|
||||||
|
assert remove_vowels(string) == ''.join(filter(lambda ch: ch.lower() not in 'aeiou', string))
|
||||||
|
|
||||||
|
# ========================| word_lengths |===========================
|
||||||
|
def test_word_lengths():
|
||||||
|
from comprehensions import word_lengths
|
||||||
|
sol = lambda xs: {word: len(word) for word in xs.split(' ') if len(word) > 0}
|
||||||
|
|
||||||
|
# No words
|
||||||
|
assert word_lengths('') == dict()
|
||||||
|
assert word_lengths(' ') == dict()
|
||||||
|
assert word_lengths(' ') == dict()
|
||||||
|
|
||||||
|
|
||||||
|
string = 'this is a test sentence'
|
||||||
|
assert word_lengths('this is a test sentence') == sol(string)
|
||||||
|
|
||||||
|
string = 'helloworld'
|
||||||
|
assert word_lengths(string) == sol(string)
|
||||||
|
|
||||||
|
|
||||||
|
# ========================| prime_numbers |===========================
|
||||||
|
def test_prime_numbers():
|
||||||
|
from comprehensions import prime_numbers
|
||||||
|
|
||||||
|
assert prime_numbers(-1) == []
|
||||||
|
assert prime_numbers(-918273987) == []
|
||||||
|
assert prime_numbers(0) == []
|
||||||
|
assert prime_numbers(1) == []
|
||||||
|
assert prime_numbers(3) == [2]
|
||||||
|
assert prime_numbers(10) == [2, 3, 5, 7]
|
||||||
|
assert prime_numbers(100) == [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]
|
||||||
|
assert prime_numbers(2384) == [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997, 1009, 1013, 1019, 1021, 1031, 1033, 1039, 1049, 1051, 1061, 1063, 1069, 1087, 1091, 1093, 1097, 1103, 1109, 1117, 1123, 1129, 1151, 1153, 1163, 1171, 1181, 1187, 1193, 1201, 1213, 1217, 1223, 1229, 1231, 1237, 1249, 1259, 1277, 1279, 1283, 1289, 1291, 1297, 1301, 1303, 1307, 1319, 1321, 1327, 1361, 1367, 1373, 1381, 1399, 1409, 1423, 1427, 1429, 1433, 1439, 1447, 1451, 1453, 1459, 1471, 1481, 1483, 1487, 1489, 1493, 1499, 1511, 1523, 1531, 1543, 1549, 1553, 1559, 1567, 1571, 1579, 1583, 1597, 1601, 1607, 1609, 1613, 1619, 1621, 1627, 1637, 1657, 1663, 1667, 1669, 1693, 1697, 1699, 1709, 1721, 1723, 1733, 1741, 1747, 1753, 1759, 1777, 1783, 1787, 1789, 1801, 1811, 1823, 1831, 1847, 1861, 1867, 1871, 1873, 1877, 1879, 1889, 1901, 1907, 1913, 1931, 1933, 1949, 1951, 1973, 1979, 1987, 1993, 1997, 1999, 2003, 2011, 2017, 2027, 2029, 2039, 2053, 2063, 2069, 2081, 2083, 2087, 2089, 2099, 2111, 2113, 2129, 2131, 2137, 2141, 2143, 2153, 2161, 2179, 2203, 2207, 2213, 2221, 2237, 2239, 2243, 2251, 2267, 2269, 2273, 2281, 2287, 2293, 2297, 2309, 2311, 2333, 2339, 2341, 2347, 2351, 2357, 2371, 2377, 2381, 2383]
|
||||||
|
|
||||||
|
|
||||||
@@ -1,4 +1,4 @@
|
|||||||
# [Primzahlen](./primes.py)
|
# [Primzahlen](src/branch/main/loops/primes/primes.py)
|
||||||
|
|
||||||
## `is_prime`
|
## `is_prime`
|
||||||
|
|
||||||
@@ -28,4 +28,4 @@ Schreiben Sie nun folgende Funktion `prime_factorize(n: int) -> list[int]` welch
|
|||||||
|
|
||||||
Tipp: Sie können hierfür die Funktionen `is_prime` und `next_prime` verwenden
|
Tipp: Sie können hierfür die Funktionen `is_prime` und `next_prime` verwenden
|
||||||
|
|
||||||
## [Hier gehts zu den Lösungen](./solution/primes.py)
|
## [Hier gehts zu den Lösungen](src/branch/main/loops/primes/solution)
|
||||||
@@ -0,0 +1,84 @@
|
|||||||
|
# [Sortierte Datenstrukturen](src/branch/main/loops/sort/sort.py)
|
||||||
|
|
||||||
|
## `selection_sort`
|
||||||
|
|
||||||
|
**Selection Sort** basiert auf dem Konzept durch jedes Element in einer Liste zu gehen um dann das kleineste Element in den übrigen zu suchen und mit dem aktuellen Element zu tauschen.
|
||||||
|
|
||||||
|
- Wichtig ist dass dabei die übergebene Liste nicht verändert wird und eine neue sortierte erstellt wird
|
||||||
|
- Manuell erstellen mit loop oder `deepcopy`
|
||||||
|
|
||||||
|
Beispiel:
|
||||||
|
```
|
||||||
|
arr[] = 64 25 12 22 11
|
||||||
|
|
||||||
|
// Find the minimum element in arr[0...4]
|
||||||
|
// and place it at beginning
|
||||||
|
11 25 12 22 64
|
||||||
|
|
||||||
|
// Find the minimum element in arr[1...4]
|
||||||
|
// and place it at beginning of arr[1...4]
|
||||||
|
11 12 25 22 64
|
||||||
|
|
||||||
|
// Find the minimum element in arr[2...4]
|
||||||
|
// and place it at beginning of arr[2...4]
|
||||||
|
11 12 22 25 64
|
||||||
|
|
||||||
|
// Find the minimum element in arr[3...4]
|
||||||
|
// and place it at beginning of arr[3...4]
|
||||||
|
11 12 22 25 64
|
||||||
|
```
|
||||||
|
|
||||||
|
<details>
|
||||||
|
<summary>Hilfe 1: Pseudocode</summary>
|
||||||
|
|
||||||
|
```
|
||||||
|
for e_i in xs
|
||||||
|
kleinstes_e = e_i
|
||||||
|
for e_j in xs mit: j = i + 1
|
||||||
|
if kleinstes_e > e_j
|
||||||
|
kleinstes_e = e_j
|
||||||
|
vertausche e_i und kleinstes_e
|
||||||
|
```
|
||||||
|
|
||||||
|
</details>
|
||||||
|
|
||||||
|
## `binary_search`
|
||||||
|
|
||||||
|
Hierbei handelt es sich um einen Algorithmus welcher die Position von einem Wert in einem sortierten Array schnell findet.
|
||||||
|
|
||||||
|
Beispiele:
|
||||||
|
```python
|
||||||
|
binary_search([1, 2, 3, 4, 5], 4) # 3, was der index von 4 ist
|
||||||
|
binary_search(["a", "b", "c", "d"], "b") # 1, was der index von "b" ist
|
||||||
|
```
|
||||||
|
|
||||||
|
- Dazu definieren wir eine linke Grenze `left` mit dem Anfangswert `0` und eine rechte Grenze `right` mit dem Anfangswert `len(xs) - 1`, damit können wir unser gesuchtes Element immer weiter eingrenzen.
|
||||||
|
- Jetzt wissen wir durch die Sortierung dass `left <= right` sein muss.
|
||||||
|
- Also gehen wir jetzt durch unsere Liste und berechnen die Mitte `middle` von `left` und `right` aus und vergleichen diese mit unserem gesuchten Wert.
|
||||||
|
- Ist `middle` kleiner als unser Wert dann können wir `left = middle + 1` setzen
|
||||||
|
- Ist `middle` größer als unser Wert dann können wir `right = middle - 1` setzen
|
||||||
|
- Sonst haben wir unseren Wert, nämlich `middle`, gefunden und können diesen zurückgeben
|
||||||
|
- Wenn der Wert nicht existiert wird `None` zurückgegeben
|
||||||
|
- Für leere Listen soll auch `None` zurückgegeben werden
|
||||||
|
|
||||||
|
|
||||||
|
<details>
|
||||||
|
<summary>Hilfe 1: Pseudocode</summary>
|
||||||
|
|
||||||
|
```
|
||||||
|
linker_index = 0
|
||||||
|
rechter_index = länge - 1
|
||||||
|
solange linker_index <= rechter_index dann
|
||||||
|
mitte = (linker_index + rechter_index) / 2
|
||||||
|
Wenn Liste[mitte] < gesuchter Wert dann
|
||||||
|
linker_index = mitte + 1
|
||||||
|
Wenn Liste[mitte] > gesuchter Wert dann
|
||||||
|
rechter_index = mitte - 1
|
||||||
|
Sonst
|
||||||
|
return Liste[mitte]
|
||||||
|
return Nichts
|
||||||
|
```
|
||||||
|
|
||||||
|
</details>
|
||||||
|
|
||||||
|
## [Hier gehts zur Lösung](src/branch/main/loops/sort/solution)
|
||||||
@@ -0,0 +1,87 @@
|
|||||||
|
# Solution
|
||||||
|
|
||||||
|
## `selection_sort`
|
||||||
|
|
||||||
|
Zunächst müssen wir eine neue Liste mit den selben Elementen erstellen, am schnellsten geht das mit `copy.deepcopy` welche eine vollständige Copie erstellt.
|
||||||
|
|
||||||
|
```python
|
||||||
|
from copy import deepcopy
|
||||||
|
|
||||||
|
xss = deepcopy(xs)
|
||||||
|
```
|
||||||
|
|
||||||
|
Wir müssen durch jedes Element gehen, also
|
||||||
|
|
||||||
|
```python
|
||||||
|
for i in range(len(xss)):
|
||||||
|
# ...
|
||||||
|
```
|
||||||
|
Nun wollen wir in den übrigen Elementen ($j = i + 1$) das kleinste finden
|
||||||
|
|
||||||
|
```python
|
||||||
|
for i in range(len(xss)):
|
||||||
|
min_i = i # index vom kleinsten Element,
|
||||||
|
# das aktuelle i falls dieses schon das kleinste ist
|
||||||
|
for j in range(i + 1, len(xss)):
|
||||||
|
# ...
|
||||||
|
```
|
||||||
|
|
||||||
|
Jetzt vergleichen wir nur noch jedes j-te Element mit dem aktuellen kleinsten
|
||||||
|
|
||||||
|
```python
|
||||||
|
for i in range(len(xss)):
|
||||||
|
min_i = i # index vom kleinsten Element,
|
||||||
|
# das aktuelle i falls dieses schon das kleinste ist
|
||||||
|
for j in range(i + 1, len(xss)):
|
||||||
|
if xss[j] < xss[min_i]:
|
||||||
|
min_i = j # kleineres element gefunden
|
||||||
|
```
|
||||||
|
|
||||||
|
Nun können wir einfach das i-te mit dem min_i vertauschen (entweder ist es i oder wir haben ein kleineres gefunden)
|
||||||
|
|
||||||
|
```python
|
||||||
|
xss[i], xss[min_i] = xss[min_i], xss[i] # tauschen i mit min_i
|
||||||
|
```
|
||||||
|
|
||||||
|
und am Ende können wir `xss` zurückgeben
|
||||||
|
|
||||||
|
```python
|
||||||
|
return xss
|
||||||
|
```
|
||||||
|
|
||||||
|
## `binary_search`
|
||||||
|
|
||||||
|
Hierfür definieren wir zunächst `left = 0` und `right = len(xs) - 1`, dann können wir die Schleifenbedingung definieren als
|
||||||
|
|
||||||
|
```python
|
||||||
|
while left <= right:
|
||||||
|
# ...
|
||||||
|
```
|
||||||
|
|
||||||
|
weil sobald diese nicht mehr gilt konnten wir den Wert nicht finden. (Links und Rechts tauschen) und wir können `None` zurückgeben.
|
||||||
|
|
||||||
|
Nun berechnen wir den mittleren Index mit dem integer division (oder auch floor weil es die Zahl hinterm Komma verwirft).
|
||||||
|
|
||||||
|
```python
|
||||||
|
middle = (left + right) // 2
|
||||||
|
```
|
||||||
|
|
||||||
|
Nun müssen wir nur noch `xs[middle]` mit `value` vergleichen
|
||||||
|
|
||||||
|
```python
|
||||||
|
if xs[middle] < value:
|
||||||
|
left = middle + 1
|
||||||
|
elif xs[middle] > value:
|
||||||
|
right = middle - 1
|
||||||
|
```
|
||||||
|
|
||||||
|
Und wenn `xs[middle] == value` ist haben wir unseren Index `middle` gefunden.
|
||||||
|
|
||||||
|
```python
|
||||||
|
if xs[middle] < value:
|
||||||
|
left = middle + 1
|
||||||
|
elif xs[middle] > value:
|
||||||
|
right = middle - 1
|
||||||
|
else:
|
||||||
|
return middle
|
||||||
|
```
|
||||||
@@ -0,0 +1,27 @@
|
|||||||
|
from copy import deepcopy
|
||||||
|
from typing import Iterator, Optional
|
||||||
|
|
||||||
|
|
||||||
|
def selection_sort[T](xs: Iterator[T]) -> Iterator[T]:
|
||||||
|
length = len(xs)
|
||||||
|
xss = deepcopy(xs)
|
||||||
|
for i in range(length):
|
||||||
|
min_i = i
|
||||||
|
for j in range(i + 1, length):
|
||||||
|
if xss[j] < xss[min_i]:
|
||||||
|
min_i = j
|
||||||
|
xss[i], xss[min_i] = xss[min_i], xss[i]
|
||||||
|
return xss
|
||||||
|
|
||||||
|
def binary_search[T](xs: list[T], value: T) -> Optional[int]:
|
||||||
|
left = 0
|
||||||
|
right = len(xs) - 1
|
||||||
|
while left <= right:
|
||||||
|
middle = (left + right) // 2
|
||||||
|
if xs[middle] < value:
|
||||||
|
left = middle + 1
|
||||||
|
elif xs[middle] > value:
|
||||||
|
right = middle - 1
|
||||||
|
else:
|
||||||
|
return middle
|
||||||
|
return None
|
||||||
@@ -0,0 +1,9 @@
|
|||||||
|
from typing import Iterator, Optional
|
||||||
|
|
||||||
|
|
||||||
|
def selection_sort[T](xs: Iterator[T]) -> Iterator[T]:
|
||||||
|
return []
|
||||||
|
|
||||||
|
|
||||||
|
def binary_search[T](xs: list[T], value: T) -> Optional[int]:
|
||||||
|
return None
|
||||||
@@ -0,0 +1,22 @@
|
|||||||
|
from random import randint
|
||||||
|
from typing import Iterator
|
||||||
|
from sort import selection_sort, binary_search
|
||||||
|
|
||||||
|
def get_random_collection(min: int, max: int, size: int) -> Iterator[int]:
|
||||||
|
return [randint(min, max) for _ in range(size)]
|
||||||
|
|
||||||
|
def test_selection_sort():
|
||||||
|
xs = [5, 4, 3, 2, 1, 0]
|
||||||
|
assert list(selection_sort(xs)) == sorted(xs)
|
||||||
|
assert xs == [5, 4, 3, 2, 1, 0], "list was modified in `selection_sort` return a copy instead"
|
||||||
|
xs = get_random_collection(0, 100, 100)
|
||||||
|
print(xs)
|
||||||
|
assert list(selection_sort(xs)) == sorted(xs)
|
||||||
|
|
||||||
|
def test_binary_search():
|
||||||
|
xs = sorted(set(get_random_collection(0, 10000, 100)))
|
||||||
|
for i, e in enumerate(xs):
|
||||||
|
assert binary_search(xs, e) == i
|
||||||
|
assert binary_search([], 1) == None
|
||||||
|
assert binary_search([2], 1) == None
|
||||||
|
assert binary_search([2, 3], 1) == None
|
||||||
@@ -0,0 +1,4 @@
|
|||||||
|
# Mit Zeichenketten arbeiten und manipulieren
|
||||||
|
|
||||||
|
Diese Teilaufgaben sind teilweise sehr einfach zu implementieren und sollen veranschaulichen was man alles mit Strings machen kann. Hierbei könnt ihr euch es natürlich einfach machen und die Buildins von `str` verwenden oder die Funktionen komplett selber implementieren.
|
||||||
|
|
||||||
@@ -0,0 +1,93 @@
|
|||||||
|
from dataclasses import dataclass, InitVar
|
||||||
|
from typing import Iterator
|
||||||
|
|
||||||
|
type Str = 'String' | str
|
||||||
|
|
||||||
|
@dataclass
|
||||||
|
class String:
|
||||||
|
_s: InitVar[str]
|
||||||
|
|
||||||
|
def __post_init__(self, s: str) -> None:
|
||||||
|
self.__s = s
|
||||||
|
|
||||||
|
def __str__(self) -> str:
|
||||||
|
return self.__s
|
||||||
|
|
||||||
|
def __add__(self, other: Str) -> 'String':
|
||||||
|
return String(self.__s + str(other))
|
||||||
|
|
||||||
|
def __iadd__(self, other: Str) -> 'String':
|
||||||
|
return self + other
|
||||||
|
|
||||||
|
def __len__(self) -> int:
|
||||||
|
return len(self.__s)
|
||||||
|
|
||||||
|
def __eq__(self, other: Str) -> bool:
|
||||||
|
return str(self) == str(other)
|
||||||
|
|
||||||
|
def concat(self, other: Str) -> None:
|
||||||
|
self + other
|
||||||
|
|
||||||
|
def contains(self, other: Str) -> bool:
|
||||||
|
s = str(other)
|
||||||
|
for c in str(self):
|
||||||
|
if len(s) <= 0:
|
||||||
|
break
|
||||||
|
elif c == s[0]:
|
||||||
|
s: str = s[1:]
|
||||||
|
else:
|
||||||
|
s = str(other)
|
||||||
|
return len(s) == 0
|
||||||
|
|
||||||
|
def concat(self, other: Str) -> None:
|
||||||
|
self.__s += str(other)
|
||||||
|
|
||||||
|
def substring(self, start: int, end: int) -> 'String':
|
||||||
|
substr: str = ""
|
||||||
|
for i, c in enumerate(self.__s):
|
||||||
|
if i >= start and i <= end:
|
||||||
|
substr += c
|
||||||
|
return substr
|
||||||
|
|
||||||
|
def strip(self, chars: Str = ' ' + '\n' + '\t' + '\r') -> None:
|
||||||
|
i = 0
|
||||||
|
while i < len(self) and self.__s[i] in chars:
|
||||||
|
i += 1
|
||||||
|
j: int = len(self) - 1
|
||||||
|
while i <= j and self.__s[j] in chars:
|
||||||
|
j -= 1
|
||||||
|
self.__s: str = str(self)[i:j + 1]
|
||||||
|
|
||||||
|
def replace(self, old: Str, new: Str, count = -1) -> None:
|
||||||
|
o = str(old)
|
||||||
|
n = str(new)
|
||||||
|
j = 0
|
||||||
|
while count > 0 or (count < 0 and j < len(self)):
|
||||||
|
i: int = j
|
||||||
|
while len(o) > 0 and j < len(self):
|
||||||
|
if o[0] == self.__s[j]:
|
||||||
|
o: str = o[1:]
|
||||||
|
j += 1
|
||||||
|
else:
|
||||||
|
j += 1
|
||||||
|
break
|
||||||
|
if len(o) <= 0:
|
||||||
|
self.__s = self.__s[:i] + n + self.__s[j:]
|
||||||
|
j += len(new) - len(old)
|
||||||
|
count -= 1
|
||||||
|
o = str(old)
|
||||||
|
|
||||||
|
def add_prefix(self, prefix: Str) -> None:
|
||||||
|
self.__s = str(prefix) + self.__s
|
||||||
|
|
||||||
|
def add_suffix(self, suffix: Str) -> None:
|
||||||
|
self.__s += str(suffix)
|
||||||
|
|
||||||
|
def join[T](self, xs: Iterator[T]) -> 'String':
|
||||||
|
output = String("")
|
||||||
|
length: int = len(xs)
|
||||||
|
for i, e in enumerate(xs):
|
||||||
|
output += str(e)
|
||||||
|
if i < length - 1:
|
||||||
|
output += self
|
||||||
|
return output
|
||||||
@@ -0,0 +1,9 @@
|
|||||||
|
from dataclasses import dataclass
|
||||||
|
|
||||||
|
# kleine Hilfestellung mit `Str` kann man sowohl `str` als auch `String` meinen
|
||||||
|
type Str = 'String' | str
|
||||||
|
|
||||||
|
@dataclass
|
||||||
|
class String:
|
||||||
|
# Implement!
|
||||||
|
pass
|
||||||
@@ -0,0 +1,49 @@
|
|||||||
|
from strings import String
|
||||||
|
|
||||||
|
def test_eq_for_str():
|
||||||
|
test_str = String("this is a test string!")
|
||||||
|
assert test_str == "this is a test string!", "__eq__ wasn't implemented correctly for `String` and `str`"
|
||||||
|
|
||||||
|
def test_strings_contains():
|
||||||
|
test_str = String("this is a test")
|
||||||
|
assert test_str.contains("this")
|
||||||
|
assert not test_str.contains("release")
|
||||||
|
|
||||||
|
def test_strings_concat():
|
||||||
|
test_str = String("")
|
||||||
|
test_str += "test succesful!"
|
||||||
|
assert test_str == "test succesful!"
|
||||||
|
test_str.concat(" Or is it?")
|
||||||
|
assert test_str == "test succesful! Or is it?"
|
||||||
|
|
||||||
|
def test_strings_strip():
|
||||||
|
test_str = String(" halo? \n")
|
||||||
|
test_str.strip()
|
||||||
|
assert test_str == "halo?"
|
||||||
|
test_str = String(" \n ")
|
||||||
|
test_str.strip()
|
||||||
|
assert test_str == ""
|
||||||
|
|
||||||
|
|
||||||
|
def test_strings_replace():
|
||||||
|
test_str = String("har har har, try replacing thhis")
|
||||||
|
test_str.replace('har ', 'ha')
|
||||||
|
assert test_str == "hahahar, try replacing thhis"
|
||||||
|
test_str.replace('r', '', 1)
|
||||||
|
assert test_str == "hahaha, try replacing thhis"
|
||||||
|
test_str.replace('hh', 'h')
|
||||||
|
assert test_str == "hahaha, try replacing this"
|
||||||
|
test_str.replace('try replacing this', "replaced")
|
||||||
|
assert test_str == "hahaha, replaced"
|
||||||
|
|
||||||
|
|
||||||
|
def test_add_pre_suf():
|
||||||
|
test_str = String(" ")
|
||||||
|
test_str.add_suffix("suff")
|
||||||
|
assert test_str == " suff"
|
||||||
|
test_str.add_prefix("pref")
|
||||||
|
assert test_str == "pref suff"
|
||||||
|
|
||||||
|
def test_join():
|
||||||
|
assert String(", ").join([1, 2, 3, 4]) == "1, 2, 3, 4"
|
||||||
|
assert String(", ").join([]) == ""
|
||||||
Reference in new issue
Block a user