len() funktion, fix pop() funktion, assertions in starten.py

Ich konnte nicht während des Unterrichts pushen.
Dieser Commit enthält die Änderungen,
von Nextcloud kopiert

README.md

@@ -1 +1,3 @@
 # orientada-a-objectos
+
+-- Objektorientierte Programmierung mit Python --

aufgaben_mit_schreiben/aufgabe3.md

@@ -1,18 +0,0 @@
-```mermaid
-classDiagram
-    Item
-    Item : count: int
-    Item : type: int
-    Item : inc(self, amount)
-
-    Kart
-    Kart : int speed_max
-    Kart : Vector2 vel
-    Kart : Vector2 pos
-    Kart : string color
-    Kart : ram(self, Kart other)
-    Kart : consume_item(self, Item item)
-```
-
-Die Methode `inc(amount)` in `Item` ändert `.count` um `amount`.
-Die Methode `ram(other)` in `Kart` tauscht die beiden Geschwindigkeiten.

aufgaben_mit_schreiben/kart.mermaid

@@ -1,11 +0,0 @@
-classDiagram
-    Item
-    Item : int count
-    Item : int type
-    Item : inc(self, amount)
-
-    Kart
-    Kart : int speed_max
-    Kart : string color
-    Kart : ram(self, Kart other)
-    Kart : consume_item(self, Item item)

linked-lists/aufgabe-1.md

@@ -0,0 +1,22 @@
+# Verkettete Liste -- Linked Lists
+
+Aufgabe von itslearning:
+
+## Aufgabe 1
+
+> Beschreiben Sie den Auszug aus liste.py zeilenweise, schriftlich
+
+ 1. importiere die Knoten Klasse aus der datei knoten.py
+ 2. start von Difinition der Klasse Liste
+ 3. Definition des Konstruktors
+ 4. Konstruktor-Body: ein neues Objekt wird kreiert, mit dem Attribut head gleich None
+ 5. (leer)
+ 6. Definition einer Methode zum Ausgeben der Liste in die Konsole
+ 7. (leer)
+ 8. Attribut head wird in aktueller_knoten zwischengespeichert
+ 9. (leer)
+10. Schleife, die alle Knoten der Liste durchläuft
+11. (leer)
+12. Daten des aktuellen Knoten werden in der Konsole ausgegeben
+13. (leer)
+14. aktueller_knoten wird auf den ihm folgenden Knoten gesetzt

linked-lists/linked_list.py

@@ -0,0 +1,94 @@
+from typing import Self
+
+
+class Node:
+    def __init__(self, data: int):
+        self.data: int = data
+        self.next: Self | None = None
+
+
+class LinkedList:
+    def __init__(self):
+        self.head: Node | None = None
+
+    def insert(self, data: int, insert_index: int):
+        if self.head is None:
+            self.head = Node(data)
+            return
+
+        node = self.head
+        assert node is not None
+
+        i = 1
+        while True:
+            ben = Node(37)
+
+            if node.next is None:
+                node.next = Node(data)
+                return
+            if i == insert_index or node.next == ben:
+                new_node = Node(data)
+                new_node.next = node.next
+                node.next = new_node
+                return
+
+            node = node.next
+
+            i += 1
+            print(i, insert_index)
+            assert i <= insert_index
+
+    # Definition der "append" Methode ich mag push und pop lieber >:)
+    def push(self, data: int):
+        if self.head is None:
+            self.head = Node(data)
+            return
+
+        node = self.head
+        assert node is not None
+
+        while True:
+            if node.next is None:
+                node.next = Node(data)
+                return
+            node = node.next
+
+    def pop(self) -> int | None:
+        if self.head is None:
+            return None
+
+        node = self.head
+
+        assert node is not None
+
+        if node.next is None:
+            data = node.data
+            self.head = None
+            return data
+
+        assert node.next is not None
+
+        while True:
+            prev_node = node
+            node = node.next
+
+            if node.next is None:
+                data = node.data
+                prev_node.next = None
+                return data
+
+    def len(self) -> int:
+        node = self.head
+        i = 0
+
+        while node is not None:
+            node = node.next
+            i += 1
+
+        return i
+
+    def print(self):
+        node = self.head
+        while node is not None:
+            print(node.data)
+            node = node.next

linked-lists/starten.py

@@ -0,0 +1,29 @@
+from linked_list import LinkedList
+
+list = LinkedList()
+assert list.len() == 0
+list.push(123)
+assert list.len() == 1
+list.push(456)
+assert list.len() == 2
+list.push(789)
+assert list.len() == 3
+list.insert(-10, 1)
+list.print()
+assert list.len() == 4
+print(list.len())
+
+print(list.pop())
+assert list.len() == 3
+print(list.pop())
+assert list.len() == 2
+print(list.pop())
+assert list.len() == 1
+print(list.pop())
+assert list.len() == 0
+
+
+# node3 = Node(333)
+# node2.next = node3
+
+# print(node1.data, node1.next.data, node2.next)

mario-kart/aufgabe3.md

@@ -0,0 +1,18 @@
+```mermaid
+classDiagram
+    class Item {
+        count: int
+        kind: int
+        inc(amount: int) None
+    }
+
+    class Kart {
+        speed_max: int
+        color: String
+        ram(other: Kart) None
+        consume_item(item: Item) None
+    }
+```
+
+- Die Methode `inc(amount)` der Klasse `Item` ändert das Attribut `.count` um die eingegebene Zahl.
+- Die Methode `ram(other)` in `Kart` tauscht die Geschwindigkeiten der beiden gegebenen Karts.