TP List chainée Polynome

TP Listes Chainées/listechainee.py

@@ -5,7 +5,7 @@ class Node:
 
 
 class ListeChainee:
-    def __init__(self, noeud = None):
+    def __init__(self, noeud=None):
         self.tete = noeud
 
     def add_first(self, data):
@@ -85,3 +85,120 @@ class ListeChainee:
             if current2:
                 current2 = current2.next
         return LC
+
+
+class nodeMonome:
+    def __init__(self, coef, degre):
+        self.coef = coef
+        self.degre = degre
+        self.next = None
+
+    def get_coef(self):
+        return self.coef
+
+    def get_degre(self):
+        return self.degre
+
+
+class polyCreux:
+    def __init__(self, monome=None):
+        self.tete = monome
+
+    def add(self, monome):
+        if self.tete is None:
+            self.tete = monome
+            return
+        if self.tete.degre < monome.degre:
+            monome.next = self.tete
+            self.tete = monome
+            return
+        current = self.tete
+        while current:
+            if current.degre == monome.degre:
+                current.coef += monome.coef
+                return
+            if current.next is None or current.next.degre < monome.degre:
+                monome.next = current.next
+                current.next = monome
+                return
+            current = current.next
+
+    def afficher(self):
+        current = self.tete
+        while current:
+            if current.next is None:
+                if current.degre == 0:
+                    print(f"{current.coef}")
+                    current = current.next
+                elif current.degre == 1:
+                    print(f"{current.coef}X")
+                    current = current.next
+                else:
+                    print(f"{current.coef}X^{current.degre}")
+                    current = current.next
+            else:
+                print(f"{current.coef}X^{current.degre}", end=" + ")
+                current = current.next
+
+    def evaluate(self, x):
+        current = self.tete
+        result = 0
+        while current:
+            result += current.coef * (x ** current.degre)
+            current = current.next
+        return result
+
+    def multiply(self, scalar):
+        current = self.tete
+        while current:
+            current.coef *= scalar
+            current = current.next
+
+    def delete_from_degre(self, degre):
+        current = self.tete
+        if current.degre == degre:
+            self.tete = current.next
+            return
+        while current.next:
+            if current.next.degre == degre:
+                current.next = current.next.next
+                return
+            current = current.next
+
+    def __add__(self, other):
+        current1 = self.tete
+        current2 = other.tete
+        LC = polyCreux()
+        while current1 or current2:
+            degre1 = current1.degre if current1 else -1
+            degre2 = current2.degre if current2 else -1
+            if degre1 == degre2:
+                LC.add(nodeMonome(current1.coef + current2.coef, degre1))
+                current1 = current1.next
+                current2 = current2.next
+            elif degre1 > degre2:
+                LC.add(nodeMonome(current1.coef, degre1))
+                current1 = current1.next
+            else:
+                LC.add(nodeMonome(current2.coef, degre2))
+                current2 = current2.next
+        return LC
+
+    def __sub__(self, other):
+        current1 = self.tete
+        current2 = other.tete
+        LC = polyCreux()
+        while current1 or current2:
+            degre1 = current1.degre if current1 else -1
+            degre2 = current2.degre if current2 else -1
+            if degre1 == degre2:
+                LC.add(nodeMonome(current1.coef - current2.coef, degre1))
+                current1 = current1.next
+                current2 = current2.next
+            elif degre1 > degre2:
+                LC.add(nodeMonome(current1.coef, degre1))
+                current1 = current1.next
+            else:
+                LC.add(nodeMonome(-current2.coef, degre2))
+                current2 = current2.next
+        return LC

TP Listes Chainées/main.py

@@ -1,8 +1,9 @@
-from listechainee import ListeChainee
+from listechainee import ListeChainee, polyCreux, nodeMonome
 
 
 def main():
-    test_listechainee()
+    # test_listechainee()
+    test_polycreux()
 
 
 def test_listechainee():
@@ -39,6 +40,36 @@ def test_listechainee():
     LC5 = LC3 + LC4
     LC5.printLinkedList()
 
+def test_polycreux():
+    pc = polyCreux(nodeMonome(6, 125))
+    pc.add(nodeMonome(4, 125))
+    pc.add(nodeMonome(4, 126))
+    pc.add(nodeMonome(7, 3))
+    pc.add(nodeMonome(9, 1))
+    pc.add(nodeMonome(10, 0))
+    pc.add(nodeMonome(44, 100))
+
+    e = pc.evaluate(1)
+    print(e)
+    e = pc.evaluate(35)
+    print(e)
+
+    pc.afficher()
+    pc.multiply(3)
+    pc.afficher()
+    pc.delete_from_degre(125)
+    pc.afficher()
+
+    pc2 = polyCreux()
+    pc2.add(nodeMonome(2, 125))
+    pc2.add(nodeMonome(4, 101))
+    pc2.add(nodeMonome(4, 1))
+    pc2.add(nodeMonome(7, 0))
+    print("affichage PC2")
+    pc2.afficher()
+    pc = pc - pc2
+    print("affichage pc somme")
+    pc.afficher()
 
 if __name__ == "__main__":
     main()

cléo/fractal.py

@@ -0,0 +1,19 @@
+import turtle
+
+def KochCurve(turtle, l, n):
+    if n == 0:
+        turtle.forward(l)  # Move forward by l units
+    else:
+        l /= n  # Reduce the length of the segment by n
+        KochCurve(turtle, l, n-1)
+        turtle.left(60)
+        KochCurve(turtle, l, n-1)
+        turtle.right(120)
+        KochCurve(turtle, l, n-1)
+        turtle.left(60)
+        KochCurve(turtle, l, n-1)
+
+
+turtle.setup(800, 400)
+KochCurve(turtle, 300, 2)
+turtle.exitonclick()