Teste #1 - TP4

P1

O seguinte programa possui um ou mais erros/omissões. Identifique o(s) erro(s)/omissão(ões)relacionando-o(s) com o conceito de espaço de nomes do python.

def  polar_to_cart_x(r, ang):
    x = r * math.cos(ang)
    return x
if  __name__  == “__main__":
    print(polar_to_cart_x (10, pi/4))

Não é feita a importação do módulo math e devemos usar math.pi e não pi.

P2

Escreva um programa para contar o número de pontos que estão dentro de uma circunferência de raio r centrada em (0, 0). O programa deverá receber o número de pontos atestar (num) e o raio (r) como parâmetros. As coordenadas de cada ponto deverão ser pedidas interativamente ao utilizador. No final, o programa deverá indicar o número de pontos que estão dentro da circunferência.

import math

def dentro(raio, x, y):
    len = math.sqrt(x ** 2 + y ** 2)
    if len <= raio:
        return True
    else:
        return False
    

def conta_dentro_circulo(num, raio):
    num_dentro = 0
    for i in range(num):
        x = eval(input("x: "))
        y = eval(input("y: "))
        
        if dentro(raio, x, y):
            num_dentro = num_dentro + 1
    
    return num_dentro
            
    
if __name__ == "__main__":
    print(conta_dentro_circulo(3, 20))

P3

Usando o módulo turtle, escreva um programa que lhe permita desenhar formas do tipo da ilustrada na Figura. Cada forma é composta por um rectângulo com uma circunferência interna, centrados no mesmo ponto.O raio da circunferência dependerá das dimensões do rectângulo, de acordo com o ilustrado na figura. O programa deverá ser parametrizável de maneira a permitir escolher o número de formas, as dimensões mínima e máxima dos lados dos rectângulos, bem como as posições (x e y) dos mesmos. As coordenadas e dimensões do rectângulo envolvente de cada forma deverão ser geradas aleatoriamente.Soluções modulares serão valorizadas.

import turtle
import random

def rectangulo(xr, yr, lado1, lado2):
    #preparar
    turtle.penup()
    turtle.goto(xr,yr)
    turtle.pendown()
    
    #desenhar
    for i in range(4):
        if i%2 == 0:
            turtle.forward(lado1)
        else:
            turtle.forward(lado2)
        turtle.right(90)
        
def circulo(xc, yc, raio):
    #preparar
    turtle.penup()
    turtle.goto(xc, yc)
    turtle.pendown()
    
    #desenhar
    turtle.circle(raio)
    

def forma_rect_circulo(xf, yf, lado1, lado2):
    #rectangulo
    rectangulo(xf, yf, lado1, lado2)

    #circulo no interior
    raio = min(lado1, lado2) / 2
    xc = xf + lado1/2
    yc = yf - lado2/2 - raio
    circulo(xc, yc, raio)
    
    
def desenha_formas(num, xmin, xmax, ymin, ymax, ladomin, ladomax):
    
    #sortear e desenhar
    for i in range(num):
        xf = random.randint(xmin, xmax)
        yf = random.randint(ymin, ymax)
        lado1 = random.randint(ladomin, ladomax)
        lado2 = random.randint(ladomin, ladomax)
        forma_rect_circulo(xf, yf, lado1, lado2)
    
    
if __name__ == "__main__":
    turtle.hideturtle()   
    desenha_formas(5, -300, 300, -300, 300, 50, 150)
    turtle.exitonclick()

Exercícios de Programação Descendente (II)

Nas aulas foi colocado o problema de visualizar na forma de um histograma o resultado de uma experiência de lançamento de um dado. O histograma permitia saber quantas vezes saiu cada número. Pretende-se algo como a figura ilustra.

Vamos novamente tentar perceber se podemos dividir o problema em sub-problemas de modo a tornar a nossa missão mais fácil. Perante o anunciado é evidente que temos dois sub-problemas: (1) efectuar a experiência contando o número de vezes que saiu cada número e, (2) usar essa informação para construir o histograma. As condições do enunciado forçam a usar o modulo turtle para a visualização! É clara a existência de uma dependência entre os dois sub-problemas, pelo que antes de começarmos a resolver em separado cada um deles precisamos definir o seu interface. Uma opção que se impõe é que o sub-problema (1) depende do número de lançamentos n para construir um tuplo (n1,n2,n3,n4,n5,n6), com ni igual ao número de vezes que saiu o número i, e n1+n2+n3+n4+n5+n6 = n. A escolha de um tuplo é natural pois precisamos de um contentor, com a função de memória. Tomadas estas decisões, podemos passar a concretização do programa.

import turtle

def dados_histo(n):
    # experiência de lançamentos
    res = lanca_dado(n)
    # visualizaçao
    histograma(res)
    
    
def lanca_dado(n):
    pass


def histograma(res):
    pass


if __name__ == '__main__':
    n = 100
    dados_histo(n)

Vamos começar por resolver o segundo sub-problema. Para tal, vamos de novo decompor o sub-problema em sub-problemas. Aqui temos, pelo menos, duas opções: (a) numa leitura “vertical”, temos quatro sub-problemas: escreve os números de 1 a 6, desenha um traço, desenha os rectângulos e escreve os números correspondentes aos números de vezes que saiu cada número; (b) numa leitura “horizontal, temos seis sub-problemas idênticos: escrever um número, desenhar um traço, desenhar uma coluna e, novamente, escrever um número. A nossa escolha vai ser a segunda, pois é aquela que nos permite ter mais graus de liberdade.

import turtle

def dados_histo(n):
    # experiência de lançamentos
    res = lanca_dado(n)
    # visualizaçao
    histograma(res)
    
    
def lanca_dado(n):
    pass

def histograma(res):
    posx = -100
    posy = 0
    comp_linha = 80
    for i,alt in enumerate(res):
        # desenha caso i
        desenha(i+1,alt,posx,posy,comp_linha)
        # define parâmetros
        posx = posx + comp_linha

def desenha(i,alt, posx,posy,comp_linha):
    pass

if __name__ == '__main__':
    n = 100
    teste = (46,39,105,0,44,5)
    histograma(teste)
    #dados_histo(n)

No esboço de solução apresentado podemos verificar que o programa histograma se limita a desenhar cada caso em sequência. Note como conseguimos os valores do número e do número de vezes que saiu graça ao uso de enumerate. Note ainda que a opção tomada obriga a que cada caso singular tenha que saber as quatro componentes relevantes: posição, tamanho do traço, numero do dado e numero de vezes que saiu. A posição para desenhar a coluna vai ser o centro pelo que pode ser calculada a partir do conhecimento do tamanho do traço. Tal como está, podemos testar o programa … mesmo que este não faça nada! Esta é uma das vantagens da programação descendente: podemos testar primeiro as soluções para os problemas e depois de as integrarmos no programa principal, testar o programa principal. A eliminação de eventuais erros é deste modo mais fácil de fazer. Passemos ao caso mais básico. São quatro so sub-problemas básicos que o compõem: número, linha, coluna, número. No entanto os dois problema de escrita de um número são na realidade o mesmo.

def desenha(i,alt, posx,posy,comp_linha):
    # escreve número i   
    # desenha linha
    # desenha coluna
    # escreve número de vezes (alt) que saiu o número i  
    pass

Podemos resolver cada um destes três sub-problemas e testá-los isoladamente.

def coluna(posx,posy, lado_1, lado_2,cor):
    # posiciona
    turtle.penup()
    turtle.goto(posx,posy)
    turtle.pendown()
    # desenha
    turtle.color(cor)
    turtle.begin_fill()
    for i in range(2):
        turtle.forward(lado_1)
        turtle.left(90)
        turtle.forward(lado_2)
        turtle.left(90)
    turtle.end_fill()
    turtle.hideturtle()
    
def linha(posx,posy,comp_linha,cor):
    # posiciona
    turtle.penup()
    turtle.goto(posx,posy)
    turtle.color(cor)
    turtle.pendown()
    # linha
    turtle.forward(comp_linha) 
    turtle.hideturtle()
    
def escreve_numero(posx,posy,fonte,valor,cor):
    # posiciona
    turtle.penup()
    turtle.goto(posx,posy)
    turtle.color(cor)  
    turtle.pendown()
    # escreve
    turtle.write(valor,font=fonte)
    turtle.hideturtle()

Agora precisamos de integrar esses sub-problemas no sub-problema de desenho de uma componente. Aqui vamos ter que perceber as relações entre cada um dos sub-componentes. Em primeiro lugar, decidimos que a largura da coluna será igual a metade do comprimento do traço. Em segundo lugar, fixamos a fonte no tamanho 12 e controlamos a posição da escrita.

def desenha(i,alt, posx,posy,comp_linha):
    # escreve número i
    escreve_numero(posx + comp_linha/2,posy - 15,('Arial',12,'bold'),i,'black')    
    # desenha linha
    linha(posx,posy,comp_linha,'red')
    # desenha coluna
    coluna(posx+comp_linha/4,posy,comp_linha/2,alt,'red')
    # escreve número de vezes (alt) que saiu o número i  
    escreve_numero(posx + comp_linha/2 - 5,posy + alt ,('Arial',12,'bold'),alt,'black')

Podemos agora testar o problema de visualizar. E está na hora de ver tudo junto.

import turtle

def dados_histo(n):
    # experiência de lançamentos
    res = lanca_dado(n)
    # visualizaçao
    histograma(res)
    
    
def lanca_dado(n):
    pass


def histograma(res):
    posx = -100
    posy = 0
    comp_linha = 80
    for i,alt in enumerate(res):
        # desenha caso i
        desenha(i+1,alt,posx,posy,comp_linha)
        # define parâmetros
        posx = posx + comp_linha

def desenha(i,alt, posx,posy,comp_linha):
    # escreve número i
    escreve_numero(posx + comp_linha/2,posy - 15,('Arial',12,'bold'),i,'black')    
    # desenha linha
    linha(posx,posy,comp_linha,'red')
    # desenha coluna
    coluna(posx+comp_linha/4,posy,comp_linha/2,alt,'red')
    # escreve número de vezes (alt) que saiu o número i  
    escreve_numero(posx + comp_linha/2 - 5,posy + alt ,('Arial',12,'bold'),alt,'black')


def coluna(posx,posy, lado_1, lado_2,cor):
    # posiciona
    turtle.penup()
    turtle.goto(posx,posy)
    turtle.pendown()
    # desenha
    turtle.color(cor)
    turtle.begin_fill()
    for i in range(2):
        turtle.forward(lado_1)
        turtle.left(90)
        turtle.forward(lado_2)
        turtle.left(90)
    turtle.end_fill()
    turtle.hideturtle()
    
def linha(posx,posy,comp_linha,cor):
    # posiciona
    turtle.penup()
    turtle.goto(posx,posy)
    turtle.color(cor)
    turtle.pendown()
    # linha
    turtle.forward(comp_linha) 
    turtle.hideturtle()
    
def escreve_numero(posx,posy,fonte,valor,cor):
    # posiciona
    turtle.penup()
    turtle.goto(posx,posy)
    turtle.color(cor)  
    turtle.pendown()
    # escreve
    turtle.write(valor,font=fonte)
    turtle.hideturtle()
  
    
    
    
if __name__ == '__main__':
    n = 100
    teste = (46,39,105,0,44,5)
    fonte = ('Arial', 24, 'bold')
    posx = 0
    posy = 0 
    cor_1 = 'black'
    cor_2 = 'red'
    comp = 80
    lado_1 = comp/2
    lado_2 = 50
    #escreve_numero(posx,posy,fonte,n,cor)
    #linha(posx,posy,comp,cor_2)
    #coluna(posx,posy, lado_1, lado_2,cor_2)
    #desenha(4,100, posx,posy,comp)
    histograma(teste)
    #dados_histo(n)
    turtle.exitonclick()

Agora é a vez do primeiro sub-problema, simular o lançamento do dado. Já fizemos isso em problemas anteriores semelhantes. Aqui a novidade reside no facto de querermos memorizar os resultados. Dado o facto de estarmos a usar tuplos, que são objectos imutáveis, vamos decompor esta questão em duas: (1) guardar os valores saídos em cada lançamento, (2) contar quantas vezes saiu cada um. Solução óbvia:

def lanca_dado(n):
    # lançamento
    resultado = tuple()
    for i in range(n):
        numero = random.randint(1,6)
        resultado = resultado + (numero,)
    # contagem
    conta = tuple()
    for i in range(1,7):
        conta_i = resultado.count(i)
        conta = conta + (conta_i,)
    return conta

Podemos finalmente testar o programa completo.

import turtle
import random

def dados_histo(n):
    # experiência de lançamentos
    res = lanca_dado(n)
    # visualizaçao
    histograma(res)
    
    
def lanca_dado(n):
    # lançamento
    resultado = tuple()
    for i in range(n):
        numero = random.randint(1,6)
        resultado = resultado + (numero,)
    # contagem
    conta = tuple()
    for i in range(1,7):
        conta_i = resultado.count(i)
        conta = conta + (conta_i,)
    return conta


def histograma(res):
    posx = -100
    posy = 0
    comp_linha = 80
    for i,alt in enumerate(res):
        # desenha caso i
        desenha(i+1,alt,posx,posy,comp_linha)
        # define parâmetros
        posx = posx + comp_linha

def desenha(i,alt, posx,posy,comp_linha):
    # escreve número i
    escreve_numero(posx + comp_linha/2,posy - 15,('Arial',12,'bold'),i,'black')    
    # desenha linha
    linha(posx,posy,comp_linha,'red')
    # desenha coluna
    coluna(posx+comp_linha/4,posy,comp_linha/2,alt,'red')
    # escreve número de vezes (alt) que saiu o número i  
    escreve_numero(posx + comp_linha/2 - 5,posy + alt ,('Arial',12,'bold'),alt,'black')


def coluna(posx,posy, lado_1, lado_2,cor):
    # posiciona
    turtle.penup()
    turtle.goto(posx,posy)
    turtle.pendown()
    # desenha
    turtle.color(cor)
    turtle.begin_fill()
    for i in range(2):
        turtle.forward(lado_1)
        turtle.left(90)
        turtle.forward(lado_2)
        turtle.left(90)
    turtle.end_fill()
    turtle.hideturtle()
    
def linha(posx,posy,comp_linha,cor):
    # posiciona
    turtle.penup()
    turtle.goto(posx,posy)
    turtle.color(cor)
    turtle.pendown()
    # linha
    turtle.forward(comp_linha) 
    turtle.hideturtle()
    
def escreve_numero(posx,posy,fonte,valor,cor):
    # posiciona
    turtle.penup()
    turtle.goto(posx,posy)
    turtle.color(cor)  
    turtle.pendown()
    # escreve
    turtle.write(valor,font=fonte)
    turtle.hideturtle()
  
    
    
    
if __name__ == '__main__':
    n = 100
    teste = (46,39,105,0,44,5)
    fonte = ('Arial', 24, 'bold')
    posx = 0
    posy = 0 
    cor_1 = 'black'
    cor_2 = 'red'
    comp = 80
    lado_1 = comp/2
    lado_2 = 50
    #escreve_numero(posx,posy,fonte,n,cor)
    #linha(posx,posy,comp,cor_2)
    #coluna(posx,posy, lado_1, lado_2,cor_2)
    #desenha(4,100, posx,posy,comp)
    #histograma(teste)
    #print(lanca_dado(n))
    dados_histo(n)
    turtle.exitonclick()
    
    

Para concluir o exercício, experimente com diferentes valores de tentativas. Que conclusões pode tirar à medida que n aumenta?? Identifique os pontos em que a solução não é genérica. como pode alterar a situação??

Na sala, alguns disseram que nos histogramas as colunas não estão separadas. A adaptação do código feito para que a visualização seja essa é mínima: retirar a linha na definição desenha, separar a cor do traço (pencolor) da cor de preenchimento (fillcolor) em desenha para que as colunas fiquem claramente a ver-se e, na função histograma, alterar o posicionamento ao longo do eixo dos xx da cada coluna.

import turtle
import random

def dados_histo(n):
    # experiência de lançamentos
    res = lanca_dado(n)
    # visualizaçao
    histograma(res)
    
    
def lanca_dado(n):
    # lançamento
    resultado = tuple()
    for i in range(n):
        numero = random.randint(1,6)
        resultado = resultado + (numero,)
    # contagem
    conta = tuple()
    for i in range(1,7):
        conta_i = resultado.count(i)
        conta = conta + (conta_i,)
    return conta


def histograma(res):
    posx = -100
    posy = 0
    comp_linha = 80
    for i,alt in enumerate(res):
        # desenha caso i
        desenha(i+1,alt,posx,posy,comp_linha)
        # define parâmetros
        posx = posx + comp_linha/2

def desenha(i,alt, posx,posy,comp_linha):
    # escreve número i
    escreve_numero(posx + comp_linha/2,posy - 15,('Arial',12,'bold'),i,'black')    
    # desenha coluna
    coluna(posx+comp_linha/4,posy,comp_linha/2,alt,'red')
    # escreve número de vezes (alt) que saiu o número i  
    escreve_numero(posx + comp_linha/2 - 5,posy + alt ,('Arial',12,'bold'),alt,'black')


def coluna(posx,posy, lado_1, lado_2,cor):
    # posiciona
    turtle.penup()
    turtle.goto(posx,posy)
    turtle.pendown()
    # desenha
    turtle.pencolor('black')
    turtle.fillcolor(cor)
    turtle.begin_fill()
    for i in range(2):
        turtle.forward(lado_1)
        turtle.left(90)
        turtle.forward(lado_2)
        turtle.left(90)
    turtle.end_fill()
    turtle.hideturtle()
    
def linha(posx,posy,comp_linha,cor):
    # posiciona
    turtle.penup()
    turtle.goto(posx,posy)
    turtle.color(cor)
    turtle.pendown()
    # linha
    turtle.forward(comp_linha) 
    turtle.hideturtle()
    
def escreve_numero(posx,posy,fonte,valor,cor):
    # posiciona
    turtle.penup()
    turtle.goto(posx,posy)
    turtle.color(cor)  
    turtle.pendown()
    # escreve
    turtle.write(valor,font=fonte)
    turtle.hideturtle()
  
    
    
    
if __name__ == '__main__':
    n = 1000
    teste = (46,39,105,0,44,5)
    fonte = ('Arial', 24, 'bold')
    posx = 0
    posy = 0 
    cor_1 = 'black'
    cor_2 = 'red'
    comp = 80
    lado_1 = comp/2
    lado_2 = 50
    #escreve_numero(posx,posy,fonte,n,cor)
    #linha(posx,posy,comp,cor_2)
    #coluna(posx,posy, lado_1, lado_2,cor_2)
    #desenha(4,100, posx,posy,comp)
    #histograma(teste)
    #print(lanca_dado(n))
    dados_histo(n)
    turtle.exitonclick()
    

Para o leitor: e se quisermos que o histograma possa ter uma orientação qualquer??

Verdades...

Pense nisto ...

Exercícios de Programação Descendente (I)

Durante as aulas foi colocado o problema de desenvolver uma solução para a criação da imagem visual do símbolo da radioactividade.

Perante este problema a reacção primeira deve ser a de equacionar a possibilidade de decompor o problema em sub-problemas, se possível, independentes. Caso não sejam independentes temos que acordar primeiro o modo como se relacionam.

Não creio ser difícil identificar três sub-problemas: desenhar um quadrado, desenhar três sectores e desenhar uma circunferência. A dependência neste caso é a posição relativa de cada uma das três componentes. Com base nesta abordagem podemos escrever um primeiro esboço de solução.

import turtle

def radioactividade():
    # desenha quadrado
    quadrado()
    # desenha sectores
    sectores()
    #desenha circunferência
    circunferencia()
    
    
def quadrado():
    pass

def sectores():
    pass

def circunferencia():
    pass

if __name__ == '__main__':
    radioactividade()

Esta solução já pode ser testada embora não faça nada! Note-se que as definições ainda não têm argumentos… Vamos tomar nova decisão: dar o máximo liberdade à resolução de cada um dos sub-problemas. Por exemplo, no caso do quadrado, vamos criar uma definição que permita desenhar um quadrado parametrizado pelo tamanho do lado, a posição, a orientação e a cor. Já sabemos como fazer isso.

import turtle

def radioactividade(lado,posx,posy,orientacao,cor):
    # desenha quadrado
    quadrado(lado,posx,posy,orientacao,cor)
    # desenha sectores
    sectores()
    #desenha circunferência
    circunferencia()
    
    

def quadrado(lado,posx,posy,orientacao,cor):
    turtle.up()
    turtle.goto(posx,posy)
    turtle.setheading(orientacao)
    turtle.pendown()
    turtle.fillcolor(cor)
    turtle.begin_fill()
    for i in range(4):
        turtle.forward(lado)
        turtle.left(90)
    turtle.end_fill()
    turtle.hideturtle()

def sectores():
    pass

def circunferencia():
    pass

if __name__ == '__main__':
    lado = 100
    posx = -50
    posy = -50
    orientacao = 30
    cor = 'yellow'
    radioactividade(lado,posx,posy,orientacao,cor)

Podemos testar isoladamente a definição quadrado e/ou testá-la no contexto da definição do símbolo da radioactividade. O normal, em programas grandes é que o teste seja feito primeiro isoladamente e só depois no interior do programa principal. Trata-se de mais uma vantagem deste tipo de programação, apelidada de programação descendente, que conduz a soluções modulares. Para além de os testes serem mais fáceis de fazer, também ficamos com código reutilizável!

Resolvida esta questão vamos escolher um dos dois sub-problemas restantes. Optamos pela circunferência. Também aqui já sabemos o que fazer.

def circunferencia(raio,posx,posy,orienta,cor):
    turtle.penup()
    turtle.goto(posx,posy)
    turtle.setheading(orienta)
    turtle.pendown()
    turtle.fillcolor(cor) 
    turtle.begin_fill()
    turtle.circle(raio)
    turtle.end_fill()
    turtle.hideturtle()

Se testarmos esta definição verificamos que está tudo funcional como pretendido. Naturalmente queremos testar esta solução no interior do nosso programa principal, e aqui, somos confrontados com o facto dos tamanhos (lado e raio), das posições e das orientações estarem relacionadas. Com um pouco de análise não será difícil chegar a uma solução aceitável.

import turtle

def radioactividade(lado,posx,posy,orientacao,cor, cor_c):
    # desenha quadrado
    quadrado(lado,posx,posy,orientacao,cor)
    # desenha sectores
    sectores()
    #desenha circunferência
    raio = lado/10
    posx_c = posx + lado/2 + raio
    posy_c = posy + lado/2
    orientacao_c = orientacao + 90
    circunferencia(raio,posx_c,posy_c,orientacao_c,cor_c)
    
    

def quadrado(lado,posx,posy,orientacao,cor):
    turtle.up()
    turtle.goto(posx,posy)
    turtle.setheading(orientacao)
    turtle.pendown()
    turtle.fillcolor(cor)
    turtle.begin_fill()
    for i in range(4):
        turtle.forward(lado)
        turtle.left(90)
    turtle.end_fill()
    turtle.hideturtle()

def sectores():
    pass

def circunferencia(raio,posx,posy,orienta,cor):
    turtle.penup()
    turtle.goto(posx,posy)
    turtle.setheading(orienta)
    turtle.pendown()
    turtle.fillcolor(cor) 
    turtle.begin_fill()
    turtle.circle(raio)
    turtle.end_fill()
    turtle.hideturtle()

if __name__ == '__main__':
    lado = 100
    posx = -50
    posy = -50
    orientacao = 0
    cor = 'yellow'
    raio = lado/10
    cor_c = 'black'
    #circunf(raio,posx,posy,orientacao,cor)
    radioactividade(lado,posx,posy,orientacao,cor, cor_c)
    turtle.exitonclick()

Como se pode ver o desenho da circunferência é precedido do cálculo dos valores apropriados para o tamanho do raio, a posição e a orientação. Repare que para que o centro da circunferência coincida com o centro do quadrado, a tartaruga tem que ser colocada numa posição em que veja esse centro à sua esquerda e à distância do raio! O leitor atento notará que a orientação inicial é de zero graus, pois é isto que nos é pedido. Caso o valor seja diferente o posicionamento do centro da circunferência também é diferente.

Deixámos para o fim o problema dos sectores. Também aqui é possível decompor este problema em três sub-problemas equivalentes. Vejamos então como podemos desenhar um sector com total liberdade.

def sector(raio,posx,posy,orientacao,cor,amplitude):
    turtle.penup()
    turtle.goto(posx,posy)
    turtle.setheading(orientacao)
    turtle.color(cor)
    turtle.pendown()
    turtle.begin_fill()
    turtle.forward(raio)
    turtle.left(90)
    turtle.circle(raio,amplitude)
    turtle.left(90)
    turtle.forward(raio)
    turtle.end_fill()
    turtle.setheading(orientacao)
    turtle.hideturtle()

O desenho tem três partes: desenho do raio, desenho do arco, desenho do raio. Notar que no final queremos ter a tartaruga com a orientação inicial. Porquê?? Uma vez mais, um leitor atento pode ser levado a pensar que o desenho da circunferência e o desenho do sector poderiam ser unidos numa única definição. Afinal, parece que apenas diferem do parâmetro amplitude. Mas será mesmo assim? Quem quiser pode explorar esse caminho e verificar as questões que se colocam.

Como desenhamos os três sectores? Não é difícil perceber que temos que repetir o desenho de um sector alterando apenas a orientação de 120 graus. Será que o facto de a tartaruga que desenha um sector terminar com a mesma orientação que a inicial ajudou???

def sectores(raio,posx,posy,orientacao,cor,amplitude):
    for i in range(3):
        sector(raio,posx,posy,orientacao,cor,amplitude)
        orientacao = orientacao + 120

Para terminar o trabalho temos que incorporar esta solução no programa principal.

import turtle

def radioactividade(lado,posx,posy,orientacao,cor, cor_c, cor_s):
    # desenha quadrado
    quadrado(lado,posx,posy,orientacao,cor)
    # desenha sectores
    raio_s = lado/4
    posx_s = posx + lado/2
    posy_s = posy + lado/2
    orientacao_s = orientacao
    amplitude = 60
    sectores(raio_s,posx_s,posy_s,orientacao_s,cor_s,amplitude)
    #desenha circunferência
    raio = lado/10
    posx_c = posx + lado/2 + raio
    posy_c = posy + lado/2
    orientacao_c = orientacao + 90
    circunferencia(raio,posx_c,posy_c,orientacao_c,cor_c)
    
    

def quadrado(lado,posx,posy,orientacao,cor):
    turtle.up()
    turtle.goto(posx,posy)
    turtle.setheading(orientacao)
    turtle.pendown()
    turtle.fillcolor(cor)
    turtle.begin_fill()
    for i in range(4):
        turtle.forward(lado)
        turtle.left(90)
    turtle.end_fill()
    turtle.hideturtle()

def sectores(raio,posx,posy,orientacao,cor,amplitude):
    for i in range(3):
        sector(raio,posx,posy,orientacao,cor,amplitude)
        orientacao = orientacao + 120
        

def sector(raio,posx,posy,orientacao,cor,amplitude):
    turtle.penup()
    turtle.goto(posx,posy)
    turtle.setheading(orientacao)
    turtle.color(cor)
    turtle.pendown()
    turtle.begin_fill()
    turtle.forward(raio)
    turtle.left(90)
    turtle.circle(raio,amplitude)
    turtle.left(90)
    turtle.forward(raio)
    turtle.end_fill()
    turtle.setheading(orientacao)
    turtle.hideturtle()

def circunferencia(raio,posx,posy,orienta,cor):
    turtle.penup()
    turtle.goto(posx,posy)
    turtle.setheading(orienta)
    turtle.pendown()
    turtle.fillcolor(cor) 
    turtle.begin_fill()
    turtle.circle(raio)
    turtle.end_fill()
    turtle.hideturtle()

if __name__ == '__main__':
    lado = 100
    posx = -50
    posy = -50
    orientacao = 0
    cor = 'yellow'
    raio = lado/10
    cor_c = 'black'
    raio_s = lado/4
    cor_s = 'black'
    amplitude = 60
    #circunferencia(raio,posx,posy,orientacao,cor)
    #sector(raio_s,posx,posy,orientacao,cor_s,amplitude)
    #sectores(raio_s,posx,posy,orientacao,cor_s,amplitude)
    radioactividade(lado,posx,posy,orientacao,cor, cor_c,cor_s)
    turtle.exitonclick()

A definição de alguns parâmetros dos sectores em função dos parâmetros do quadrado não deve oferecer dúvidas. Se executarmos o programa verificamos que não aparece a separação entre a circunferência e os sectores. A solução desse problema é trivial e passa por colocar a cor da caneta da tartaruga, quando desenha a circunferência, a branco.

def circunferencia(raio,posx,posy,orienta,cor):
    turtle.penup()
    turtle.goto(posx,posy)
    turtle.setheading(orienta)
    turtle.pencolor('white')
    turtle.pendown()
    turtle.fillcolor(cor) 
    turtle.begin_fill()
    turtle.circle(raio)
    turtle.end_fill()
    turtle.hideturtle()

Como dissemos atrás esta solução global funciona quando a orientação inicial é zero. Se for outra não funciona. Como alterar a nossa solução mexendo o mínimo possível, por forma ao programa funcionar mesmo quando o quadrado tem uma orientação qualquer? A solução passa por recalcular o centro da figura tendo a orientação em linha de conta. Para isso basta usar um pouco do nosso conhecimento de trigonometria.

import turtle
import math


def radioactividade(lado,posx,posy,orientacao,cor, cor_c, cor_s):
    # desenha quadrado
    quadrado(lado,posx,posy,orientacao,cor)
    # desenha sectores
    raio_s = lado/4
    ang_base = (orientacao* math.pi / 180)
    ang = ang_base + math.pi/4     
    posx_s = posx + lado/math.sqrt(2) * math.cos(ang) 
    posy_s = posy + lado/math.sqrt(2) * math.sin(ang)
    orientacao_s = orientacao
    amplitude = 60
    sectores(raio_s,posx_s,posy_s,orientacao_s,cor_s,amplitude)
    #desenha circunferência
    raio = lado/10
    posx_c = posx_s +  raio * math.cos(ang_base)
    posy_c = posy_s + raio * math.sin(ang_base)
    orientacao_c = orientacao + 90
    circunferencia(raio,posx_c,posy_c,orientacao_c,cor_c)
    
    

def quadrado(lado,posx,posy,orientacao,cor):
    turtle.up()
    turtle.goto(posx,posy)
    turtle.setheading(orientacao)
    turtle.pendown()
    turtle.fillcolor(cor)
    turtle.begin_fill()
    for i in range(4):
        turtle.forward(lado)
        turtle.left(90)
    turtle.end_fill()
    turtle.hideturtle()

def sectores(raio,posx,posy,orientacao,cor,amplitude):
    for i in range(3):
        sector(raio,posx,posy,orientacao,cor,amplitude)
        orientacao = orientacao + 120
        

def sector(raio,posx,posy,orientacao,cor,amplitude):
    turtle.penup()
    turtle.goto(posx,posy)
    turtle.setheading(orientacao)
    turtle.color(cor)
    turtle.pendown()
    turtle.begin_fill()
    turtle.forward(raio)
    turtle.left(90)
    turtle.circle(raio,amplitude)
    turtle.left(90)
    turtle.forward(raio)
    turtle.end_fill()
    turtle.setheading(orientacao)
    turtle.hideturtle()

def circunferencia(raio,posx,posy,orienta,cor):
    turtle.penup()
    turtle.goto(posx,posy)
    turtle.setheading(orienta)
    turtle.pencolor('white')
    turtle.pendown()
    turtle.fillcolor(cor) 
    turtle.begin_fill()
    turtle.circle(raio)
    turtle.end_fill()
    turtle.hideturtle()

if __name__ == '__main__':
    lado = 200
    posx = -50
    posy = -50
    orientacao = 45
    cor = 'yellow'
    raio = lado/10
    cor_c = 'black'
    raio_s = lado/4
    cor_s = 'black'
    amplitude = 60
    radioactividade(lado,posx,posy,orientacao,cor, cor_c,cor_s)
    turtle.exitonclick()

Como se pode ver apenas mexemos no programa principal e em zonas localizadas do código, as zonas de definem a interacção entre as partes. E pronto. Espero que da próxima vez que programar procure usar este princípio da decomposição de um problema em sub-problemas!

Teste # 1 - TP2

P1

O que aparece no lugar do ponto de interrogação?

>>> x = 'abacadabra'
>>> x[1] = 'zeus'
Traceback (most recent call last):
  Python Shell, prompt 2, line 1
builtins.TypeError: 'str' object does not support item assignment

Aparece um erro pois as cadeias de caracteres são imutáveis não podendo o seu valor ser alterado.

P2

Como saber se uma moeda está enviesada? Fazemos vários lançamentos e comparamos com o valor esperado para uma das duas opções. Como nada neste mundo é perfeito aceitamos uma pequena discrepância em relação a esse valor. Para resolver o problema, vamos devagar e por partes. Primeiro uma versão simples que apenas simula e compara com o caçoe médio esperado.

def enviesada_a(n):
    # lança e conta
    conta = 0
    for i in range(n):
        conta = conta + random.randint(0,1)   
    # analisa
    return conta != n//2

Esta versão baseia-se num padrão dec programação conhecido por ciclo - acumulador. O nome conta está associado a um objecto cujo valor corresponde ao numero de vezes que já saiu caras (1). O ciclo é repetido o número de vezes pretendido. A comparação final é feita usando a divisão inteira.

Vamos partir desta solução para a solução final pretendida. A moeda estará enviesada se o valor obtido estiver fora de um dado intervalo.

def enviesada(n,perc):
    """ 
    n = número de lançamentos
    perc = percentagem aceitável [0,1]
    """
    # lança e conta
    conta = 0
    for i in range(n):
        conta = conta + random.randint(0,1)   
    # analisa
    espera = n/2
    inf_ = (1 - perc)* espera
    sup_ = (1 + perc) * espera
    return (conta < inf_) or (conta > sup_)

Como se observa usamos agora uma divisão de floats.

P3

Queremos desenhar bonecos como o da figura.

Olhando para a figura observamos que precisamos saber desenhar balões coloridos e uma cauda que é composta de repetições de uma sequência de quatro segmentos com orientações alternadas. Uma solução simples vai envolver três passos:

def boneco(n,raio_1, raio_2, posx,posy, orientacao, cor_1,cor_2,cor_3):
    # desenha balão grande
    # desenha balão pequeno
    # desenha cauda
    pass

Tratemos dos balões isoladamente:

def bola(raio, posx,posy, orientacao, cor):
    turtle.penup()
    turtle.goto(posx,posy)
    turtle.pendown()
    turtle.setheading(orientacao)
    turtle.fillcolor(cor)
    turtle.begin_fill()
    turtle.circle(raio)
    turtle.end_fill()
    turtle.hideturtle()

Esta solução corresponde ao que já foi feito nas aulas!!! Vamos tratar da parte nova: a cauda. olhando para a figura vemos que é composta a partir de uma sequência de formas mais simples. Estas por sua vez são formadas por três traços. Eis uma solução genérica para a cauda:

def cauda(n, tipo, posx, posy,orientacao, comp, cor):
    turtle.penup()
    turtle.goto(posx,posy)
    turtle.pendown()
    turtle.setheading(orientacao)
    turtle.pencolor(cor)
    for i in range(n):
        turtle.forward(comp)
        turtle.right(tipo * 60)     
    turtle.hideturtle()

Dizemos que é genérica porque usamos o parâmetro n, que no caso que nos interessa será igual a 3. Por outro lado, note-se que o parâmetro tipo é usado para determinar a orientação de cada sequência de três segmentos. tipo pode valer 1 ou -1, pois só temos duas orientações a considerar.

Resolvidas as três questões (balão grande, balão pequeno e cauda), vamos juntar tudo. A primeira questão é a de saber como juntamos os dois balões. A ideia é desenhar o maior e depois, a partir da posição final e da orientação, calcular a posição do centro do balão pequeno. Uma hipótese é:

def boneco(n,raio_1, raio_2, posx,posy, orientacao, cor_1,cor_2,cor_3):
    # desenha balão grande
    bola(raio_1,  posx,posy, orientacao, cor_1)
    # desenha balão pequeno
    turtle.penup()
    turtle.setheading(orientacao-90)
    turtle.forward(2*raio_2)
    turtle.setheading(orientacao)
    turtle.pendown()
    bola(raio_2,  turtle.xcor(),turtle.ycor(), orientacao, cor_2)
    # desenha cauda
   

Esta solução é fácil de entender se nos lembrarmos que a tartaruga desenha uma circunferência tendo o centro à sua esquerda! Claro que podemos fazer de outro modo:

def balao(n,raio_1, raio_2, posx,posy, orientacao, cor_1,cor_2,cor_3):
    bola(raio_1,  posx,posy, orientacao, cor_1)
    bola(-raio_2,  turtle.xcor(),turtle.ycor(), orientacao, cor_2)

Percebe a diferença???

Só falta acrescentar a cauda…

def balao(n,raio_1, raio_2, posx,posy, orientacao, cor_1,cor_2,cor_3):
    bola(raio_1,  posx,posy, orientacao, cor_1)
    turtle.penup()
    turtle.setheading(orientacao-90)
    turtle.forward(2*raio_2)
    turtle.setheading(orientacao)
    turtle.pendown()
    bola(raio_2,  turtle.xcor(),turtle.ycor(), orientacao, cor_2)
    for i in range(n):
        cauda(3,(-1)**i,turtle.xcor(),turtle.ycor(),turtle.heading(),20,cor_3)
    turtle.hideturtle()

E pronto! Percebeu o modo como alternamos a orientação da cauda??? Simplesmente fazendo o tipo igual a (-1)** i, o que faz com que o tipo vá ser alternadamente 1 e -1, como pretendido!

Pode usar este programa para criar variantes. Por exemplo:

def baloes(n,raio_1, raio_2, posx,posy, orientacao, cor_1,cor_2,cor_3):
    # balão grande
    bola(raio_1,  posx,posy, orientacao, cor_1)
    # n balões pequenos à volta do balão grande...
    for i in range(n):
        turtle.penup()
        turtle.circle(raio_1,360/n)
        turtle.pendown()        
        bola(-raio_2,  turtle.xcor(),turtle.ycor(), turtle.heading(), cor_2)
    turtle.hideturtle()

Teste # 1 - TP1

P1

Quando fazemos :

>>> X = X + 1 

acontece o seguinte. Primeiro o sistema tenta calcular o objecto associado à expressão X + 1. Para tal procura no espaço dos objectos o valor do objecto associado ao nome X. De seguida, incrementa esse valor de uma unidade e associa o novo objecto ao nome X.

P2

Era-nos pedido uma solução para o problema de saber se após o lançamento de um dado n vezes, o número de vezes que saiu um número par é maior do que o valor médio esperado. Podemos resolver este problema pro aproximações, baseando-nos num padrão de programação nosso conhecido: ciclo - acumulador.

def par_impar(n):
    conta_par = 0 # o acumulador
    for i in range(n):
        num = lanca_dado()
        # actualiza o acumulador
    # define resultado

A implementação da simulação do lançamento do dado é trivial:

import random 

def lanca_dado():
    return random.randint(1,6)

Com estes elementos chegamos facilmente à versão final:

import random

def lanca_dado():
    return random.randint(1,6)

def par_impar(n):
    conta_par = 0
    for i in range(n):
        num = lanca_dado()
        if (num == 2) or (num == 4) or (num == 6): # if num in (2,4,6):
            conta_par = conta_par + 1
    if conta_par > n/2:
        return True
    else:
        return False

Notar que o teste de saída de número par pode ser abreviado para if num in (2,4,6):

P3

Queremos um programa que nos permita desenhar figuras como a abaixo.

Pedem para poder parametrizar muita coisa: posição, orientação, número de laços e de segmentos tos, cor, tamanho do lado dos laços, tamanho dos segmentos, etc.

A solução passa por dividir o problema em sub-problemas e não tentar resolver tudo de uma vez. Olhando para a figura vemos laços e uma cauda. Os laços podem ser construídos como dois triângulos ligados por um vértice, enquanto a cauda é uma sequência de segmentos. Vamos resolver cada um dos sub-problemas.

Comecemos pelos triângulos coloridos, algo que fizemos nas aulas.

def tri_cor(posx,posy,orientacao,lado,cor):
    turtle.penup()
    turtle.goto(posx,posy)
    turtle.pendown()
    turtle.setheading(orientacao)
    turtle.fillcolor(cor)
    turtle.begin_fill()
    for i in range(3):
        turtle.forward(lado)
        turtle.left(120)
    turtle.end_fill()
    turtle.hideturtle()

Como se pode ver, iniciamos o programa definindo os parâmetros e depois desenhos o triângulo. O laço resulta de desenharmos dois triângulos percebendo que a orientação de ambos está desfasada de 180 graus.

def laco(posx,posy,orientacao,lado,cor):
    tri_cor(posx,posy,orientacao,lado,cor)
    tri_cor(posx,posy,orientacao + 180,lado,cor)
    turtle.hideturtle()

Passemos à cauda como sequência de segmentos. Desenhar um segmento com uma dada inclinação é trivial.

def seg(posx,posy,comp,orientacao,cor):
    turtle.penup()
    turtle.goto(posx,posy)
    turtle.pendown()
    turtle.setheading(orientacao)
    turtle.pencolor(cor)
    turtle.forward(comp)
    turtle.hideturtle()

Podemos agora juntar as peças do nosso puzzle. Se pensarmos um pouco, a estratégia mais interessante para o nosso programa final consiste em desenhar um segmento e de seguida desenhar um laço, repetindo estas acções o número apropriado de vezes. Daí a solução:

def boneco(n, posx, posy, orientacao,inc,comp,lado,cor):
    turtle.penup()
    turtle.goto(posx,posy)
    turtle.pendown()
    for i in range(n):
        if i % 2 == 0:
            seg(turtle.xcor(),turtle.ycor(),comp,orientacao + inc,cor)
            laco(turtle.xcor(),turtle.ycor(),turtle.heading()-90,lado,cor)
        else:
            seg(turtle.xcor(),turtle.ycor(),comp,orientacao - inc,cor)
            laco(turtle.xcor(),turtle.ycor(),turtle.heading()+90,lado,cor)        
    if n % 2 == 0:
        seg(turtle.xcor(),turtle.ycor(),comp,orientacao + inc,cor)
    else:
        seg(turtle.xcor(),turtle.ycor(),comp,orientacao - inc,cor)

E pronto! O leitor atento notará que o if final se deve à necessidade de desenhar o último segmento da cauda. Por outro lado, note como controlamos a orientação da cauda, e como relacionamos a orientação dos segmentos e dos laços. Finalmente, a cor dos laços e dos segmentos é a mesma, mas é trivial fazer com que tenham cor diferente!

Depois de feito o programa, torna-se evidente que podemos simplificar o desenho dos segmentos:

def boneco(n, posx, posy, orientacao,inc,comp,lado,cor):
    turtle.penup()
    turtle.goto(posx,posy)
    turtle.pendown()
    turtle.pencolor(cor)
    for i in range(n):
        if i % 2 == 0:
            turtle.setheading(orientacao + inc)
            turtle.forward(comp)
            laco(turtle.xcor(),turtle.ycor(),turtle.heading()-90,lado,cor)
        else:
            turtle.setheading(orientacao - inc)
            turtle.forward(comp)
            laco(turtle.xcor(),turtle.ycor(),turtle.heading()+90,lado,cor)
    if n % 2 == 0:
        turtle.setheading(orientacao + inc)
        turtle.forward(comp)
    else:
        turtle.setheading(orientacao - inc)
        turtle.forward(comp) 

E chega… ou talvez não!

Para terminar, e embora não fosse necessário, um pequeno programa para desenhar apenas uma cauda ondulante:

def cauda(n,posx,posy,comp,orienta_1,orienta_2,cor):
    # posiciona
    turtle.penup()
    turtle.goto(posx,posy)
    turtle.pendown()
    turtle.pencolor(cor) 
    for i in range(n):
        if i % 2 == 0 :
            seg(turtle.xcor(),turtle.ycor(),comp, orienta_1,cor)
        else:
            seg(turtle.xcor(),turtle.ycor(),comp, orienta_2,cor)

Note-se como controlamos a orientação dos segmentos.