Teste 1 - TP9

Pergunta 1 O espaço dos objectos é o local da memória onde estão guardados os objectos. Em particular, os atributos valor e tipo. O espaço dos nomes é o local da memória onde estão armazenados os nomes que foram associados a objectos através de uma atribuição explícita (caso da instrução de atribuição =) ou implícita (caso de uma definição (def) ou da importação de um módulo (import). Visualmente temos a seguinte situação para cada um dos três casos referidos.

Pergunta 2 Olhando para a cara o que vemos? Que é composta a partir de quadrados e rectângulos coloridos. E os quadrados são um caso particular de rectângulos. Então só precisamos de uma função auxiliar.

view sourceprint?

01.def rect_cor(posx,posy,lado1,lado2,cor):

02.    # Atributos

03.    turtle.penup()

04.    turtle.goto(posx,posy)

05.    turtle.pendown()

06.    turtle.fillcolor(cor)

07.    turtle.begin_fill()

08.    for i in range(4):

09.        if i%2 == 0:

10.            turtle.forward(lado1)

11.        else:

12.            turtle.forward(lado2)

13.        turtle.left(90)

14.    turtle.end_fill()

15.    turtle.hideturtle()

Com esta implementação podemos colocar o rectângulo em qualquer posição e com qualquer cor!

A partir do momento em que temos esta possibilidade o resto é apenas calcular as posições e definir a cor de cada rectângulo ou quadrado. Numa solução simples, e mais não era pedido, podemos assumir que a cara fica sempre na mesma posição, no caso da nossa implementação no ponto (0,0). Notar que este ponto corresponde ao canto inferior esquerdo da cara.

view sourceprint?

01.def cara():

02.    # cabeça

03.    rect_cor(0,0,120,120,'white')

04.    # olhos

05.    rect_cor(30,85,20,20,'blue')

06.    rect_cor(70,85,20,20,'blue')

07.    # nariz

08.    rect_cor(55,30,10,35,'red')

09.    # boca

10.    rect_cor(50,15,20,10,'yellow')

11.    # orelhas

12.    rect_cor(-10,60,10,30,'red')

13.    rect_cor(120,60,10,30,'red')

Pergunta 3 Pedem-nos para comparar duas cadeias de caracteres posição a posição e determinar em quantas os respectivos caracteres são diferentes. Chama-se a isto a Distância de Hamming. Vamos esquecer para já o problema de tamanhos diferentes e assumimos que têm o mesmo comprimento. Uma solução simples é percorrer as duas cadeias por posição e comparar.

view sourceprint?

1.def hamming_basico(cadeia_1, cadeia_2):

2.    """Calcula a distância de Hamming de duas cadeias."""

3.    distancia = 0

4.    for i in range(tamanho_menor):

5.        if cadeia_1[i] != cadeia_2[i]:

6.            distancia = distancia + 1

7.    return distancia  

Ter feito isto já valia bastante. Agora o problema do tamanho. Por definição os caracteres em excesso da cadeia maior são diferentes dos da outra (que não existem!). Logo só temos que somar a dirença. Por outro lado temos que ter o cuidado de percorrer as duas cadeias um número de vezes igual ao tamanho da de menor comprimento. Logo, usando apenas funções mencionadas nas aulas:

view sourceprint?

01.def hamming(cadeia_1, cadeia_2):

02.    """Calcula a distância de Hamming de duas cadeias."""

03.    tamanho_menor = min(len(cadeia_1), len(cadeia_2))

04.    distancia = 0

05.    for i in range(tamanho_menor):

06.        if cadeia_1[i] != cadeia_2[i]:

07.            distancia = distancia + 1

08.    tamanho_maior = max(len(cadeia_1), len(cadeia_2))

09.    distancia = distancia + (tamanho_maior - tamanho_menor)

10.    return distancia

Em alternativa podíamos ainda fazer:

view sourceprint?

01.def hamming_b(cadeia_1, cadeia_2):

02.    """Calcula a distância de Hamming de duas cadeias."""

03.    tamanho_menor = min(len(cadeia_1), len(cadeia_2))

04.    distancia = 0

05.    for i in range(tamanho_menor):

06.        if cadeia_1[i] != cadeia_2[i]:

07.            distancia = distancia + 1

08.    distancia = distancia + abs(len(cadeia_1)- len(cadeia_2))

09.    return distancia

A função abs dá-nos o módulo do número dado como argumento: abs(-5) e abs(5) são ambos iguais a 5. Este exemplo e a sua solução ilustram o poder das abstracção que permite a escrita de programas modulares e ainda a técnica de encontrar primeiro uma solução para um problema mais simples e depois completar a solução.