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)

main.py

@@ -1,13 +0,0 @@
-import pygame
-
-from kart import Kart
-
-Vec2 = pygame.Vector2
-
-player = Kart(
-    name = "epsilon",
-    pos = Vec2(0, 0),
-    vel = Vec2(2, 0),
-    dir = 0,
-    speed_max = 10,
-)

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.

mario-kart/input.py

@@ -3,7 +3,7 @@ import pygame
 class Input:
     def __init__(self):
         self.left: bool = False
-        self.right: bool = True
+        self.right: bool = False
         self.down: bool = False
         self.up: bool = False
         self.close: bool = False
@@ -24,13 +24,13 @@ class Input:
                     self.down = True
             if event.type == pygame.KEYUP:
                 if event.key == pygame.K_LEFT:
-                    self.left = True
+                    self.left = False
                 if event.key == pygame.K_RIGHT:
-                    self.right = True
+                    self.right = False
                 if event.key == pygame.K_UP:
-                    self.up = True
+                    self.up = False
                 if event.key == pygame.K_DOWN:
-                    self.down = True
+                    self.down = False
 
     def horizontal(self) -> float:
         return self.right - self.left

mario-kart/kart.py

@@ -23,11 +23,12 @@ class Kart:
     def tick(self, input: Input):
         input_x = input.horizontal()
         input_y = input.vertical()
-        assert abs(input_x) < 1
+        assert abs(input_x) <= 1
-        assert abs(input_y) < 1
+        assert abs(input_y) <= 1
 
         acc_amount = input_y * 2
         self.vel += Vec2(acc_amount, 0).rotate(self.dir)
+        self.vel *= 0.9
         steer = input_x * 2
         self.dir += steer
 
@@ -44,8 +45,8 @@ class Kart:
 
     def consume_item(self, item: Item):
         if item.kind == items.ITEM_BANANA:
-            self.speed_max += 1
+            self.speed_max += 0.01
         elif item.kind == items.ITEM_BANANA:
-            self.speed_max -= 1
+            self.speed_max -= 0.01
 
         self.speed_max = clamp(self.speed_max, 0, 100)

mario-kart/main.py

@@ -0,0 +1,55 @@
+import pygame
+
+from input import Input
+from kart import Kart
+
+Vec2 = pygame.Vector2
+
+kart_image = pygame.surface.Surface((10, 10))
+
+player = Kart(
+    name = "epsilon",
+    pos = Vec2(0, 0),
+    vel = Vec2(2, 0),
+    dir = 0,
+    speed_max = 3,
+)
+
+clock = pygame.Clock()
+
+def main():
+    pygame.init()
+
+    input = Input()
+    width, height = 800, 600
+    screen = pygame.display.set_mode((width, height))
+    pygame.display.set_caption("Pygame Window Example")
+
+    kart = Kart(
+        name = "jerry",
+        pos = Vec2(0.0, 0.0),
+        vel = Vec2(0.0, 0.0),
+        dir = 0.0,
+        speed_max = 10.0
+    )
+
+
+    while not input.close:
+        input.poll()
+        kart.tick(input)
+
+        # Draw game:
+        screen.fill((0, 125, 0))
+        pygame.draw.rect(screen, (255, 0, 0), pygame.Rect(kart.pos.x - 5, kart.pos.y - 5, 5, 5))
+        pygame.draw.line(screen, (0, 0, 0), kart.pos, kart.pos + Vec2(100, 0).rotate(kart.dir))
+
+        pygame.draw.rect(screen, (0, 0, 255), pygame.Rect(kart.pos.x - 5, kart.pos.y - 5, 5, 5))
+        pygame.draw.line(screen, (0, 0, 0), kart.pos, kart.pos + Vec2(100, 0).rotate(kart.dir))
+
+        pygame.display.flip()
+
+        clock.tick(60)
+
+
+if __name__ == "__main__":
+    main()