22.09

turtlerekursion.py

@@ -1,9 +1,18 @@
 import turtle
+import sys
+sys.setrecursionlimit(1000000)
 
 def draw_square(t, size):
-    for i in range(4):
-        t.forward(size)
-        t.left(90)
+    
+    t.forward(size / 2)
+    t.left(90)
+    t.forward(size)
+    t.left(90)
+    t.forward(size)
+    t.left(90)
+    t.forward(size)
+    t.left(90)
+    t.forward(size / 2)
 
 # draw_square(turtle, 100)
 
@@ -28,38 +37,69 @@ def draw_recursive_tree(t, size, größe):
     draw_recursive_tree(t, size * 0.7, größe - 1)
     t.left(30)
     t.backward(size)
-turtle.left(90)
+#turtle.left(90)
 #draw_recursive_tree(turtle, 100, 5)
+
+
 # Ich möchte einen Code schreiben der erst ein 64 Quadrat zeichnet 
 # und dann rekursiv immer zwei halb so große Quadrate oben links und rechts über das ursprüngliche Quadrat zeichnet. 
 # Bis die Seitenlänge = 1 ist.
-def draw_recursive_squares(t, length):
+# Es soll nur eine Turtle geben, die wiederverwendet wird.
+
+
+def draw_recursive_squares(t, length, x, y):
     if length < 1:
+        draw_recursive_squares(t, length / 2, x - length * 2.5, y + length * 2.5)
         return
-
-    draw_square(t, length)
-
-    # Position des aktuellen Quadrats
     x = t.xcor()
     y = t.ycor()
 
-    # Turtle für oben links
-    left_turtle = t.clone()
-    left_turtle.penup()
-    left_turtle.goto(x - length * 1.5, y + length)
-    left_turtle.pendown()
+        
+    t.penup()
+    t.goto(x + length * 1.5 , y + length * 2.5)
+    t.pendown()
+    
+    
+    draw_square(t, length)
+    
+    
 
-    # Turtle für oben rechts
-    right_turtle = t.clone()
-    right_turtle.penup()
-    right_turtle.goto(x + length , y + length)
-    right_turtle.pendown()
+    draw_recursive_squares(t, length / 2, x - length * 2.5, y + length * 2.5)
+#square = draw_square(turtle, 64)    
+#turtle.speed(10)
+#draw_recursive_squares(turtle, 32, 0,0)
 
-    # Beide Äste rekursiv weiterführen
-    draw_recursive_squares(left_turtle, length / 2)
-    draw_recursive_squares(right_turtle, length / 2)
 
-turtle.speed(10)
-draw_recursive_squares(turtle, 64)
+t = turtle.Turtle()
+t.speed(2000)
+#t.speed(0)
 
-turtle.done()
+def square_recursion(t, length, x, y):
+    if length < 8:
+        return
+    print(length)
+    t.penup()
+    t.goto(x, y)
+    t.pendown()
+    draw_square(t, length)
+    square_recursion(t, length / 2, x - length * 1.5, y + length * 1.5)
+    square_recursion(t, length / 2, x + length * 1.5, y + length * 1.5)
+
+
+#square_recursion(t, 64, 0, 0) 
+#turtle.done()
+
+# Jetzt möchte ich eine Kochkurve zeichnen, die rekursiv immer kleinere Dreiecke zeichnet.
+def draw_koch_Kurve(t, length, depth):
+    if depth == 0:
+        t.forward(length)
+        return
+    t.forward(length / 3)
+    t.left(60)
+    draw_koch_Kurve(t, length / 3, depth - 1)
+    t.right(120)
+    draw_koch_Kurve(t, length / 3, depth - 1)
+    t.left(60)
+    draw_koch_Kurve(t, length / 3, depth - 1)
+
+draw_koch_Kurve(t, 300, 10)