Add OOP solutions.

ai_exercises/01.py

@@ -0,0 +1,28 @@
+# Die Aufgabe: Der "Text-Analysator"
+
+# Schreibe eine Funktion namens analysiere_text, die einen String entgegennimmt und ein Dictionary mit folgenden Informationen zurückgibt:
+
+#     anzahl_zeichen: Die Gesamtzahl der Zeichen (inkl. Leerzeichen).
+
+#     anzahl_woerter: Wie viele Wörter der Text enthält.
+
+#     ist_lang: Ein Boolean, der True ist, wenn der Text mehr als 50 Zeichen hat, andernfalls False.
+
+def analysiere_text(text):
+    # HIER DEINEN CODE EINFÜGEN
+    ergebnis = {
+        'anzahl_zeichen': len(text),
+        'anzahl_woerter': len(text.split()),
+        'ist_lang': len(text) > 50
+    }
+    
+    return ergebnis
+
+# --- Main-Abschnitt ---
+if __name__ == "__main__":
+    test_text = "Python programmieren macht Spaß und ist logisch."
+    
+    analyse = analysiere_text(test_text)
+    
+    print(f"Text: {test_text}")
+    print(f"Ergebnis: {analyse}")

ai_exercises/02.py

@@ -0,0 +1,22 @@
+# Die Aufgabe: Der "Listen-Filter & Transformer"
+
+# Schreibe eine Funktion namens verarbeite_zahlen, die eine Liste von Zahlen entgegennimmt. Die Funktion soll eine neue Liste zurückgeben, die:
+
+#     Nur die geraden Zahlen aus der ursprünglichen Liste enthält.
+
+#     Jede dieser geraden Zahlen quadriert (hoch 2 nimmt).
+
+#     Die Liste am Ende absteigend sortiert (vom größten zum kleinsten Wert).
+
+def verarbeite_zahlen(zahlen_liste):
+    return sorted([zahl*zahl 
+                   for zahl in zahlen_liste if zahl % 2 == 0], reverse=True)
+
+# --- Main-Abschnitt ---
+if __name__ == "__main__":
+    meine_zahlen = [3, 8, 2, 5, 10, 7, 4]
+    
+    ergebnis = verarbeite_zahlen(meine_zahlen)
+    
+    print(f"Eingabe: {meine_zahlen}")
+    print(f"Ergebnis: {ergebnis}")

ai_exercises/03.py

@@ -0,0 +1,46 @@
+# Die Aufgabe: Der "Warenkorb-Manager" (OOP)
+
+# Erstelle die Klasse Warenkorb. Sie muss so entworfen sein, dass sie mit dem unten stehenden main-Block funktioniert.
+
+# Anforderungen:
+
+#     Speicherung: Intern sollen die Produkte in einer Liste gespeichert werden.
+
+#     Methoden:
+
+#         hinzufuegen(name, preis): Speichert ein Produkt.
+
+#         gesamtpreis(): Liefert die Summe aller Preise zurück.
+
+#         anzahl_artikel(): Liefert die Anzahl der Produkte zurück.
+
+# --- HIER DIE KLASSE WARENKORB ERSTELLEN ---
+
+
+class Warenkorb:
+    def __init__(self):
+        self.__waren = []
+
+    def hinzufuegen(self, produkt, preis):
+        self.__waren.append((produkt, preis))
+
+    def gesamtpreis(self):
+        return sum([preis for _, preis in self.__waren])
+    
+    def anzahl_artikel(self):
+        return len(self.__waren)
+
+
+# --- Main-Abschnitt ---
+if __name__ == "__main__":
+    # Instanzierung
+    mein_korb = Warenkorb()
+    
+    # Methodenaufrufe
+    mein_korb.hinzufuegen("Apfel", 0.99)
+    mein_korb.hinzufuegen("Brot", 2.50)
+    mein_korb.hinzufuegen("Kaffee", 5.95)
+    
+    # Ausgaben
+    print(f"Artikel im Korb: {mein_korb.anzahl_artikel()}")
+    print(f"Gesamtsumme: {mein_korb.gesamtpreis():.2f}€")

ai_exercises/04.py

@@ -0,0 +1,42 @@
+# Die Aufgabe: Das "Bibliotheks-System"
+
+# Wir wollen verschiedene Medientypen in einer Bibliothek verwalten. Alle Medien haben einen Titel, aber Bücher haben zusätzlich eine Seitenzahl, während Filme eine Laufzeit haben.
+
+# Deine Mission:
+
+#     Erstelle eine Basisklasse Medium.
+
+#     Erstelle zwei Unterklassen: Buch und Film, die von Medium erben.
+
+#     Nutze die Magic Method __str__, damit man ein Objekt einfach mit print(objekt) schön formatiert ausgeben kann.
+
+# --- HIER DIE KLASSEN Medium, Buch UND Film ERSTELLEN ---
+
+
+class Medium:
+    def __init__(self, titel, laenge):
+        self._titel = titel
+        self._laenge = laenge
+
+class Buch(Medium):
+    def __str__(self):
+        return f'BUCH: {self._titel} ({self._laenge} Seiten)'
+
+class Film(Medium):
+    def __str__(self):
+        return f'FILM: {self._titel} ({self._laenge} Minuten)'
+
+
+
+# --- Main-Abschnitt ---
+if __name__ == "__main__":
+    # Erstellung der Objekte
+    buch1 = Buch("Der Prozess", 280)
+    film1 = Film("Inception", 148)
+    
+    # Medien in einer Liste sammeln
+    bibliothek = [buch1, film1]
+    
+    # Ausgabe der Medien (nutzt automatisch die __str__ Methode)
+    for medium in bibliothek:
+        print(medium)

snake/game_loop.py

@@ -0,0 +1,40 @@
+import pygame
+from game_object import GameObject
+from window import Window
+from input_manager import InputManager
+
+
+class GameLoop:
+    def __init__(self, window: Window, game_objs: list[GameObject], input_manager: InputManager):
+        self.__window = window
+        self.__game_objs = game_objs
+        self.__input_manager = input_manager
+
+
+    @staticmethod
+    def __draw_all(window: Window, game_objs: list[GameObject]) -> None:
+        window.reset()
+
+        for obj in game_objs:
+            window.draw_object(obj)
+
+
+    @staticmethod
+    def __update_all(game_objs: list[GameObject], user_input: int) -> None:
+        for obj in game_objs:
+            obj.update(user_input, game_objs)
+
+
+    def run(self, framerate=15):
+        clock = pygame.time.Clock()
+
+        last_input = None
+
+        while last_input != InputManager.QUIT:
+            last_input = self.__input_manager.process_input()
+
+            GameLoop.__update_all(self.__game_objs, last_input)
+            GameLoop.__draw_all(self.__window, self.__game_objs)
+
+            clock.tick(framerate)
+            pygame.display.flip()

snake/game_over_screen.py

@@ -0,0 +1,22 @@
+import pygame
+from game_object import GameObject
+from snake import Snake
+
+
+class GameOverScreen(GameObject):
+    def __init__(self, window_size, color):
+        font = pygame.font.SysFont('Arial', 140)
+        self.__text_surface = font.render('GAME OVER', True, color)
+        self.__pos = [0.5*(win_size - font_size) 
+                      for win_size, font_size in zip(window_size, 
+                                                     self.__text_surface.get_size())]
+        self.__is_visible = False
+    
+    def draw(self, surface):
+        if self.__is_visible:
+            surface.blit(self.__text_surface, self.__pos)
+
+    def update(self, user_input, game_objs):
+        for obj in game_objs:
+            if isinstance(obj, Snake) and obj.is_dead():
+                self.__is_visible = True

snake/main.py

@@ -1,52 +1,36 @@
-import pygame
 from window import Window
 from input_manager import InputManager
 from snake import Snake
 from game_object import GameObject
 from wall import Wall
 from prey import Prey
-
+from game_over_screen import GameOverScreen
-
+from game_loop import GameLoop
-def draw_all(window: Window, game_objs: list[GameObject]) -> None:
-    window.reset()
-
-    for obj in game_objs:
-        window.draw_object(obj)
-
-
-def update_all(game_objs: list[GameObject], user_input: int) -> None:
-    for obj in game_objs:
-        obj.update(user_input, game_objs)
 
 
 def create_game_objects(window: Window):
     return [Snake(start_position=(400, 300),
                   length=5,
                   radius=10,
-                  color=(255, 0, 255)),
+                  color=(0, 0, 255)),
             Wall(window_size=window.get_size(),
                  width=5,
                  color=(255, 0, 0)),
             Prey(size=10,
                  color=(255, 255, 0),
-                 window_size=window.get_size())]
+                 window_size=window.get_size()),
+            GameOverScreen(window_size=window.get_size(),
+                           color=(255, 0, 0))]
 
 
 if __name__ == '__main__':
-    window = Window(title='Snake', size=(800, 600), background_color=(0, 128, 0))
+    window = Window(title='Snake', 
-    input_manager = InputManager()
+                    size=(800, 600), 
-    game_objs = create_game_objects(window)
+                    background_color=(50, 180, 50))
+    game_loop = GameLoop(window=window,
+                         game_objs=create_game_objects(window),
+                         input_manager=InputManager())
     
-    clock = pygame.time.Clock()
+    game_loop.run(framerate=15)
-    framerate = 15
     
-    last_input = None
     
-    while last_input != InputManager.QUIT:
-        last_input = input_manager.process_input()
-
-        update_all(game_objs, last_input)
-        draw_all(window, game_objs)
-
-        clock.tick(framerate)
-        pygame.display.flip()

snake/snake.py

@@ -60,3 +60,7 @@ class Snake(GameObject):
 
     def get_bounding_boxes(self) -> list[pygame.rect.Rect]:
         return [seg.get_bounding_boxes()[0] for seg in self.__segments]
+    
+    
+    def is_dead(self):
+        return self.__is_dead

uebungen.ipynb

@@ -1559,7 +1559,65 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Fügen Sie hier Ihre Klassendefinition für ZeichenZaehler ein."
+    "# Fügen Sie hier Ihre Klassendefinition für ZeichenZaehler ein.\n",
+    "\n",
+    "class ZeichenZaehler:\n",
+    "    def __init__(self, zeichen):\n",
+    "        self.__zeichen = set(zeichen.lower())\n",
+    "        self.__stand = 0\n",
+    "\n",
+    "    def zaehle(self, string):\n",
+    "        if type(string) == str:\n",
+    "            for zeichen in self.__zeichen:\n",
+    "                self.__stand += string.lower().count(zeichen)\n",
+    "            return True\n",
+    "        else:\n",
+    "            return False\n",
+    "\n",
+    "    def zaehler_stand(self):\n",
+    "        return self.__stand\n",
+    "\n",
+    "    def setze_zurueck(self):\n",
+    "        self.__stand = 0\n",
+    "\n",
+    "\n",
+    "def zeichenZaehler_zaehlt_korrekt():\n",
+    "    zaehler = ZeichenZaehler('ai')\n",
+    "    zaehler.zaehle('aannii')\n",
+    "    assert(zaehler.zaehler_stand() == 4)\n",
+    "\n",
+    "def zeichenZaehler_akkumuliert_stand():\n",
+    "    zaehler = ZeichenZaehler('ai')\n",
+    "    zaehler.zaehle('aannii')\n",
+    "    zaehler.zaehle('aaanniii')\n",
+    "    assert(zaehler.zaehler_stand() == 10)\n",
+    "\n",
+    "def zeichenZaehler_ignoriert_grossklein():\n",
+    "    zaehler = ZeichenZaehler('Ai')\n",
+    "    zaehler.zaehle('aannII')\n",
+    "    assert(zaehler.zaehler_stand() == 4)\n",
+    "\n",
+    "def zeichenZaehler_setzt_zaehler_zurueck():\n",
+    "    zaehler = ZeichenZaehler('ai')\n",
+    "    zaehler.zaehle('aannii')\n",
+    "    zaehler.setze_zurueck()\n",
+    "    zaehler.zaehle('aaanniii')\n",
+    "    assert(zaehler.zaehler_stand() == 6)\n",
+    "\n",
+    "def zeichenZaehler_zaehle_liefert_true_bei_string():\n",
+    "    zaehler = ZeichenZaehler('ai')\n",
+    "    assert(zaehler.zaehle('aannii') == True)\n",
+    "    assert(zaehler.zaehle(123) == False)\n",
+    "\n",
+    "def teste():\n",
+    "    zeichenZaehler_zaehlt_korrekt()\n",
+    "    zeichenZaehler_akkumuliert_stand()\n",
+    "    zeichenZaehler_ignoriert_grossklein()\n",
+    "    zeichenZaehler_setzt_zaehler_zurueck()\n",
+    "    zeichenZaehler_zaehle_liefert_true_bei_string()\n",
+    "\n",
+    "\n",
+    "teste()"
    ]
   },
   {
@@ -1599,7 +1657,21 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Fügen Sie hier Ihren Code ein."
+    "# Fügen Sie hier Ihren Code ein.\n",
+    "\n",
+    "zaehler = ZeichenZaehler('aieou')\n",
+    "\n",
+    "eingabe = input('Geben Sie einen Text ein: ')\n",
+    "\n",
+    "while(len(eingabe) > 0):\n",
+    "    if eingabe.isdecimal() and int(eingabe) == 0:\n",
+    "        zaehler.setze_zurueck()\n",
+    "    else:\n",
+    "        zaehler.zaehle(eingabe)\n",
+    "        print(f'Es war(en) {zaehler.zaehler_stand()} Vokal(e) in Ihren Eingaben.')\n",
+    "\n",
+    "    eingabe = input('Geben Sie einen Text ein: ')\n",
+    "    "
    ]
   },
   {
@@ -1666,24 +1738,12 @@
     "print(r)"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Fügen Sie hier Ihren Code für \n",
-    "\n",
-    "some_str = ExtendedString('Das ist ein Test, oder etwa nicht?')\n",
-    "print(some_str.multisplit(' ?,'))"
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "### 9.3. <a id='toc9_3_'></a>[Aufgabe](#toc0_)\n",
-    "Erstellen Sie eine Klasse `ExtendedString`, die die gleiche Funktionalität wie die originale `str`-Klasse anbietet, deren `split`-Funktion jedoch einen zusätzlichen Parameter `multi` anbietet. Wird `multi` nicht angegeben oder ist es auf `False` gesetzt, verhält sich `split` wie in der originalen `str`-Klasse. Ist `multi` jedoch auf `True` gesetzt, wird der jeweilige String an jedem Character des Separator-Strings geteilt. Das Argument `maxsplit` kann in diesem Fall der Einfachheit halber ignoriert werden.\n",
+    "Erstellen Sie eine Klasse `ExtendedString`, die die gleiche Funktionalität wie die originale `str`-Klasse anbietet. Wird `multi_split` jedoch aufgerufen, wird der jeweilige String an jedem Character des Separator-Strings geteilt.\n",
     "\n",
     "**Beispiel**\n",
     "\n",
@@ -1693,7 +1753,7 @@
     "<br/>\n",
     "`print(some_str.split(' ?,'))` gibt `['Das ist ein Test, oder etwa nicht?']` aus.\n",
     "<br/>\n",
-    "`print(some_str.split(' ?,', multi=True))` gibt `['Das', 'ist', 'ein', 'Test', 'oder', 'etwa', 'nicht']` aus.\n",
+    "`print(some_str.multi_split(' ?,'))` gibt `['Das', 'ist', 'ein', 'Test', 'oder', 'etwa', 'nicht']` aus.\n",
     "</code>"
    ]
   },
@@ -1703,7 +1763,23 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Fügen Sie hier Ihren Code ein."
+    "# Fügen Sie hier Ihren Code ein.\n",
+    "class ExtendedString(str):\n",
+    "    def multi_split(self, separators):\n",
+    "        result = [self]\n",
+    "        for sep in separators:\n",
+    "            tmp = []\n",
+    "            for elem in result:\n",
+    "                tmp.extend(elem.split(sep))\n",
+    "            result = [entry for entry in tmp if len(entry) > 0]\n",
+    "        \n",
+    "        return result\n",
+    "    \n",
+    "\n",
+    "some_str = ExtendedString('Das ist ein Test, oder etwa nicht?')\n",
+    "print(some_str.split())\n",
+    "print(some_str.split(' ?,'))\n",
+    "print(some_str.multi_split(' ?,'))"
    ]
   },
   {
@@ -1744,6 +1820,13 @@
     "# Erweitern Sie die Klasse Database\n",
     "\n",
     "class Database:\n",
+    "    __my_obj = None\n",
+    "\n",
+    "    def __new__(cls):\n",
+    "        if Database.__my_obj is None:\n",
+    "            Database.__my_obj = super().__new__(cls)\n",
+    "        return Database.__my_obj\n",
+    "\n",
     "    def __init__(self):\n",
     "        self.__entries = []\n",
     "\n",
@@ -1784,7 +1867,14 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Fügen Sie hier Ihren Code für die Quadrat-Klasse ein."
+    "# Fügen Sie hier Ihren Code für die Quadrat-Klasse ein.\n",
+    "\n",
+    "class Quadrat:\n",
+    "    def __init__(self, seitenlaenge):\n",
+    "        self.__seitenlaenge = seitenlaenge\n",
+    "\n",
+    "    def seitenlaenge(self):\n",
+    "        return self.__seitenlaenge"
    ]
   },
   {
@@ -1803,6 +1893,36 @@
    "outputs": [],
    "source": [
     "# Fügen Sie hier Ihren Code für die RechteckAdapter-Klasse ein.\n",
+    "class Rechteck:\n",
+    "    def seite1(self):\n",
+    "        pass\n",
+    "\n",
+    "    def seite2(self):\n",
+    "        pass\n",
+    "\n",
+    "    def umfang(self):\n",
+    "        pass\n",
+    "\n",
+    "    def flaecheninhalt(self):\n",
+    "        pass\n",
+    "\n",
+    "\n",
+    "class RechteckAdapter(Rechteck):\n",
+    "    def __init__(self, quadrat):\n",
+    "        self.__quadrat = quadrat\n",
+    "\n",
+    "    def seite1(self):\n",
+    "        return self.__quadrat.seitenlaenge()\n",
+    "\n",
+    "    def seite2(self):\n",
+    "        return self.__quadrat.seitenlaenge()\n",
+    "\n",
+    "    def umfang(self):\n",
+    "        return self.__quadrat.seitenlaenge() * 4\n",
+    "\n",
+    "    def flaecheninhalt(self):\n",
+    "        return self.__quadrat.seitenlaenge()**2\n",
+    "    \n",
     "\n",
     "def verarbeiteRechteck(rechteck):\n",
     "    print(f'Die 1. Seite des Rechtecks ist {rechteck.seite1()} Einheiten lang.')\n",
@@ -1812,7 +1932,7 @@
     "\n",
     "\n",
     "quadrat = Quadrat(4)\n",
-    "verarbeiteRechteck(quadrat) # Erstellen bzw. ergänzen Sie hier Ihr Adapter-Objekt, um es mit dem Quadrat-Objekt an die Funktion zu übergeben."
+    "verarbeiteRechteck(RechteckAdapter(quadrat)) # Erstellen bzw. ergänzen Sie hier Ihr Adapter-Objekt, um es mit dem Quadrat-Objekt an die Funktion zu übergeben."
    ]
   },
   {
@@ -1833,6 +1953,42 @@
    "source": [
     "# Fügen Sie hier Ihren Code für die Klasse EntryCounter ein.\n",
     "\n",
+    "class EntryCounter:\n",
+    "    def __init__(self, max_persons):\n",
+    "        self.__max_persons = max_persons\n",
+    "        self.__count = 0\n",
+    "        self.__lights = []\n",
+    "        self.__state = None\n",
+    "\n",
+    "    def someone_enters(self):\n",
+    "        self.__count += 1\n",
+    "        self.__update_state()\n",
+    "\n",
+    "    def someone_leaves(self):\n",
+    "        self.__count -= 1\n",
+    "        self.__update_state()\n",
+    "\n",
+    "    def get_count(self):\n",
+    "        return self.__count\n",
+    "    \n",
+    "    def register(self, light):\n",
+    "        self.__lights.append(light)\n",
+    "    \n",
+    "    def __update_state(self):\n",
+    "        state = None\n",
+    "        if self.__count + 1 < self.__max_persons:\n",
+    "            state = 'green'\n",
+    "        elif self.__count + 1 == self.__max_persons:\n",
+    "            state = 'yellow'\n",
+    "        else:\n",
+    "            state = 'red'\n",
+    "\n",
+    "        if state != self.__state:\n",
+    "            for light in self.__lights:\n",
+    "                light.update(state)\n",
+    "            self.__state = state\n",
+    "\n",
+    "\n",
     "class TrafficLight:\n",
     "    def __init__(self, status):\n",
     "        self.__status = status\n",
@@ -1840,6 +1996,9 @@
     "    def get_light_status(self):\n",
     "        return self.__status\n",
     "    \n",
+    "    def update(self, status):\n",
+    "        self.__status = status\n",
+    "\n",
     "    # Erweitern Sie hier die Klasse TrafficLight um weitere Methoden, falls notwendig."
    ]
   },
@@ -1856,16 +2015,20 @@
     "\n",
     "entry_counter = EntryCounter(5)\n",
     "# Fügen Sie hier zusätzlichen Code für entry_counter ein, falls notwendig, und nur, wenn Sie in der Aufgabenbeschreibung dazu aufgefordert werden.\n",
+    "entry_counter.register(traffic_light1)\n",
+    "entry_counter.register(traffic_light2)\n",
     "\n",
     "for enter_or_leave in [1, 1, 1, 1, -1, 1, 1, 1, -1, -1, -1, -1]:\n",
     "    if enter_or_leave == 1:\n",
-    "        entry_counter.someoneEnters()\n",
+    "        print('Someone enters')\n",
+    "        entry_counter.someone_enters()\n",
     "    elif enter_or_leave == -1:\n",
-    "        entry_counter.someoneLeaves()\n",
+    "        print('Someone leaves')\n",
+    "        entry_counter.someone_leaves()\n",
     "    else:\n",
     "        print(f'Unrecognized code: {enter_or_leave}')\n",
     "\n",
-    "    print(f'People in the room: {entry_counter.getCount()}')\n",
+    "    print(f'People in the room: {entry_counter.get_count()}')\n",
     "    print(f'Traffic light 1: {traffic_light1.get_light_status()}')\n",
     "    print(f'Traffic light 2: {traffic_light2.get_light_status()}\\n')"
    ]
@@ -1920,6 +2083,16 @@
    "source": [
     "# Fügen Sie hier Ihren Code ein.\n",
     "\n",
+    "buffer_size = 32\n",
+    "\n",
+    "with open('ohm.png', 'rb') as file:\n",
+    "    with open('logo.png', 'wb') as file:\n",
+    "        buffer = file.read(buffer_size)\n",
+    "        \n",
+    "        while len(buffer) > 0:\n",
+    "            file.write(buffer)\n",
+    "            buffer = file.read(buffer_size)\n",
+    "\n",
     "Image(filename=\"logo.png\")"
    ]
   },
@@ -1961,23 +2134,42 @@
    "source": [
     "def input_lines(prompt_text):\n",
     "    # Fügen Sie hier Ihren Code ein.\n",
-    "    pass\n",
+    "    lines = []\n",
+    "    last_input = input(prompt_text)\n",
+    "\n",
+    "    while len(last_input) > 0:\n",
+    "        lines.append(last_input)\n",
+    "        last_input = input(prompt_text)\n",
+    "\n",
+    "    return lines\n",
     "\n",
     "def write_lines_to_file(lines, filename):\n",
     "    # Fügen Sie hier Ihren Code ein.\n",
-    "    pass\n",
+    "    with open(filename, 'w') as outfile:\n",
+    "        for line in lines:\n",
+    "            outfile.write(line + '\\n')\n",
     "\n",
     "def copy_textfile_reversed(text_filename, cpy_filename):\n",
     "    # Fügen Sie hier Ihren Code ein.\n",
-    "    pass\n",
+    "    with open(text_filename, 'r') as file:\n",
+    "        lines = file.readlines()\n",
+    "    \n",
+    "    with open(cpy_filename, 'w') as file:\n",
+    "        for line in lines[::-1]:\n",
+    "            file.write(line.strip()[::-1] + '\\n')\n",
     "\n",
     "def output_files_together(filename1, filename2):\n",
     "    # Fügen Sie hier Ihren Code ein.\n",
-    "    pass\n",
+    "    with open(filename1, 'r') as file1:\n",
+    "        with open(filename2, 'r') as file2:\n",
+    "            for line1, line2 in zip(file1, file2):\n",
+    "                print(line1.strip())\n",
+    "                print(line2.strip())\n",
+    "\n",
     "\n",
     "lines = input_lines('Geben Sie einen Text ein: ')\n",
     "write_lines_to_file(lines, 'eingaben.txt')\n",
-    "copy_textfile_reversed('eingabe.txt', 'umgekehrte_eingaben.txt')\n",
+    "copy_textfile_reversed('eingaben.txt', 'umgekehrte_eingaben.txt')\n",
     "output_files_together('eingaben.txt', 'umgekehrte_eingaben.txt')"
    ]
   },