1. a) Faça um programa que escolha aleatoriamente um número. Se ele for par, desenhe um quadrado; se for ímpar, desenhe um círculo (ou polígono).
    b) Faça um programa que escolha aleatoriamente um número. Se ele for par, avance 1 unidade com o forward(); se for ímpar, gire 1 grau para direita com right(). Repita esse trecho de código 3 mil vezes.
    c) Altere o programa anterior para avançar x unidades e girar y graus, onde x e y são número aleatórios.

Passo 1

O enunciado pede três programas separados:
(a) Escolher um número aleatório; se for par desenhar um quadrado, se for ímpar desenhar um círculo (ou polígono).
(b) Escolher um número aleatório; se for par, avançar 1 unidade com forward(); se for ímpar, girar 1^\circ com right(). Repetir esse trecho 3000 vezes.
(c) Alterar o programa do item (b) para que, em vez de sempre usar 1, se avance x unidades e se gire y graus, onde x e y são números aleatórios (supõe-se que x e y sejam gerados a cada iteração).
Informações relevantes dadas:
  • Precisamos decidir e gerar números aleatórios.
  • Precisamos testar paridade (par/ímpar) do número sorteado.
  • Usaremos comandos de desenho como forward(), right(), circle() (assumo uso da biblioteca turtle do Python).
  • No item (b) foi informado repetir o trecho 3000 vezes.
  • No item (c) x e y devem ser aleatórios; vou gerar x como distância e y como ângulo por iteração.

Passo 2

Entendendo como gerar números aleatórios (aula rápida): em Python usamos o módulo random. A função mais comum é random.randint(a, b), que retorna um inteiro aleatório entre a e b, inclusive. Exemplo:
\texttt{n = random.randint(1, 100)}
cria um inteiro n entre 1 e 100. Use isso para escolher o número cuja paridade vamos testar. Se você quiser números reais (com casas decimais) use random.uniform(a, b).

Passo 3

Entendendo paridade (aula rápida): para saber se um inteiro n é par ou ímpar usamos o resto da divisão por 2. Em matemática escrevemos n \bmod 2; em Python usamos o operador %. A condição é:
  • n é par se n \bmod 2 = 0 (em Python: n % 2 == 0).
  • n é ímpar se (n \bmod 2 = 1` (em Python: n % 2 == 1).
Exemplo em Python:
\texttt{if n \% 2 == 0:}
significa “se n for par”.)

Passo 4

Noções básicas do turtle (aula prática): os comandos que vamos usar:
  • turtle.Turtle() cria o objeto de desenho.
  • forward(d) ou fd(d) anda d unidades para frente.
  • right(a) gira a^\circ para a direita.
  • circle(r) desenha um círculo de raio r.
  • speed(...), hideturtle(), tracer(0,0) e update() ajudam a acelerar o desenho para muitos passos (útil no item (b) e (c)).
  • turtle.done() encerra a janela (ou turtle.mainloop()).
Vamos sempre colocar turtle.speed('fastest') ou turtle.tracer(0,0) quando repetirmos muitas vezes (como 3000 iterações) para não ficar lento.

Passo 5

Construindo o programa do item (a) passo a passo:
  1. Importar módulos: random para números aleatórios e turtle para desenhar.
  2. Criar a tartaruga: t = turtle.Turtle().
  3. Sortear um inteiro n, por exemplo entre 1 e 100.
  4. Testar paridade com n % 2 == 0.
  5. Se par: desenhar um quadrado. Como desenhar um quadrado? Um quadrado tem 4 lados iguais; cada canto vira 90^\circ. Em código:
    • repetir 4 vezes: forward(size) e right(90).
  6. Se ímpar: desenhar um círculo com circle(radius) ou um polígono aproximando um círculo. Aqui uso circle(radius) para ficar simples.
Explico os parâmetros: size é o comprimento do lado do quadrado; radius é o raio do círculo. Você pode ajustar para caber na tela.

Passo 6

Código explicativo do item (a):
  • O código abaixo está pronto para copiar e executar em Python (versão padrão com turtle):
# (a) sorteia um número; par -> quadrado, ímpar -> círculo
import random
import turtle

t = turtle.Turtle()
t.speed('fastest')  # acelerar desenho

n = random.randint(1, 100)  # sorteia n entre 1 e 100
print("Número sorteado:", n)

if n % 2 == 0:
    size = 100  # comprimento do lado do quadrado (ajuste se quiser)
    for _ in range(4):
        t.forward(size)
        t.right(90)
else:
    radius = 50  # raio do círculo
    t.circle(radius)

turtle.done()
Observações didáticas: a linha if n % 2 == 0: testa a paridade; o laço for _ in range(4): repete quatro lados; t.right(90) vira 90^\circ. Simples assim.

Passo 7

Construindo o programa do item (b) passo a passo:
  1. Queremos repetir um trecho 3000 vezes. Em Python: for i in range(3000):.
  2. A cada iteração, sorteamos um inteiro n (por exemplo entre 1 e 100).
  3. Se n for par (n % 2 == 0) avançamos 1 unidade com t.forward(1); se for ímpar giramos 1 grau com t.right(1).
  4. Como são muitas iterações, use turtle.tracer(0, 0) para desligar o desenho automático e turtle.update() ao final para mostrar tudo de uma vez; também esconder a tartaruga com hideturtle() e usar speed('fastest') para performance.
Dica visual: com passos tão pequenos ( 1) as mudanças são sutis; você pode aumentar a unidade para ver mais claramente, mas seguirei o pedido literal.

Passo 8

Código explicativo do item (b):
# (b) 3000 iterações: se número aleatório for par -> forward(1), se ímpar -> right(1)
import random
import turtle

t = turtle.Turtle()
t.hideturtle()
t.speed('fastest')
turtle.tracer(0, 0)  # desliga atualização automática para ficar rápido

for i in range(3000):  # repetir 3000 vezes
    n = random.randint(1, 100)
    if n % 2 == 0:
        t.forward(1)
    else:
        t.right(1)

turtle.update()  # desenha tudo de uma vez
turtle.done()
Explicação: cada iteração decide mover ou girar 1; o caminho gerado pode ser uma linha ondulada/espiral dependendo das sequências de par/ímpar.

Passo 9

Construindo o programa do item (c) passo a passo:
  1. Mantemos a estrutura do item (b) com for i in range(3000):.
  2. Em cada iteração sorteamos três números:
    • n: para decidir par/ímpar (como antes).
    • x: distância de avanço quando n for par.
    • y: ângulo de giro quando n for ímpar.
  3. Decisões:
    • Se n % 2 == 0: t.forward(x).
    • Caso contrário: t.right(y).
  4. Defina intervalos razoáveis para x e y. Por exemplo:
    • x entre 1 e 10 unidades (random.randint(1, 10)).
    • y entre 1^\circ e 90^\circ (random.randint(1, 90)).
      Você pode mudar estes intervalos para efeitos visuais diferentes. Também pode usar random.uniform(a, b) se quiser distâncias ou ângulos não inteiros (floats).

Passo 10

Código explicativo do item (c):
# \text{(c)} 3000 iterações: sorteia n para par/ímpar; se par -> forward(x), se ímpar -> right(y)
import random
import turtle

t = turtle.Turtle()
t.hideturtle()
t.speed('fastest')
turtle.tracer(0, 0)

for i in range(3000):
    n = random.randint(1, 100)      # decide paridade
    x = random.randint(1, 10)       # distância (unidades) quando for par
    y = random.randint(1, 90)       # ângulo (graus) quando for ímpar

    if n % 2 == 0:
        t.forward(x)
    else:
        t.right(y)

turtle.update()
turtle.done()
Variação com números reais (floats), se preferir movimentos menos “em degraus”:
# variação: x e y como floats
import random, turtle
t = turtle.Turtle()
t.hideturtle()
t.speed('fastest')
turtle.tracer(0, 0)

for i in range(3000):
    n = random.randint(1, 100)
    x = random.uniform(0.5, 10.0)    # float entre 0.5 e 10.0
    y = random.uniform(0.5, 180.0)   # float entre 0.5 e 180.0

    if n % 2 == 0:
        t.forward(x)
    else:
        t.right(y)

turtle.update()
turtle.done()

Passo 11

Dicas finais e testes rápidos:
  • Se o desenho parecer muito pequeno, aumente os intervalos de x ou diminua o número de iterações.
  • Para depurar, reduza range(3000) para range(50) e coloque print()s para ver os valores de n, x e y.
  • Se quiser resultados reproduzíveis, use random.seed(s) com um inteiro s fixo antes de sortear, assim a sequência aleatória será a mesma em cada execução.
  • Experimente alterar os intervalos de x e y para ver padrões interessantes: por exemplo, y sempre múltiplo de 90^\circ gera formas ortogonais; y em torno de 137^\circ pode criar curvas bonitas (número áureo relacionado a phyllotaxis).
Você consegue rodar cada um dos programas copiando o código para um arquivo .py e executando com Python. Vai dar tudo certo — começa com o (a), depois (b) e por último (c). Boa sorte e, se travar, me manda o erro que eu te explico passo a passo.

Resposta

(a)
# (a) sorteia um número; par -> quadrado, ímpar -> círculo
import random
import turtle

t = turtle.Turtle()
t.speed('fastest')  # acelerar desenho

n = random.randint(1, 100)  # sorteia n entre 1 e 100
print("Número sorteado:", n)

if n % 2 == 0:
    size = 100  # comprimento do lado do quadrado (ajuste se quiser)
    for _ in range(4):
        t.forward(size)
        t.right(90)
else:
    radius = 50  # raio do círculo
    t.circle(radius)

turtle.done()
(b)
# (b) 3000 iterações: se número aleatório for par -> forward(1), se ímpar -> right(1)
import random
import turtle

t = turtle.Turtle()
t.hideturtle()
t.speed('fastest')
turtle.tracer(0, 0)  # desliga atualização automática para ficar rápido

for i in range(3000):  # repetir 3000 vezes
    n = random.randint(1, 100)
    if n % 2 == 0:
        t.forward(1)
    else:
        t.right(1)

turtle.update()  # desenha tudo de uma vez
turtle.done()
(c)
# \text{(c)} 3000 iterações: sorteia n para par/ímpar; se par -> forward(x), se ímpar -> right(y)
import random
import turtle

t = turtle.Turtle()
t.hideturtle()
t.speed('fastest')
turtle.tracer(0, 0)

for i in range(3000):
    n = random.randint(1, 100)      # decide paridade
    x = random.randint(1, 10)       # distância (unidades) quando for par
    y = random.randint(1, 90)       # ângulo (graus) quando for ímpar

    if n % 2 == 0:
        t.forward(x)
    else:
        t.right(y)

turtle.update()
turtle.done()

Exercícios relacionados