Drawing a complete graph of equally-spaced points on a circle's circumference with Turtle

Question

I'm writing a function that dots equally-spaced points on the circumference of a circle centered at origin, then draws lines between all points.

I have been messing with this code for a while now and I can not seem to get it to function as intended. I need to make a circle out of points from the given radius and number of points in turtle. This is what I have so far:

from turtle import *

def drawLineSeg (p, q):
    up()
    goto(p)
    down()
    goto(q)

def pntCirc (r, n):
    for i in range(1, n+1):
        up()
        goto(0,0)
        forward(r)
        down()
        dot(10)
        L.append (pos())
        right(360/n)

L = []

def clique (r, n):
    pntCirc (r, n)
    color ('blue')
    for i in range(0, len(L)):
        drawLineSeg (L[0], L[i])
        drawLineSeg (L[1], L[i])
        drawLineSeg (L[2], L[i])
        drawLineSeg (L[3], L[i])
        drawLineSeg (L[4], L[i])
        drawLineSeg (L[5], L[i])
        drawLineSeg (L[6], L[i])
        drawLineSeg (L[7], L[i])
        drawLineSeg (L[8], L[i])
        drawLineSeg (L[9], L[i])
        drawLineSeg (L[10], L[i])
        drawLineSeg (L[11], L[i])
        drawLineSeg (L[12], L[i])
        drawLineSeg (L[13], L[i])
        drawLineSeg (L[14], L[i])
        drawLineSeg (L[15], L[i])
        drawLineSeg (L[16], L[i])
        drawLineSeg (L[17], L[i])
        drawLineSeg (L[18], L[i])
        drawLineSeg (L[19], L[i])
    return

speed(50)
color ('red')
clique (300, 20)
# clique (300, 8)
# clique (300, 16) 
hideturtle()
done()

In the clique function, I have tried using for loops and while loops, which is around what I need to use for this to work; I can't use any more technical stuff like enumerate, numpy, or matplotlib. I need to make this work for any amount of given points, not just the 20 points I tested for. It throws an IndexError when I test for 8 points, for example. How do I do this with one code, not hard-written?

clique (300, 20)
# clique (300, 8)
# clique (300, 16) 

I have, as stated above, hard coded it to give me the full result (this is the full model that I hard coded the function for) when using 20 points, but if I just put in:

for i in range(0, len(L)):
        drawLineSeg (L[0], L[i])

I get this instead.

Any help would be greatly appreciated as I am currently stuck and am not sure how to proceed from here.

Answer 1

Great effort here. What you're drawing is a complete graph. You're very close, only missing an inner loop which is essentially what the hardcoded 20 calls simulates.

We need to find all combinations of points, so the logic is essentially a nested loop:

for each point at index i from 0 to length(points):
    for each other point from index i + 1 to length(points):
        draw a line between the two points

While moving the turtle from the center will work, I'd prefer to compute the points around the circumference of the circle mathematically. The formula for a point is:

x = math.cos(angle_in_radians) * radius + center_x
y = math.sin(angle_in_radians) * radius + center_y

... but the center is assumed to be 0 for our purposes (this is a good thing to make a parameter).

To compute all of the points around the circumference, we can iterate from 0 to 360 degrees in increments of 360 / n (the number of points we want to draw), then convert our angle to radians and plug into the formula. No lists required.

As a cosmetic aside, I'd prefer to avoid from turtle import * which brings in too many functions into the namespace. Better to import turtle, then use the turtle prefix going forward. I'd also prefer to create a Turtle instance and pass it into the function so it's not reliant on global state.

I'd also prefer to use parameters on the function for all of the available knobs. Center x and y would be nice to add.

The final result is:

import math
import turtle

def clique(t, r, n, dotsize=10, dotcolor="red", linecolor="blue"):
    for i in range(n):
        a = 360 / n * i
        x = math.cos(math.radians(a)) * r
        y = math.sin(math.radians(a)) * r
        t.color(linecolor)

        for i in range(i + 1, n):
            a = 360 / n * i
            xx = math.cos(math.radians(a)) * r
            yy = math.sin(math.radians(a)) * r
            t.goto(x, y)
            t.pendown()
            t.goto(xx, yy)
            t.penup()

        t.goto(x, y)
        t.color(dotcolor)
        t.dot(dotsize)

if __name__ == "__main__":
    t = turtle.Turtle()
    t.penup()
    t.speed("fastest")
    clique(t, 200, 7)
    turtle.exitonclick()

Answer 2

I appreciate @ggorlen's circle math approach to a solution (+1), but I think the shortest path from where you are to where you want to be is via a nested loop that draws lines from every point to every other point avoiding null lines (same point) and redundant lines:

from turtle import Screen, Turtle

def drawLineSeg(p, q):
    turtle.goto(p)
    turtle.pendown()
    turtle.goto(q)
    turtle.penup()

def pntCirc(r, n):
    for _ in range(1, n + 1):
        turtle.forward(r)
        turtle.dot(10)

        positions.append(turtle.position())

        turtle.backward(r)
        turtle.right(360 / n)

def clique(r, n):
    pntCirc(r, n)

    turtle.color('blue')

    for start in range(len(positions) - 1):
        for end in range(start + 1, len(positions)):
            drawLineSeg(positions[start], positions[end])

positions = []

screen = Screen()

turtle = Turtle()
turtle.hideturtle()
turtle.color('red')
turtle.speed('fastest')
turtle.penup()

clique(300, 20)

screen.exitonclick()