Polígonos Estrelados Regulares - Python

Essa é mais uma postagem com um código em Python. Dessa vez eu fiz um código para gerar polígonos estrelados regulares. Estudo programação quando posso, então, acredito que esse código pode ser, com certeza, melhorado. Sinta-se à vontade para fazer comentários, dar sugestões e também de usar o código onde quiser. Esse código pode ser usado para mostrar o que podemos fazer com Python a estudantes de matemática e computação. Pode ser usado também como um ótimo exercício para quem está estudando Python.

Antes do vermos o código, vamos entender o que é um polígono estrelado regular. 

Chamamos de poligonal uma sequência finita de segmentos de reta que são desenhados de forma que, onde um segmento acaba, outro começa. Uma poligonal é chamada simples quando os segmentos que a formam não se cruzam. Uma poligonal é chamada fechada quando o ponto inicial do primeiro segmento de reta coincide com o ponto final do último segmento de reta na poligonal. 

Definimos um polígono estrelado, formalmente, da seguinte forma: um polígono estrelado é uma poligonal não simples fechada, tal que, para cada três segmentos consecutivos quaisquer, os dois segmentos extremos estão no mesmo semiplano em relação ao segmento do meio. Tais polígonos são classificados como regulares se possuem todos os lados e ângulos congruentes.

Informalmente, um polígono estrelado regular é uma estrela onde os segmentos que a formam e os ângulos em sua pontas são congruentes (possuem a mesma medida).

Podemos construir um polígono estrelado regular de $n > 3$ pontas seguindo os passos:

1. Construa um círculo de raio qualquer e o divida em $n$ partes iguais;

2. Calcule $a = \displaystyle\frac{n}{2}$;

3. Liste os números inteiros $k$ tais que $2 < k \leq a$;

4. Determine o números $k$ tais que $\mbox{mdc}(k,n) = 1$;

5. A quantidade de números $k$ tais que $\mbox{mdc}(k,n) = 1$ é a quantidade de polígonos estrelados distintos que existem com $n$ pontas;

6. Ligando os pontos da divisão do círculo feita no passo 1, de $k$ em $k$, para cada $k$, vamos obter todos os polígonos estrelados regulares com $n$ pontas (paramos de ligar os pontos quando chegamos no ponto inicial, ou seja, ao ligarmos os pontos de $k$ em $k$, os pontos inicial e final devem coincidir).

Polígonos estrelados em Python

Esse é o código:

# Importando os pacotes
import math
from numpy import linspace
import matplotlib.pyplot as plt

# Introdução do app

print(10*'*', 'Bem vindo ao Gerador de Polígonos Estrelados Regulares', 10*'*')

print('\nVocê sabe o que é um polígono estrelado regular?')

texto1 = '\nUm polígono estrelado é uma poligonal (sequência de segmentos de reta), não simples \
        \n(os segmentos se cruzam) fechada (os pontos inicial e final são os mesmos), tal que \
\npara cada três segmentos consecutivos quaisquer, os dois segmentos extremos estão \
 \nno mesmo semiplano em relação ao segmento do meio. Tais polígonos são classificados \
\ncomo regulares se possuem todos os lados e ângulos congruentes.'

print(texto1)

texto2 = '\nA seguir, digite um número de pontas para ver quantos polígonos estrelados ' \
         'existem com esse número de pontas e vizualizá-los.'

print(texto2)

# Função para calcular o mdc
def mdc(a,b):
    if a % b == 1:
        return 1
    else:
        r = -1
        while r != 0:
            r = a % b
            a = b
            b = r
        return a

# Função para transformar grau em radiano
def rad(x):
    return (x * math.pi) / 180

# Função com os passos
def lista_passos(x,y):
    passos = []
    lista = list(range(2, x + 1))
    for i in lista:
        if mdc(y, i) == 1:
            passos.append(i)
    return passos

# Função para desenhar as estrelas
def plotagem(lista_x, lista_y):
    fig, ax = plt.subplots(figsize=(5,5))
    circle = plt.Circle((0, 0), 1, fill=False, color='red')
    ax.add_artist(circle)
    plt.plot(lista_x, lista_y)
    plt.ylim(-1.1,1.1)
    plt.xlim(-1.1,1.1)
    plt.show()

# Função para trocar a ordem dos pontos
def restos(passo,y):
    lista = list(range(0, passo * y + 1, passo))
    lista_restos = [i % y for i in lista]
    return lista_restos

def main():
    pontas = 0
    cont = False
    while cont == False:
        try:
            pontas = int(input('\nDigite o número de pontas (inteiro maior que 0): '))
            if pontas > 0:
                cont = True
            else:
                print('Você digitou um valor inválido. Tente novamente')
        except ValueError:
            print('Você digitou um valor inválido. Tente novamente')
    div_circulo = linspace(0, 360, num=pontas + 1)
    max = math.floor(pontas / 2)
    lista_de_passos = lista_passos(max, pontas)
    quantidade_estrelados = len(lista_de_passos)
    if quantidade_estrelados == 0:
        print('\nNão é possível construir um polígono estrelado regular com ' + str(pontas) + ' pontas.')
    else:
        print('\nExiste(m) ' + str(quantidade_estrelados) + ' polígono(s) estrelado(s) regular(es) com ' + str(pontas) + ' pontas.')
        input('\nPressione qualquer tecla para vizualizá-los.')
        pontos_x = [math.cos(i) for i in [rad(j) for j in div_circulo]]
        pontos_y = [math.sin(i) for i in [rad(j) for j in div_circulo]]
        for i in lista_passos(max, pontas):
            aux_x = [pontos_x[j] for j in restos(i, pontas)]
            aux_y = [pontos_y[j] for j in restos(i, pontas)]
            plotagem(aux_x, aux_y)

main()

Gostou dessa postagem? Foi útil para você? Tem alguma dúvida? Deixe um comentário.