AULA 5

(1)

AULA 5

(2)

Hoje

I mais

recursão

I argumentos na linha de comando

I registros e estruturas

(3)

Curvas de Hilbert

Niklaus Wirth

Algorithms and Data Structures Prentice Hall, 1986.

(4)

Curvas de Hilbert

As curvas a seguir seguem um certo padrão regular e podem ser desenhadas na tela sobre o controle de um programa.

O objetivo é descobrir o esquema de recursão para construir tais curvas.

Estes padrões serão chamados de H⁰,H¹,H². . ..

Cada Hi denomina a curva de Hilbert de ordem i, em homenagem a seu inventor, o matemático David Hilbert.

(5)

H

¹

(6)

H

²

(7)

H

³

(8)

H

⁴

(9)

Padrão

As guras mostram que Hi+1 é obtida pela composição de 4 instâncias de Hi de metade do tamanho e com a rotação apropriada, ligadas entre si por meio de 3 linhas de conexão.

Por exemplo:

I H1 é formada por 4 H0 (vazio) conectados por 3 linhas.

I H² é formada por 4 H¹ conectados por 3 linhas

I H3 é formada por 4 H2 conectados por 3 linhas

(10)

H

²

(11)

H

³

(12)

H

⁴

(13)

Partes da curva

Para ilustrar, denotaremos as quatro possíveis instâncias por A, B, C e D:

I A será o padrão que tem a abertura para direita;

I B será o padrão que tem a abertura para baixo;

I C será o padrão que tem a abertura para esquerda; e

I D será o padrão que tem a abertura para cima.

Representaremos a chamada da função que desenha as interconexões por meio da setas ↑,↓,←,→.

(14)

A

¹

e A

²

(15)

B

²

e B

³

(16)

C

²

e C

³

(17)

D

⁴

(18)

Esquema recursivo

Assim, surge o seguinte esquema recursivo:

Ak : Dk−1 ← Ak−1 ↓ Ak−1 → Bk−1

Bk : Ck−1 ↑ Bk−1 → Bk−1 ↓ Ck−1

Ck : Bk−1 → Ck−1 ↑ Ck−1 ← Dk−1

Dk : Ak−1 ↓ Dk−1 ← Dk−1 ↑ Ck−1

Para desenhar os segmentos utilizaremos a chamada de uma função

linha(x,y,direcao,comprimento)

que move um pincel da posição (x,y) em uma dada direcao por um certo comprimento.

(19)

typedef enum {DIREITA, ESQUERDA, CIMA, BAIXO} Direcao;

void linha(int *x, int *y,Direcao direcao, int comprimento) {

switch (direcao) {

case DIREITA : *x = *x + comprimento;

break;

case ESQUERDA : *x = *x - comprimento;

break;

case CIMA : *y = *y + comprimento;

break;

case BAIXO : *y = *y - comprimento;

break;

}desenheLinha(*x, *y);

}

(20)

A

k

voida(int k, int *x, int *y, int comprimento) { if (k > 0) {

d(k-1, x, y, comprimento);

linha(x, y, ESQUERDA, comprimento);

a(k-1, x, y, comprimento);

linha(x, y, BAIXO, comprimento);

linha(x, y, DIREITA, comprimento);

b(k-1, x, y, comprimento);

} }

(21)

B

k

voidb(int k, int *x, int *y, int comprimento) { if (k > 0) {

c(k-1, x, y, comprimento);

} }

(22)

C

k

voidc(int k, int *x, int *y, int comprimento) { if (k > 0) {

} }

(23)

D

k

voidd(int k, int *x, int *y, int comprimento) { if (k > 0) {

} }

(24)

Argumentos na linha de comando

(25)

Argumentos na linha de comando

Quando main é chamada, ela recebe dois argumentos:

I argc ('c' de count) é o número de argumentos que o programa recebeu na linha de comando; e

I argv[ ] é um vetor de strings contendo cada um dos argumentos.

Por conveção argv[0] é o nome do programa que foi chamado. Assim, argc é sempre pelo menos 1.

(26)

Argumentos na linha de comando

Por exemplo, na chamada

meu_prompt> echo Hello World!

I argc= 3

I argv[0] = "echo"

I argv[1] = "Hello"

I argv[2] = "World!"

(27)

Argumentos na linha de comando

Na chamada

meu_prompt> gcc echo.c -o echo

I argc= 4

I argv[0] = "gcc"

I argv[1] = "echo.c"

I argv[2] = "-o"

I argv[3] = "echo"

(28)

echo.c

#include <stdio.h>

intmain(int argc, char *argv[]) { int i;

for (i = 1; i < argc; i++) printf("%s ", argv[i]);

printf("\n");

return 0;

}

(29)

echo.java

public class echo {

public static void main(String argv[]) { for (int i=0; i < argv.length; i++)

System.out.print(argv[i] + );

System.out.print("\n");

System.exit(0);

} }