pascal

pantoflicek_spirala.py

+import turtle
+from tkinter import simpledialog as sd
+def draw_inward_square_spiral(my_turtle, length, decrement, level):
+    if level == 0 or length <= 0:
+        return
+    for _ in range(4):
+        my_turtle.forward(length)
+        my_turtle.right(90)
+        length -= decrement
+    draw_inward_square_spiral(my_turtle, length, decrement, level - 1)
+
+
+def main():
+    my_turtle = turtle.Turtle()
+    my_win = turtle.Screen()
+    my_win.bgcolor("white")
+
+    level = sd.askinteger("recursion","depth of recursion : ",minvalue = 1)
+    length = 300  # Initial length of the side of the square
+    decrement = 10  # Amount by which each subsequent side length decreases
+
+    draw_inward_square_spiral(my_turtle, length, decrement, level)
+
+    my_win.exitonclick()
+main()
\ No newline at end of file

pantoflicek_strom.py

+import turtle
+import tkinter
+from tkinter import simpledialog as sd
+
+def draw_branch(branch_length, levels, t,):
+    if levels == 0:
+        return
+    if branch_length > 5:
+        t.forward(branch_length)
+        t.right(30)
+        draw_branch(branch_length * 0.7, levels - 1, t)
+        t.left(60)
+        draw_branch(branch_length * 0.7, levels - 1, t)
+        t.right(30)
+        t.backward(branch_length)
+
+
+def main():
+    t = turtle.Turtle()
+    my_win = turtle.Screen()
+    t.left(90)
+    t.up()
+    t.backward(100)
+    t.down()
+    t.color("green")
+
+    levels = sd.askinteger("recursion","depth of recursion : ",minvalue = 1)
+    draw_branch(100, levels, t)
+
+    my_win.exitonclick()
+
+
+main()
\ No newline at end of file

pantoflicek_trojuhelnik.py

+import turtle
+from tkinter import simpledialog as sd
+def draw_triangle(vertices, my_turtle):
+    my_turtle.fillcolor("white")
+    my_turtle.penup()
+    my_turtle.goto(vertices[0][0], vertices[0][1])
+    my_turtle.pendown()
+    my_turtle.begin_fill()
+    my_turtle.goto(vertices[1][0], vertices[1][1])
+    my_turtle.goto(vertices[2][0], vertices[2][1])
+    my_turtle.goto(vertices[0][0], vertices[0][1])
+    my_turtle.end_fill()
+
+def get_mid(p1, p2):
+    return [(p1[0] + p2[0]) / 2, (p1[1] + p2[1]) / 2]
+
+def sierpinski(vertices, level, my_turtle):
+
+    draw_triangle(vertices, my_turtle)
+    if level > 0:
+        sierpinski([vertices[0],
+                    get_mid(vertices[0], vertices[1]),
+                    get_mid(vertices[0], vertices[2])],
+                   level-1, my_turtle)
+        sierpinski([vertices[1],
+                    get_mid(vertices[0], vertices[1]),
+                    get_mid(vertices[1], vertices[2])],
+                   level-1, my_turtle)
+        sierpinski([vertices[2],
+                    get_mid(vertices[2], vertices[1]),
+                    get_mid(vertices[0], vertices[2])],
+                   level-1, my_turtle)
+
+def main():
+    my_turtle = turtle.Turtle()
+    my_win = turtle.Screen()
+    my_win.bgcolor("white")
+
+    vertices = [[-200, -100], [0, 200], [200, -100]]
+    level = sd.askinteger("recursion","depth of recursion : ",minvalue = 1)
+    my_turtle.speed = 100 * level
+    sierpinski(vertices, level, my_turtle)
+    my_win.exitonclick()
+
+main()

pascal-pantofle.py

+def generate_pascal_triangle(n):
+    triangle = [[1 for _ in range(i+1)] for i in range(n)]
+    for i in range(2, n):
+        for j in range(1, i):
+            triangle[i][j] = triangle[i-1][j-1] + triangle[i-1][j]
+    return triangle
+
+def print_pascal_triangle(triangle):
+    for row in triangle:
+        print(' '.join(str(num) for num in row))
+
+n = int(input("Enter the number of levels: "))
+triangle = generate_pascal_triangle(n)
+print_pascal_triangle(triangle)
\ No newline at end of file