!
" #
$
%!
! &
!
"
'
#
%
$
)
%
&'
&'
&'
&'
%
'
*
$
,%
-
%
+%
%
%
%
0+%
0
$ %
)
%
.
+%
' %
%
+%
$
.
%
%
(
/
( %
'
,
.
(
2
&'
1
%
!
(
(
!
(
"
2 3 4
%
(
/
2!
$
4
%
)
0
%
$
5
%
$
%
%
%
"
3
4
%
%
.
%
/4
7
5
%
/
(%
%
$5(
(
)
$ /
#260( /
. 2$
!
%
$
#%
$
algorithms and software Principles
$
%
/ $
"
.
!
)
"
*!
'
(
+
"
,
-
%
+
.# /
'
,
)
! &
3.1
3.2
3.3
3.4
3.5
3.6
3.7
3.8
3.9
3.10
3.11
3.12
2
!
"
#
'
+! )0!
1
'
+1
%
!
#
'
!
! "0!
2-
Primeiro exemplo ........................................................................................... 41
Outro exemplo de Algoritmo em pseudocódigo............................................. 42
Exemplos de implementações em linguagens de programação...................... 42
O conceito de subprograma ............................................................................ 44
O Conceito de variavel Local e Global .......................................................... 45
Procedimentos ................................................................................................ 45
Funções........................................................................................................... 47
Passagem de parãmetros por referência.......................................................... 49
Recursividade ................................................................................................. 50
Tipos de dados Variaáveis e Expressões ........................................................ 50
Operadores Aritméticos.................................................................................. 51
Operadores relacionais ................................................................................... 52
Operadores Boleanos...................................................................................... 52
Ficheiros de Texto .......................................................................................... 53
! %
5.1
5.2
5.3
5.4
5.5
5.6
5.7
5.8
5.9
!
Forma geral de um algoritmo em pseudocódigo ............................................ 29
Entrada de dados............................................................................................. 33
Saída de dados ................................................................................................ 34
Estruturas de controlo de fluxo....................................................................... 35
Estruturas de sequência .................................................................................. 35
Estruturas de Decisão ..................................................................................... 36
Estruturas de Decisão Simples ....................................................................... 36
Estruturas de Decisão Múltipla ...................................................................... 37
Estruturas de Repetição ou Loop.................................................................... 38
Ciclos contados............................................................................................... 38
Ciclos Enquanto.............................................................................................. 39
Ciclos Repetir … Até que (cond) ................................................................... 40
/' # ! !"'
4.1
4.2
4.3
4.4
4.5
4.6
4.7
4.8
4.9
4.10
4.11
4.12
4.13
4.14
&
' #'
%
!
#
'
! #
' ) 11
Forma Geral de um programa em C ............................................................... 55
Declaração e inicialização de variaveis e constantes...................................... 55
Expressões em C............................................................................................. 55
Implementação de estruturas de controlo de fluxo......................................... 55
Leitura(input) e Escrita(output) de dados....................................................... 55
Funções, argumentos e passagem de parâmetros ........................................... 55
Exemplos de programas em C ........................................................................ 55
Arrays, Matrizes e Strings .............................................................................. 64
Ponteiros ......................................................................................................... 79
4
!
"
5.10 Estruturas avançadas de dados – Estruturas e uniões; Enumerações e tipos
definidos pelo utilizador ............................................................................................. 81
5.11 Ficheiros de Texto em C, Rapor e VisualAlg................................................. 81
!
6.1
%
& 3
4,
Pesquisa .......................................................................................................... 83
& 3
3
& 3
6.2
" #
#
42
( 5
4
Ordenação....................................................................................................... 93
6 ((#
!
7,
%
#"%
77
-8+
9#
#
-81
: ";
-87
Complexidade do Quicksort ..................................................................................... 109
7.1
Filas, Listas e Pilhas ........................................ Erro! Marcador não definido.
4
7
/ ""
6 (#
!
#
'
" ' "5#
"#
=
'< "
--1+
5
!
-
%
!
#
"
'
8%
-
-
$
,
&'
%
.
/% 9 (
,
-%
%
%
%
(
(
: ) ;(
&'
1
1
%
,
%
)
.
>'
#
'
/"
< '
!
3 ?"
< 3
% %
!
'
(
9
'(@
!
%A
" !%
,% ( %
1
!
$
%
;
=3
8
%
%,%
0+%
-%
%
@
%
/
>( ! $
?
-%
>/
/
(
'
$
%,%
-
:
(
* % ;
)%
B>'
"
! $! '
#!
:
%
!
'
(
%
1
) . 6
%
% A
8 %
:
%
. B
,
'
'
< %
)
-1
'
#
(
1
&A ;
%
'
%
8
%
(
.
(
&A
<=$4
;.
%
%
1
( % 8
<
%
%
!
%
(
%
,
@
( 1
&'
%
:
&' .
(
,%
!
.
.
0
.
<
%
%
<
3
.
< '
<
"
'
!
'
%A
" C
"
'
!
$
6
"
$
(C "
5$
B
"'
"
"
" !
(C "
#
!
B
'
%
(
(
%
%
(
,
&'
. #
%
*
"
$
(
.
%
%
&A
1
.
)
(
&
&
(
% %
%+
% &
% % 1
.
)%
%
1
%+
%
' 3
#
3
#! !
1
-
9
%
%&'
(
-
'
#
'
%
(
"%
C
. B
<
%
1
(
(
&A
. 0
)
&A
1 (
8
4
(
1 (
9
&'
1
%
.
(
1
(
%
,%
9
&'
,%
(
4
%
%
%
%
$
.
(
%
!
%
1
%
< '
%&' (
(
1
% &
' !#
*
%
1
.
) '
%
8
%
&'
%
1
&' .
LINGUAGEM DE DESCRIÇÃO DE ALGORITMICA (LDA)
%
-
)
%
(
%
(
D % (
E %
.
7
1
'
)
&'
&A
!
"
Estrutura um Algoritmo
Algoritmo Nome_Do_Algoritmo
variáveis
Declaração das variáveis
Procedimentos
Declaração dos procedimentos
Funções
Declaração das funções
Início
Corpo do Algoritmo
Fim
Identificadores
F
% $
%
&A (
,
(
%
(
G
1. O primeiro caracter deve ser uma letra
2. Os nomes devem ser formados por caracteres pertencentes ao seguinte conjunto :
{a,b,c,..z,A,B,C,...Z,0,1,2,...,9,_}
3. Os nomes escolhidos devem explicitar seu conteúdo.
Variáveis:
B
,%
&A
&' .
9
,
(
(
(
%
G
INTEIRO : qualquer número inteiro, negativo, nulo ou positivo.
REAL : qualquer número real, negativo, nulo ou positivo.
CARACTER : qualquer conjunto de caracteres alfanuméricos.
LÓGICO : tipo especial de variável que armazena apenas os valores V e F, onde V
representa VERDADE e F FALSO
Declaração de variáveis
&'
1
9
(
,
(
%
)G
8
,
%
%
!
H ,
"
(... G
Operações Básicas:
&'
,
-
$
%
%
•
%
8
,
1
(
6F
(
F6#G
OPERADOR DE ATRIBUIÇÃO:
NomeDaVariavel ← Valor ou Expressão Atribuída.
•
OPERADORES ARITMÉTICOS:
+ = Adição
* = Multiplicação
- = Subtração ou inversor do sinal.
/ = Divisão
Quociente = Quociente da divisão de inteiros
Resto = Resto da divisão de inteiros
EXP(a,b) = Exponenciação ab
•
FUNÇÕES PRIMITIVAS: SEN(x); COS(x); TG(x); ABS(x); INT(x); Raiz(x);
PI( );
•
OPERADORES RELACIONAIS:
#'
* % :H
= - igual
< - menor
≤ - menor ou igual
•
%
,
;(
)
A (
G
≠ - diferente
> - maior
≥ - maior ou igual
OPERADORES LÓGICOS:
#'
)
A
* %
(
G
e - e lógico ou conjunção.
ou - ou lógico ou disjunção.
não - negação.
PRIORIDADE DE OPERADORES:
) % &'
-
%
,
1
)
' 1
) +%
( %
'
,
%
.
9
,
(
!
"
&'
G
1º - Efectuar operações embutidas em parênteses "mais internos"
2º - Efectuar Funções
3º - Efectuar multiplicação e/ou divisão
4º - Efectuar adição e/ou subtracção
5º - Operadores Relacionais
6º - Operadores Lógicos
?#G
%
,
&A
(
(
%
1 (
&'
%
9
(
%
.
COMANDOS DE ENTRADA E SAÍDA:
-
%
%
,1
&A
(
%
9 (
1
(
1 (
9
%
9
: %
(...;(
(
+%
'
%
(
&' (
%
(
(
1
)
%9%
(
%
&'
8(
&'
%
6
#9 .
Comando de Entrada de Dados
Leia(variável_1, variável_2,...)
Comando de Saída de Dados
Imprima(expressão_1, expressão_2,...)
COMANDOS DE CONTROLE DE FLUXO:
&'
%
8
(
)
D %
)%
%
8
%
&'
F
1
%
. 6
6
1 (
&' (
&A
%
#
%
%
9
%
%
%
&' .
10
&A
&'
' G #1+% (
!
#6IBJ 0/ G
1
)%
'
B
%
(
)%
%
1+%
,
%
"
/9
%
%
(
$
(
.
1
.
Inicio
Comando_1
...
Comando_n
Fim
#6K60LM G
% A (
%
%
%
%
8
) % &'
&' (
.
Simples
Se (Expressão Lógica)
Então Sequência_1
F6 62/
LM
. 6)
Composta
Se (Expressão Lógica)
Então Sequência_1
Senão Sequência_2
G #
+
%
%
,%
&A (
8
%&A
.
Enquanto (Expressão Lógica) faça
Sequência
O comando Enquanto analisa a Expressão Lógica e
enquanto o seu resultado for, o valor lógico, Verdade a
Sequência é executada.
Para variável ← valor_inicial até O comando Para incrementa, a variável, a partir do
valor_inicial de uma unidade, até que, esta atinja o
valor_final faça
valor_final. E para cada incremento a Sequência é
Sequência
executada..
O comando Repita executa a Sequência até que o valor
Repita
Sequência
retornado pela Expressão Lógica seja Verdadeiro
Até (Expressão Lógica)
TIPOS DE DADOS
6
%
8
.
11
,
(
!
H602 FD
%
:$
:6 , % ;.
%
:
(
-
( %
0
1
%
E
)
%
%
%
8
;
&'
"
(
( ...;(
$
-
&'
%
%
: E
9 %
;.
:
;(
.
Declaração :
NomeDoVector : vetor[nº de elementos] de Tipo do Vector
Referência :
NomeDoVector[índice]
! 2F/
NG
$
%
A .
(
(
1 (
+%
%
9 %
1
A .
Declaração :
NomeDaMatriz : matriz[dimensões] de Tipo da Matriz
Referência :
NomeDaMatriz[índices]
F6O/
#2F G
%
:P
-
8
,
( 1
;(
*
.
Declaração :
NomeDoRegistro : Registro
Declaração de Variáveis
FimRegistro
Referênca :
NomeDoRegistro.NomeDaVariável
Obs: Podemos ainda definir um vector formado por registros.
MODULARIZAÇÃO
' ! # E%
*
(
%
(
-
(
<
%*
%
%*
'
%
1
<
.
*
%
.
12
&'
( 1
( 8
,1
, (
&A
%
%
1
' G
!
& " !'
%
0
< B
&$
1
%
%
-
-
(
%
"
%*
%
%
+%
D
%
%*
1
-
.
1
D
.
Declaração :
Procedimento NomeDoProcedimento [(parâmetros)]
Variáveis
Inicio
Comandos;
Fim;
(
D
%
,
.
;
D
6 2F
6 2F
#Q
G 6 2F
:
%
D
D
%
6 2F
6 2F
:
+ % ;.
'
9
1
#Q
D
(
1
#Q
%
8
%
%
1
HF
&' .
Referência :
NomeDoProcedimento(variáveis)
?#G
,
D
%
%
D
.
%A
%
%
,
%
%
,
.
< B
&' -
(
-
'
%
$
%
(
(
%
&$
(
&' ( 1
Declaração :
Função NomeDaFunção [(parâmetros)] : tipo_da_função
Variáveis
Inicio
Comandos
NomeDaFunção ← (expressão de retorno)
Fim;
Referência :
NomeDaFunção(parâmetro)
13
(
.
1
(
!
B
.# /
'
&'
,%
,%
%
1
%
&'
%
%
1
%
1
(
1
1
"
A
.
%
,
(
-
%
&'
&A
+< (
,% ( %
) % &'
%
$
!
.
>'
!
'
' #=" ! !
<
' !
'
'
1
%
! " "
!
1
%
%+%
%
.
%
%
* %
-
&'
8%
B
#
( -%
%
1
9%
*
%
%
9 .
+
Modelo de memória de uma linguagem de programação de alto nível
B
1
%
%
&'
%
,
*
9
G
P
# %3
H
O
14
%
0(
(
!
/
&A
6
P
%
(
0(
%
%
%
, .
;
&
%
(
.
'
%:
1
% &'
;. 6
D %
%
'
%
. I
6
%
-
%
%
%
*
%
(
,
&.
.
1
1
D
(
P %3 .
*
(
.
,
:
A
%
*
&A
G
&
%+
-
,
'
%
-
&
&
&(
R. I
8
, '
& -
. #
%
&
1
:
%
%
&
&
P
"
%
&
%
;.
LINGUAGEM DE DESCRIÇÃO DE ALGORITMO (LDA)
Para escrevermos algoritmos é preciso uma linguagem clara e que não deixe
margem a ambiguidades, para isto, devemos definir uma sintaxe e uma semântica, de
forma a permitir uma única interpretação das instruções num algoritmo.
Estrutura um Algoritmo
Algoritmo Nome_Do_Algoritmo
variáveis
Declaração das variáveis
Procedimentos
Declaração dos procedimentos
15
!
"
Funções
Declaração das funções
Início
Corpo do Algoritmo
Fim
Identificadores
Representam os nomes escolhidos para rotular as variáveis, procedimentos e funções,
normalmente, obedecem as seguintes regras :
4. O primeiro caracter deve ser uma letra
5. Os nomes devem ser formados por caracteres pertencentes ao seguinte conjunto :
{a,b,c,..z,A,B,C,...Z,0,1,2,...,9,_}
6. Os nomes escolhidos devem explicitar seu conteúdo.
Variáveis:
Unidades básicas de armazenamento das informações a nível de linguagens de
programação. Os tipos de dados e variáveis utilizados dependem da finalidade dos
algoritmos, mas, podemos definir alguns, pelo fato de serem largamente utilizados e
implementados na maioria das linguagens, sendo estes:
INTEIRO : qualquer número inteiro, negativo, nulo ou positivo.
REAL : qualquer número real, negativo, nulo ou positivo.
CARACTER : qualquer conjunto de caracteres alfanuméricos.
LÓGICO : tipo especial de variável que armazena apenas os valores V e F, onde V
representa VERDADE e F FALSO
Declaração de variáveis
Para que os programas manipulem valores, estes devem ser armazenados em variáveis e
para isso, devemos declará-las de acordo com a sintaxe:
NomeVariável,... : tipo
Operações Básicas:
Na solução da grande maioria dos problemas é necessário que as variáveis tenham seus
valores consultados ou alterados e, para isto, devemos definir um conjunto de
OPERADORES, sendo eles:
•
OPERADOR DE ATRIBUIÇÃO:
NomeDaVariavel ← Valor ou Expressão Atribuída.
16
!
•
OPERADORES ARITMÉTICOS:
+ = Adição
* = Multiplicação
- = Subtração ou inversor do sinal.
/ = Divisão
•
"
Quociente = Quociente da divisão de inteiros
Resto = Resto da divisão de inteiros
EXP(a,b) = Exponenciação ab
FUNÇÕES PRIMITIVAS: SEN(x); COS(x); TG(x); ABS(x); INT(x); Raiz(x);
PI( );
• OPERADORES RELACIONAIS:
São utilizados para relacionar variáveis ou expressões, resultando num valor lógico
(Verdadeiro ou Falso), sendo eles:
= - igual
< - menor
≤ - menor ou igual
≠ - diferente
> - maior
≥ - maior ou igual
• OPERADORES LÓGICOS:
São utilizados para avaliar expressões lógicas, sendo eles:
e - e lógico ou conjunção.
ou - ou lógico ou disjunção.
não - negação.
PRIORIDADE DE OPERADORES:
Durante a execução de uma expressão que envolve vários operadores, é necessário a
existência de prioridades, caso contrário poderemos obter valores que não representam o
resultado esperado.
A maioria das linguagens de programação utiliza as seguintes prioridades de operadores
:
1º - Efetuar operações embutidas em parênteses "mais internos"
2º - Efetuar Funções
3º - Efetuar multiplicação e/ou divisão
4º - Efetuar adição e/ou subtração
5º - Operadores Relacionais
6º - Operadores Lógicos
OBS: O programador tem plena liberdade para incluir novas variáveis, operadores ou
funções para adaptar o algoritmo as suas necessidades, lembrando sempre, de que, estes
devem ser compatíveis com a linguagem de programação a ser utilizada.
17
!
"
COMANDOS DE ENTRADA E SAÍDA :
No algoritmo é preciso representar a troca de informações que ocorrerá entre o
mundo da máquina e o nosso mundo, para isso, devemos utilizar comandos de entrada e
saída, sendo que, a nível de algoritmo esses comandos representam apenas a entrada e a
saída da informação, independe do dispositivo utilizado (teclado, discos, impressora,
monitor,...), mas, sabemos que nas linguagens de programação essa independência não
existe, ou seja, nas linguagens de programação temos comandos específicos para cada
tipo de unidade de Entrada/Saída.
Comando de Entrada de Dados
Leia(variável_1, variável_2,...)
Comando de Saída de Dados
Imprima(expressão_1, expressão_2,...)
COMANDOS DE CONTROLE DE FLUXO:
Para representar a solução de um problema devemos escrever o conjunto de passos a
serem seguidos, sendo que, a maioria dos problemas exigem uma dinâmica na sua
solução, impondo assim que os algoritmos executem conjunto de instruções de acordo
com as possíveis situações encontradas no problema original. E de acordo com a
Programação Estruturada os mecanismos utilizados para esse controle são :
Sequência, Seleção e Repetição.
•
SEQUÊNCIA : usada para executar comandos passo a passo, sabendo que
todos eles serão executados na ordem de escrita, sem nenhum desvio. Uma
sequência pode possuir um ou vários comandos, os quais devem ser delimitados
pelos identificadores Início e Fim.
Inicio
Comando_1
...
Comando_n
Fim
•
SELEÇÃO : usada para tomar decisões, ou seja desviar a execução do
algoritmo de acordo com uma condição, podendo ser simples ou composta.
Simples
Se (Expressão Lógica)
Então Sequência_1
Composta
Se (Expressão Lógica)
Então Sequência_1
Senão Sequência_2
18
!
•
"
REPETIÇÃO : Serve para efetuar um conjunto de ações repetidas vezes. Existem
três tipos básicos de repetições, sendo elas.
Enquanto (Expressão Lógica) faça
Sequência
O comando Enquanto analisa a Expressão Lógica e
enquanto o seu resultado for, o valor lógico, Verdade a
Sequência é executada.
Para variável ← valor_inicial até O comando Para incrementa, a variável, a partir do
valor_inicial de uma unidade, até que, esta atinja o
valor_final faça
valor_final. E para cada incremento a Sequência é
Sequência
executada..
O comando Repita executa a Sequência até que o valor
Repita
Sequência
retornado pela Expressão Lógica seja Verdadeiro
Até (Expressão Lógica)
TIPOS DE DADOS
Estruturas formadas por um conjunto de variáveis, permitindo modelar de forma
mais natural os dados.
VETOR: estrutura formada por um conjunto unidimensional de dados de mesmo tipo
(homogêneo) e possuindo número fixo de elementos (Estático). Na declaração dos
vetores devemos informar o seu nome, seu tipo (inteiro, real, caracter, ...), e seu
tamanho (número de elementos). Cada elemento do vetor é identificado por um índice
(unidimensional), o qual indica a sua posição no vetor.
Declaração :
NomeDoVetor : vetor[nº de elementos] de Tipo do Vetor
Referência :
NomeDoVetor[índice]
MATRIZ: estrutura semelhante ao vetor, sendo que, pode possuir n dimensões. Desta
forma para fazer referência aos elementos de uma matriz, precisaremos de tantos índices
quanto for suas dimensões.
Declaração :
NomeDaMatriz : matriz[dimensões] de Tipo da Matriz
Referência :
NomeDaMatriz[índices]
REGISTRO: estrutura formada por um conjunto de variáveis, que podem possuir tipos
diferentes (Heterogêneo), agrupadas em uma só unidade.
Declaração :
NomeDoRegistro : Registro
19
!
"
Declaração de Variáveis
FimRegistro
Referênca :
NomeDoRegistro.NomeDaVariável
Obs: Podemos ainda definir um vetor formado por registros.
MODULARIZAÇÃO
A modularização consiste num método para facilitar a construção de grandes
programas, através de sua divisão em pequenas etapas, que são : módulos, rotinas, subrotinas ou sub-programas. Permitindo o reaproveitamento de código, já que podemos
utilizar um módulo quantas vezes for necessário, eliminando assim a necessidade de
escrever o mesmo código em situações repetitivas.
Procedimentos - Um procedimento é um bloco de código precedido de um cabeçalho
que contém o Nome do procedimento e seus parâmetros. Com isto, podemos fazer
referência ao bloco de código de qualquer ponto do algoritmo através do seu nome e
passando os seus parâmetros.
Declaração :
Procedimento NomeDoProcedimento [(parâmetros)]
Variáveis
Inicio
Comandos;
Fim;
Onde, parâmetros representam as variáveis que devem ser passadas ao
procedimento. Os parâmetros podem ser de : ENTRADA (passado por valor) ou de
ENTRADA/SAÍDA (passado por referência). Os parâmetros de ENTRADA não podem
ser alterados pelo procedimento, para que isso seja possível o parâmetro deve ser de
ENTRADA/SAÍDA Para indicar que um parâmetro é de ENTRADA/SAÍDA devemos
colocar a palavra VAR antes da sua declaração.
Referência :
NomeDoProcedimento(variáveis)
OBS: As variáveis passadas aos procedimentos são associadas aos parâmetros do
procedimento de acordo com a ordem das variáveis e da lista de parâmetros.
Funções - Uma função é semelhante a um procedimento, sendo que esta deve retornar,
obrigatoriamente, um valor em seu nome, desta forma, é necessário declarar, no
cabeçalho da função, qual o seu tipo.
Declaração :
Função NomeDaFunção [(parâmetros)] : tipo_da_função
Variáveis
Inicio
20
!
"
Comandos
NomeDaFunção ← (expressão de retorno)
Fim;
Referência :
NomeDaFunção(parâmetro)
6
#
=
.# /
%
%
%
.
'
B
)
9% (
9
//
0/
%
(
/%
(%
#62 #(
1
)
% %
1
%
-
S
. B
1
1
%
9
%
R
)
E
%
G@
%
R
>@
U@
O
T
.
%D
&A @
U@ V<RW @
21
.
9
F 06## !6 2 (
6)
-
%D
-
%
( %
G
/
!(
%
%+%
!
@' " 1
%
,
'
.
.
!
6
#9
%
(
. 6)
U6#0F6H6F >
6#2FB2BF #
60/
#M (
1
%
'
#/
!
9
)
%
$ *
1
(
K6F >
% '.
%
6
"
#/
!
'
'. 6
E
22
.
. 6
M
2
9
.
(
!
B
%
%
&'
P ),
.6
0/
0K # %
9
. B
"
+
) 1
)
%
1
%
%%
1
%% . 2
1
-
)
)
&'
)%
1
%
.
%%
%
%% (
&' (
K
%
%
2 (
) %
%%
I
6 IB
'
) 1
%
%
(
%%
'
%
%%
1
- )%
:%
'
%
%
.#
%%
)%
-
F
-1
:%
%
;
23
&' %
%
F6 62/
F X 2CIB6:%
%
&'
.
61
%
'
&' ; -%
1
)%
1
&'
%%
%
%%
* - )%
%
%%
% .
(
;(
!
!
9
(
%
1
B
"
%
G
%
%D
%
U
B
%$
?
)
,
%
,
%D
%
0
:
+
9
%
0
%
% %
;.
+%
%
%
&A .
24
1
!
2
)
"
@ "
8
%
,
#9
9
,%
!
=" !
%
Y,
%
F
$
&'
G
1
1
)
1
"
1
"
G
-
9
1
,
-%
.
9
)
%$
%
,%
9
-
..
.
25
%
!
9
-
)
"
%
9
.
% A .
9
&'
,
)
. 6
,
,
-
%
&' .
9
-
E
8
,
5
) % &' .
,
<
$ . C 1 1
) % &' .
6
%
) .
(
)
<
E
%
,
1
.
!
)
%
1
%
%
,
)
,
)
%
-
. 6
"
,
# $
( %
) % &'
.
@
'( #
6
S#5
9
Z
4T
'
F
%
1
'
8
8
%
G
( %
9
&' -
,
% %
%
1
.
)
26
%
( %
%
,
%
1
.
!
,
%
>%
[(
%
>
&'
". K
<
&'
@
) V< )W R@
1
&' -
,% .
@
)
"
%
)WR@
. 6
%
9
@
#
)
)WR@
-
,
.
@
'( # ! ) #
#
6
9
-
%
,%
;.
:
%
9
%$
S
&A
:
T -
-
) \ %
%
%$
G
6
9
I
-
.
9
8
S
T - )%
1
(
1
%
%
,
%$
'
G
!
0
% %
%$
1
E
1
.
S %
%
'
) :
#"
%
;
9
8
%
.
) :/
F "
-
%
% )
!
;.
E %
% '.
1
T. C
;. 6
T
F #"% G
-
)
)
0
%&' -
%
%
;.
F
%
%
S
+%
9
' * %
)
1
A
,
,
' %
:2
$ %
27
%
)
A
. 6
!
&'
)
,
)
%
$
1
-
'
.
#F""# G
1+%
%%
9
%
%% .
'
;
%
I
"
F
&'
%%
:
-1
' 1
%
&'
) % &'
)
;
28
'
%
1 .
%
%
!
)
"
! &
%*
! "0!
&
-
1
! #
-%
:
1
(
%
%
$
'
%
1
;
(
%
$ %
&' . C( %
%*
(
(
'
]
"
)
% (
)%
<
:%
)
;
.
%+%
%
&'
%*
)
+<
1
(
1
:
1
;.
6
%
%*
(
? #/
0( 1
%*
9
$
%
:
/
8%&'
9
+( %
- . '
)
%
$
<
;.
#!
'
#
'
'
! "0!
&'
H
%
6
&'
9 %
-
H
&A
G
-
9
'
%*
&'
&' ( %
$ %
%
%
%
@
@
. 2
-% %
.
H
' $,
%
^
0;(
( %
U
%
_
$ G
3
%
%
%
%
%
9
%
( %
%9%
&'
(
%
K
:1
%
0. 2
-
)
%
%
29
'
%
%
.
!
.
'
9 (
' $,
0$ :;(
:;( 0
%
H
(
5:;
%
<%$
/ %:;( #1 :;(
&'
%
H
* %
' -
:;(
A (
%
(
H
%
.
G
' ..
)% &'
$
/
..
( %
"
-
%
%
..
'
..
?, %
%.
%
.
%
$ %
.
%*
/%
,%
'
%*
@
% (
E%
,
$ (
(
E%
<%$
( %
0
,
-
G
@
&' G
G
G
# %&'
%
&A
%
# %&'
0
$
-%
<%$
. 6
8
,
:
A
;.
%
&'
%$
,
( 1
%
-
E
$
$
,
$
1
G
9
(
-
%
-
<
%
( 1
<%$
%*
-
1
%&'
%
%
H
%&' 1
%
% .
%
.6
)
)
.
H
%
%
@ @(
%
,
(
'
-
%
,
G 1
1
$ .
'
$ G1
30
)
!
8
%
%
,
,%
&
( 1
%
"
,
$
( %
@@
.
2
6
+
- G
(
<%$
%
1
( %
H
%
1
%
* %
'
:
:
;.
1
' +
&' ;G
G
%
,
(
%
%
,
-%
(
8( %
%
.
%
%
%
G
,
(
8( %
(
8( %
.
% G
H6F
,
6/
F
K# .
H
-
-
<%$
%
(%
%
%
E
(
(%
-
%
`
V
<
%
<
,
,
aG
V
9
(
%
%
%
.
,
%
,
(
$
.
&'
,
%
& %
<%$
(
) G
<
.
'
'
%
9
%
)% &'
%&'
<
.
&
:
A ;.
,
&'
,
(
&'
, ) %
H ,
V
8(
.
G
%
-%
<
V
+
<
aG V
@
b@
V
,
<
<
<
<
<
a
<
a@
c
@
a(
,
a(
V
)G
31
V
'
a
'
<
<
a
!
V
aG V
'
<
%
1
6)
a .. V
H
.
8
%
(
-
V
(
<
<
%
a
V
)
"
<
%
a%
<
1
V
<
a
V
<
a
a.
G
%
&
'
() '
&
% &%
*
(+
+
(,
-&%
*+
+
.)/+
+
(,
0 0
-
&
&
1
%
'
$,
%
&' G
$ .
% G
bRc
9
bR c
(
%
,
&'
%
1
-
R
( %
%
R[
b ( c
( b (dc
( b (R c
( bR( c
( bR(dc
( bR(R c
( ...
,
H
%
* %
-[
9 %
%
- bY(R c
.
,
9 %
E
:%
-
;.
)
%
0
!
( %
+
'< " G
%
'
G
-%
%
&' .
%
%
&'
H
"
-
'
%
-
)
.
9
H
'
G 1
1
%
%
.
%
:@
;.
K0 " G
H6F
32
6/
F
%
(
(
,
$
E
K# .
)%
.
!
&'
1
%
<
)
A
,
,
,
%
%
-%
;(
1
1
,
1
)
%
V<.
9
'
(
:%
1
(
,
$
.
)
%
-
"
&A (
,
%
G
12 3
'
(12 (+
4
'
12 '
(5
% *
(,12 % *
(,5 ! 63$
-*
3)7,12 8
.2 4
0 0
-
12 9 :
%
12 ;<= >
%
%
:
(
+
%
9
8
%
) ;G
+
! ! !!
#
:V
<
<
,
a;
F%
(
% 8
'
V
% %
;. C
$
#%
H8
)
?
% ?&
:;
<
<
,
,
)
G
(
@
!
?$
33
,
a :%
0.
<
%
(
!
"
% !
?$
"
,
@
! ! !!
" $ :V
<
< )
A a;
6%
9
. 6
,
(
)
A
1
%
A
V
<
%
< )
E
% %
)
-
$
0 %
(
(
%
[
& (
$
<
%
:V
< )
%
e :
6)
%
%
,
,
1
'
%
%
(
(
<
)
.
%
%
%
& 1
%
G
@
5G
G
&
E %
)G
G%
%
9
%
:)G[;
,
;.
@)
( -
.
A a;.
( %
4
%
.
"
<
1
8
5 %
/+ %
1
T
%
%
%
. C
1
)
( %
:5G"G ;
S
.
E
A
0.
&
% %
)
%
:;
E
,
)
%
%
%
U
'
4
-(
A a.
9
%
H
%
%
%
)V< .[
5V< "
34
:; %
$ . C
%
1
!
V< @
"
@
V< H6F
6/
F
%
:@
)@
( )GYGR( 5W`GY;
%
: ( @ 3@
;
6%
G
%
: ( @ 3@
;
6%
G
%
: W @ 3@
;
%
:;
$
@
6
%
%
(-
%
! "
)
%
V
2
6/
F
-%
A
%
&' . I
,
%
$ ;
A
'
%
$ ;
3:
G H6F
(
$ ;
3:
)
1
d
3:
G
H
&
G ) .[
6%
6%
1
%
6%
8
%
<
&
<
,
%
( %
:
6
1
%
H
A
1
.
)(
&'
;.
&'
%
(
%
%
&'
'
)
G
% !$
;
35
*)
%
%
.
<12(5A
B
)
3?"
% &'
6)
,
%*
%
1
%
&'
!
(
a@
%
1
%
#! =
#/
0
%*
%
* %
!
!
"
"
% '
'
&' .
1
%
- %
1
1
S
T.
:%
%
0
% '
;
% '
!
V )
"
.
' #
'< * % a
V 1f+ % <
<%
a
%
#
%
!E
%
(
H6F
6/
F (
a:
$
K# (
H
V )
%
$
V 1f+ % <
%
%
;
'
)%
'
%
2C
<
. #
) % &'
$
1 ?
' < * % a.
.
D
1 EF
2
2
2(D
1 EF
2
2
2 D
"
%
V )
'<* % a
<%
H6F
(
&'
6/
F (
<Ra :
$
%
$ %
) % &' %
; '
$
K# (
%
%
)%
1
(
. #
$
%
$ %
)%
'
)%
6
V 1f+ % <
V 1f+ % <
(
<%
< a : -
;.
%
' $,
1
... $
%
... $
% :%
36
...
% .
;(
!
1f+ %
%
.
%
8
,
!
$
"
:%
4 %$
% $ V )
%
%
*# #
H
:
<%$
.
4
%
'
H
%
"
%
&A ;
0;.
'<
<
) -
%
%
G
&' a
V ) RRa( V ) R a( ...( V ) R a
V 1f+ % <
%
<%
V ) Ra( V )
V 1f+ % <
<Ra
a( ...( V )
<%
< a
<%
< )
a
...
%
V 1f+ % <
a
% $
H8
)
(1
@
2
%
1
@
&
% !B
!
"
A &$
$
;
) ;
) '
% !H
I
% !H
% !H
) G
"
+$
) I
)
)
+$
+$
"
"
37
J
%
G
!
7
!
6
%
%+%
0
+
&' %
G
... ...
1
%%
%
... %
4$
...
... %
%%
Z$
X
%
...
0;(
...
...
-8 ) "# "
%
:U
U
;
:
:
"
%
^_
%
%
0;
...
0;.
) - ) %
:
)
G
!
&
6
1f+ %
%
E
.
V
,
a
V
V %
ac %
V 1f+ % < <%
<
,
a
,
&A
<
V
<
%
a
a
1
%% .
%
C
A
ab
%
'
,
%
E
%
(
(%
.
)
%
' 1
% %
' 1
,
)
%
% %
% & .
%
.I
()
, %
%
%% . I
'
V %
a
1
- V %
a.
)
' V %
) % &'
'
/ %
.0
%
a(
<
,
C
C
V %
V
%
)
V
a
a
C
V
%
%
%
(
%
&'
,)
%
% %
' 1
, %
&' ' a -R. H
9
% %
(
a
,
&'
%% .
1
%
%
(
1
&'
%
&'
(
(%
.
1f+ %
1
, %
V
<
38
%
%$
(V %
a. #
!
:
(1
1f+ %
%
%
, (
) % &'
%
1
8
%
V
<
%
a( V
<
) % &'
%% (
$
) % &'
)
A
)
%
%
V %
, )%
a
V %
a
;(
U
,
*
.
a '
'
&' (
1
"
E %
,
.
(
E
R
R
'
)
.
KL
( (
% M
&
M
(
( "
% !
M
&
3$
"
"
/
G#(
1 V
<
%%
'
, )%
.
K
9
%
a:
$
(
&' ( V
V %
)
(1
.
(!
"
(
%
< % a
a
'
$
% M
&
M
(
("
% !
M
&
3$
"
"
6
)
(
K
(
(!
,
"
% M
&
M
(
(
% !
M
&
3$
2("
"
"
-- ) "#
61
...
3
&
39
%
$
<RG
;(
!
6
%
1f+ %
% %
&' :
%
-
1
)
"
' * % ;
.
1
V )
V 1f+ % <
1
<%
'< * % a
a
%
6
V )
'<* % a
)
' 1
%% . I
V 1f+ % < <%
-
%
H6F
a- )%
&'
6/
F (
.
/ %
V 1f+ % < <%
a 1
.0
1
) % &'
<
9
%
%%
1 V )
'<
* % a 8
.#
&'
H6F
6/
F ( V 1f+ % <
%
a
, )%
U%
%
, (
) % &'
,
%
*
1
.
1
)
,
(
<
%
&' G
KL
( ( !
E
+
+
+
"
$
% M
&
M12 (
E
M1N ( "
% !
M
&
3$
M12 M5 (
"
E
"
/
G0
)%
%%
)%
-+ ) "#
H
6
%
&' :
1
1f+ %
.
<3
... %
%
%
(
&'
1f+ %
,
F" !G
1f+ %
% %
%
-
.
40
-1
)
' * % ;
8
!
V 1f+ % < <%
V )
'<* % a
a
/ %
9
%
%% .
/ %
V )
* % a
'<
V 1f+ % < <%
.0
1
%$
V )
'< * % aG
K# (
%
' )%
U%
%
, (
,
%
$ .
0
)
KL
"
a
(
$
) % &'
*
G
( ( !
$
% M
&
M12 (
% !
M
&
3$
M12 M5 (
MD (
"
/' # ! !"'
! "0!
- & '
)
% %
%
%
!
#
'
!
/' #
)
-
1
R
.
12 @
12 @
I<O< 12 (<PH( ;<Q
=BO ! $
@
B DN BKPR>
12 5
12 5(
;
B@
; I<O<@
S 12 8
41
E
$
!
B
OB'BO !<
+
:
:&)
S$
/' #!
6)
% $ %
%$
#
'
1
%
"
'
! "0!
,
:
D
;1
-
'
&' G
"
SS
'
!
<
:
)G
:
$
> <
:
> < 122 < 5 G
! > <$
"
,
/' # !
,-
"
"
' #'
"
SS
'
%A
'#
!
' %
! ) A$
T
! 5 A$
U@
, + )I)JJI $ I)KI
A
SS '
5 A@
!
)
A$T
U
,, ) (#
N 5 A+
,2
"
A
O
#9
SS
'
!<) G&
$
&
@
&
N < 5 G@
@
,1 L ;#
#
&
&
2D
AN 5 A
2D
22 !
&'
%*
$
(
%
.
42
-%
%
!
,
$
"
SS
"
'
!
% () %
"
$
T
!
!
% ($5
!
%
$
$
@
U
#
A
%
,
"
&' (
U
SS
&A
'
<
<
E%
*
* A,
,*
%
E%
.
& &
A,
,
, 4 & "#
"
A
O
SS
'
!<) G&
&
N < 5 G@
@
,7 & #
A
SS '
T
V!
W ()W
$N X0@
W (5 W
@
U
, -8
&L&
SS
"
'
!
W' <) W' G$
T
!
W' < 5 W' G$
@
U
, -SS
, -+
"
& #
'
!
<)G)O
&M 9
SS '
5A
! "
, -1
"
6 "
SS
<5G+
! ) A$
&
, -,
(M
"
0 0
0%
5A
"9 '
! A
$
&
2O
! ) A$
!
?V$ !
?5 V$
$$
'
! )A$
43
$
&
@
!
SS
'
"
N 5A
"
,-
#6 "
SS '
"
SS
'
N
!
AV%
) AV% A
$
5A
"
2
" "
!
#
(
'
-
.
&'
-
2
<
%
% (
% &'
Z (
8
%
(
%
%
%
-1
&'
8
,%
-%
&' . 2
%
<
(
%
(
' %$
%
(
&'
*
%
%
)
'.
%
.
%
*
%$
1
-
- %
-
(
. C
) % &'
%
%$
*
)
P,
B
%
&' (
1
) % &' .
%
%$
1
)%
( 1
%$
6
'(
' %
&' .
(
-
) % &' .
&'
)
%
%
%
%
.
)
%$
G
44
(
%
%
!
1
)
"
! $
5$ #
0
(
%$
: '
,
"#
%
#( #
-
%
,
)
(
&A
$
9
1
%$
;.
-
-
9
+
D
%
%
: '
<$
: '
1
(
G
'
1f+ %
%
1
% %
%
&' .
%
( -
,
.
D
1
%
,
%$
%
( %
'
1
*
%$
1 (
,
;(
;( 1
"
%
%
%
+<
%
.
*
%
&'
& " !'
H
%
:
&'
-
1
:%
&' 1
%
%
&'
)
,
%
;(
$
:
$
;
0
&' ( 1
%
%
(
)G
%
%
'
'
% ;. #
%*
V
&A <
<
# %&'
D
%
<
<
%
a
b:V 1f+ % <
<
a;c
&A
/
%
# %&'
0
%
V
<
%
<
D
b
<
%
a
,
acV 1f+ % <
%
.
(
V 1f+ % <
1f+ %
<
D
aG V
45
<
<
a
<
%
&A <
!
9
%
.
%
D
,
D
<%$
%
, (
.
:
-
<
D
a-
1f+ %
%
;
9
%
.
,
%
;
+% U%
( V 1f+ % <
,
& :
"
%
& %
<%$
(
(
%&'
%
%
&'
%
)G
V
<
<
,
*)
aG V
)
<
<
(
a
-
% %
Y
R`; 1
%
%
\d :
(
8(
,
,
.
D
-
%
, (
9
<
%
%
,
%,%
,
%
:
(
)
G
?&
8
8 )
% Y%
?12
5
12
?
A
"
%
$
%
G
12 .
12 27
%! $
)%
%
D
(%
%
)G
46
(
)
, 9
,
,
-
%
;(
!
!
?)V&
8
8
:% Y%
"
$
A
12 ?5 V
"
%
$
%
G
12 .
12 27
!) $
%! $
D
.
%
)
%
(
'
&G
1
) % &' (
,
,
%
%
D
(
%
%
%$
.
<
%
) % &' .
E %
%$
1
.
%A
&' -
1
%
0;.
%
(
,
%
$
%
D
<
<
%
<
<
&A
,
&'
%
%
V
# %&'
H
%
a;c
GV
:%
&' a
(
&'
)
b:V 1f+ % <
<
%
)G
&A <
<
a
/
%
# %&'
0
%
V
,
-
<
.
<
&' a
%
(
%
V 1f+ % <
1f+ %
47
<
%
&A <
<
D
a
!
b
cV 1f+ % <
<
D
aG V
9
%
.
& :
D
a
%
;
<%$
+% U%
%
, (
.
( V 1f+ % <
:
-
<
D
9
1f+ %
%
.
&'
&' :
a-
%
;
%
<
D
,
,
<
"
*
,
% %
;. 6
(
&' :
;(
%
-
.
,
%
%
& %
<%$
(
(
%&'
%
%
&'
%
)G
V
<
<
H
,
aG V
)
Y
%
<
<
a
(
1
\d(
&'
% %
%
D
. 6
-
)
,
%,%
9
<
"
,
G
&
%
?&
8
8 )
?12
% Y%
A
5
?
"
"
%
$
%
V< Y
V< <d
48
G
(
!
"
V<
%
:
;
#
,
%
D
&'
(
%
:)(5G
%
G
;G
%
)W 5
%
%
$
%
G
V< Y
V< <d
V<
: ( ;
%
:
;
4 &
'!
N'
= ?"
P,
D
G -
'
+% .
%
(
( 1
1
D
% &'
,
-
+%
'
:
%*
%
,
1
,
,
;(
)
D
(
:)(5G
%
% (
U
%
V< )W 5
%
49
.
-
.
%
)
D
%
E
.
,
&'
.
D
,
%
H
,
1
(
-
(
&
) % &'
H
%
+% G
G
;
!
%
$
"
%
G
V< Y
V< <d
: ( (
%
:
7
"
;
;
$! !
F%
-
%$
1
.
%
&'
E
"
) % %
1
"
!
%&
%
%
D
%
G
$
&
%1N
%
%6"
!
%2($
"
"
"
-8
! !!
5$
/
2
A
%
%
:% + %
;G
F
:
:
2
`;
:0
%
0
%
* % :2
`.RYR";
2
S T
SRT;
;
6
%*
,
6)
2
%
%
) %
%&' H .
G
50
%
&'
!
"
)G
5G
G%
G
%
%
6
0
%
0
(%
%
&A
(
)
%
%
(
(
(
)
.
(
%(
%
.
--
!
'< "
,
(
-(
. #'
W(< 6)
'
%
E %
-%
%
G <`( W). 6 1
,
(
W
+% .
<
'
.
'
e
%
.
+%
% &'
W
%
<.
%
.
&' (
&' ( h
%
,
%
%
'.
g . 2
( [e
'
-%
W(<(h(
)
+
&' (
%
&'
+
%
1
+%
&A ( -
1
)
'
-% .
*
i
)
(
:
-(
i ` g . 2
'
%
%
%
: 1
WW ( <<
1
;.
+%
.
% &' .
j
'
)
( [j
+%
g [. 2
-%
+
,
;.
B,
1
51
%
!
%
.6)
1
g WR :
1
0G WW -
$
WW
<<;. K
WW k
&'
G
(
0
*
%
-
%
%
.
&'
;(
:
%*
&'
:
,
%
%*
)
-+
G@
F @W @
-( %
%
&'
. I
%
;
%
!
@
%
%
@
-%
@g @
F
@
.
#"
F
%
G
(
g( V(
(
a(
&'
Vg(
` g` : ` `l;
ag(
@
?@
Va
1
0
-,
-
%
%
+
-
- %
*
%
gWW
%
&'
<
%
&' . 6)
?g WW.
%
"
!
1 (
. #'
1 (
(
A * %
. 6)
G
6/
F U@ @a @
?@:@ @ ,
K# . K
<
%
mg.
)
H6F
- % l;
Va -
6 #
,
&' .
K# g H6F
6/
F .2
* % . 61
H6F
%
2
6/
F g
+%
%
K# (
m
0.
1
H6F
. 61
* %
0.
1
* %
K
%
H6F
6/
F
. 61
n
n
%
oo
0.
1
>
(
'
6/
F 1
F
)
H6F
K#
6/
F
. 61
0.
) %
52
* %
> F
%
!
-2 ."9
!
"
/
B
%
%$
-
) . 6
%$
%
) 1
%
%$
#6IBJ 0/ /
#
%$
K6 2pF/ #
6
%
F
% &'
1+%
G
q!/
0 #
%
%
1
(
K
* .
1
%$
&'
'
'
0
1
6
%*
*
).
1
H
,
1
1
6
%
%
R; #
1
-
%
9 %
%
'
; #
%$
%
H
< ) (
% %
-
&' (
1
%
)
.
.
G
1
1
%
.
)
(
%$
(
H
,
(
,
.
H
9
(
1
-
,
-
&' .
`; #
%
%*
@ %
$
Y; 0
(
@
1
%
,
%
%
%&'
%
9 % (
&A
:
A
,
...;.
'
8
1
%
%
$
H/
#B KO.6>6
$ (
%
,;. 6
H
:
%
53
,
%
( '
+
)
'
!
'U
%
(
%
)
)
1
H8
<
' :
%
V
V
% % &'
)
)
( . )( .
1
<
1
a-
%
%
G
+?
% ?)V&
?
(
(
%.;.
a
E %
E %
(
%
-G
<
<
1
"
4"
!
V$
"
"
54
%
:
;.
!
/
! %
' #'
' )!
#
/+
( ;
%
!
#
'
I
-
/+
3 B?
%
#
" ?
/+
4 =
!
/+
[ ;
# )
$ B
!
$
\
/' # !
'
H
')
)
%
0
%%
&'
9 (
%
:K
0.
% % 0
<
mmm;. 6
1
%
$
%
/+
.
%
!
Z
/+ S
4
"
.[R
P
%
!<
%
%
%
)
%
%
%
&A
&' - ) %
#
0. 2
%%
G
%
R.
,
%
&'
% %3
)%
6
.6>6
55
'G
0
!
. 0
K
%
:
;
`. 6) %
.#
.
%
0
0
&'
0
3
K 3.
)
$
,
)%
/' # - O 0 %
&'
8
)%
Y. 0
(
%
<
' -%
.#
%
F
%
%
! )0!
#
'
@
!
R
## + 8
r
@
&' G 0 %
G
H
H
%
!
G
<RR<
"
% %
!
g#
r
' R.
$
( G
(
(
G
#
"
%
#
&'
V<
V<
V<
V<
V<
1
" $#
:@
#
1
1
G@
;
: ;
0%
1
V<R
%
%
="
56
4.
F
-
'
%
Z
.
&
"
# !
:
;
!
" $ :@
"
@
;
" $#
:;
:
#
;
V<
W
='
V<
" $ :@ !" $#
:
=' #
.# /
2
-g@
;
;
'
'
F
;
/' #+O0 %
&
! )0!
.# /
'
E
'
-R
## + 8
F
;
/' #,O0 %
&
! )0!
.# /
'
[.
'
## + 8
F
;
/' #2O0 %
&
! )0!
#
'
%
'
@
0 %
## + 8
rr %
&' G 0 %
&'
G
E
r rR @
%
%
R
%
:;
!
G R<RR<
"
H6F#M R.
$
H
G
57
.
.
!
%
= "
%
: G
;G
$
(G
"
V<R
V<
R
<R = "
V< h
='
='= "
/ %
% %
V< %
:R ;
" $#
:@
=' #
.# /
'
' #'
s %
R g@
(
;
'
F
;
%
'
@
%
%
:
')
.$@
;U
:;
58
"
!
"
^
U
g %
:@
:R ;U
%
R gi e @
(
;U
_
%
:
;
^
(U
gRU
: g UagRU
<< ;
^
g hU
_
U
_
/' #
1
O
0 %
1 &'
)j W?)W0g (
&
G>Rg Wn n
.
! )0!
#
'
'
## + 8
@
0 %
F
61 &'
@
&' G 0 %
gg
%
>RFV<::< W 1 :
> FV<::< W 1 :
>R V<
> V<
0 #
6K2 #6
;; : h ;;
!6
F IB6 6 2M
)R V<:< ; : h ;
)R V< #IF2:< 6K2 ; : h ;
) V<)R
) V<<)R
%
G
G
!
<RR<
# %&'
%
(?(0(
V< j <Yh h%
"
&A
()R () ()R ()
1
1
%
mg
59
;; : h ;;
t O
!
$
(?(0(
()R () ()R ()
U
"
# %&'
0
K
(?(0
1
%
mg
:@ g@
;
: ;
='
: Va ;
" $ :@
?g@
;
#
F6G
K
0
" $ FB)PBG
:0;
0 %
V< j <Yh h%
:
ag ;
)R V<::< ;W#FI2:
;; : h ;
) V<::< ;<#FI2:
;; : h ;
)R V<
) V<
)R V<:< ; : h ;
)R V<#IF2:<
; : h;
) V<)R
) V<:<)R ;
='
6%
%
)
" $ :@
>Rg@
;
" $ :)R ;
W@
;
" $ :@
60
"
!
" $#
:)R ;
6%
%
)
> g@
;
" $ :@
" $ :) ;
" $ :@
W@
;
" $#
:) ;
2
=' #
.# /
'
' #'
'
F
;
%
'
s %
V
.$a
s %
V
$.$a
')
61
"
!
:
;
^
h0 %
1 %
O
!
HR.
<RR< "
/
!
F2
26G
% %0
% &'
0
%
&' B
5
68
8
8
S
-
8
8
'
DN
8
8
%
-
"
<N )GN ) N )S
"!
N )](ON )]( N )] ON )] N @
-
8
8
=
"
B^ <?_ 5G?5 N `
$
@
<
T
"!` <N $
@
"!a" ) b<$
@
U
c
!
<NN $
@
8
8
=
"
G
"!` GN $
@
"!a" ) bG$
@
8
8
=
"
"!`
N$
@
"!a" )b $
@
8
8
I
-
8
8
S
S
N!
G6G2.6<6 $
@
8
8
"!
S
DN
DN $
T
](ON!
!
2G$
5E !
S
] ON!
!
2G$
2 E !
S
]( N @
] N @
U
T
](ON!
2G$
8
! 6<$
@
62
$
$
8
! 6<$
@
$
$
8
! 6<$
@
"
!
]( N E !
2S
$
8
! 6<$
@
] ON](O@
] N!
2]( $
@
U
8
8
B
%
-
"
?
5d
Ad
"!` 2222222222222222222222222222222222222222222 $
@
"!` O -
BE
a"]_ 5a"]5a"N )<)G) $
@
"!](Na( +"5a( +"`
)](O)" A !
]( $
$
@
"!] Na( +"5a( +"`
)] O)" A !
] $
$
@
U
63
"
!
44
M
B
E
5-
%
1
%&'
,
%
% .
+
%
5. /
:b c
;
)
Y
5
:
Notas[1]
%
R
Y;.
Notas[2]
%
( %
S
G
9 %
0
%
-
Notas[3]
9 % . 6
/
1
'
.
+
.
9 %
,
'
6
$
%
%
"
%
Notas[4]
8
,
,
-
T
1
N
.
.
%
&
R. 6
F
H
?
1
R.
) 5(
$
%
%
%
9 %
%
9 % .
Notas
1
2
3
4
87
93
77
82
64
%
!
5
E
-1
%
%
%%
%
5
%
%
:
-
)
G0 %
-
)
!
!
"
#
$
%& " #
' !" #(
65
;.
) &'
.
6
"
Y
%
%%
%
!
1
.6
-
%
6)
%
6) %9
%
RG 6
Y
Y
.
5G
1
%
9
%
"
1
E
%
.
66
"
( % %
E
1
,)
1
!
"
#
#
" ##
*
##
#
)
#+
#
,
#
#
#
#
#
#
#
- ##
##
##
#
#
%&
#
#!
.,
!
'!
!
#
# (
%& .
!
##!
/ # ' ! ## (
67
"
!
6) %9
%
% %
-
G
) %9
%
1
.
68
"
!
"
#
#
" ##
*
##
#
)
#+
#
,
#
#
#
#
#
#
#
- ##
##
##
#
#
%&
#
#!
.,
!
'!
!
#
# (
%& .
!
##!
/ # ' ! ## (
69
"
!
F
&'
<%*
G
algoritmo "Calculo de Max_Min_Media"
// Função : Calcular o valor maximo, minimo e media de 6 notas
// Autor : Jorge Mota
// Data : 05-12-2006
// Secção de Declarações
var
notas: vetor [1..6] de real
numeros: vetor [1..6] de inteiro
maxima,minima,media,soma,nota : real
i,imax,imin,numero : inteiro
inicio
// Secção de Comandos
//Inicialização de variaveis
soma<-0
media<-0
maxima<-0
minima<-21
imax<-0
imin<-0
//Leitura e processamento
para i<-1 ate 6 faca
escreva("Numero do aluno=")
leia(numero)
escreva("Nota =")
leia(nota)
notas[i]<-nota
numeros[i]<-numero
soma<-soma+nota
se (nota>maxima) entao
maxima<-nota
imax<-i
fimse
se (nota<minima) entao
minima<-nota
imin<-i
fimse
fimpara
media<-soma/6
escreval("Nota maxima")
escreval(maxima)
escreval(imax)
escreval("Nota minima")
escreval(minima)
escreval(imin)
Escreva("Media =")
70
"
!
escreval(media)
fimalgoritmo
71
"
!
6) %9
%
`G 0 %
-
%
72
.
"
!
,
0
1
0
2 ## #
3
4
#
5
)
# ,
)
5 1
!#
!
##
)# !5
#
6
5
#
6 ,!
#
6 ,!
#
65
)
!
#
65 $
1
1 ! 65
1 ! 65 !
)
%&
5
)(
5!
#
6 ,!
#
6 ,! $ ,
5
# #!
%&
#
777(
73
"
!
,
0
1
0
2 ## #
3
4
#
5
)
# ,
)
5 1
!#
!
##
)# !5
#
6
5
#
6 ,!
#
6 ,!
#
65
)
!
#
65 $0
1 ! 65
1 ! 65 !
)
%&
5
)(
5!
#
6 ,!
#
6 ,! $ ,
5
# #!
%&
#
777(
74
"
!
<0*
75
"
!
5. Leitura validada de uma posição para o jogo do Galo:
4
)
'
4'
-'0
4-'0
8'
9'
4
'
4'
-'0
4-'0
%& ,
:;. < %.1
& ,= , .=
=
0 (
%&
8' ! !
9' !4(
76
"
!
"
6. Desenhe um algoritmo que escreva os primeiros n numeris de Fibonacci
uma série de fibonacci.
77
!
7. Desenvolva algoritmicamente em raptor o jogo do Galo?
78
"
!
"
47 &
%
&' (
&' % 8
%
&. B
0+%
,
* (
-
0
-
&'
+%
&' .
8.9.1 Ponteiros
'
%
&'
%
1
* (
(
-% ( -
1
-
&
%
*
%
5
,%
K
&
. 6
9 %
(
%
4
*
(
&( -
1
%
.
&.
-
&.
1
%
(
)
-
%
*
9
. /
%
,
,
* (
& 1
1
-%$
%
$
&' .
(
*
& .
%
&'
(
1
1
%
%
%
6#
%
* (
'
%
)(
%
%
%
.
(
1
1
1
,
1
* (
%
1
%
-%
1
A
%
&
%
&' ( -
\
%
1
9
*
*
(
\
1
.
79
%
'
( %
!
"
8.9.2 Utilidade dos Ponteiros
'
%
&A
% (
+%
*
. #'
(
%
1
:$
;( %
'
%
%
%
%
( ,
% %
&
&A
%
%
+%
8
D
-
'
%3;(
0;. /
*)
'
%
;.
'
1
-E
8
&' %$
-
(
%
+%
&'
. 2
:%
%
%
-
:%
9
<%$
(%
:
%
&' .
6
%
%
%
(
$
0( 0WW(
8
-E
'
%
1
%
&'
% &'
9
&' 1
1
%$
.
&'
E
.
K
%
0
0WW
1
&A (
%
&'
1
1
&'
%
.
1
6
%
%
&'
%
&'
$
%
%
%3(
%*
&'
%
(
,%
1
1
.2
.
%
%
&'
8
.
Exemplos
Abaixo é mostrado o exemplo da declaração de uma lista encadeada em C, o que não
seria possível sem o uso de ponteiros:
/* a lista encadeada vazia é representada por NULL ou algum outro
símbolo */
#define LISTA_VAZIA NULL
struct link {
80
8
!
"
void *info; /* conteúdo do nó da lista */
struct link *prox; /* endereço do próximo nó da lista; LISTA_VAZIA
se este é o último nó */
};
4 -8
$
'
! !!
%A
4 -- ."9
%$
:
/
#
#E !
-
%
##
%&'
1
%
;
;( 1
: )G
%$
-
%
%
Z
-
%$
)
'
&'
:
$A .
$
)
$
'
%
%
%$
%$
%
,)
%
&'
%
%
;.
'
%
%
&'
8
.C
%
1
$
%
,
%
m
E
:
&' %
;.
\
'(
%.
F
%
)
%%
%$
1
%
%$
:/ /
;. B
%$
)
' -. ).
6)
8
$
: )
%
) % &A .
6
%
;.
)
$
4.
%$
&'
%$
8
. 6
%$
A Q
')
%
1
O
!= !
!
B
%!
:
.
%
'
81
%
1
!
\
0
)G
"
%
!
.
6
'
%$
%
6 r r/
$ %
(1
$
-
$
$
%
%$
!$#
$
&'
%
Exemplo de redireccionamento:
Chamamos a função,
Redirect_Input("file.txt")
ou
Redirect_Input("C:\Documents and Settings\file.txt");
6) %9
% G
/
1
*
S
r
R
rR
R
.
. )T
Resolução em Raptor:
82
%$
%$
%
R
!
"
= #
. )
>/ #
? @
#
)
#
A
B
>
@
%&
#
= #
%&
7
!
7-
#
%
&'
%
'
(
#!
. ) > @
#
CD 7(
& 3
! & 3
%
&A
%+%
%
%
&'
. 0
%
(
%
%
9
&'
%
(
&A (
D%
83
&'
!
1
%
%
(
)
E
&'
E
% .
%
(
(
% &A
%
)
%
,
:
%
H
9
%
(
$
; G #1
1
*
%
K
'.
(
%
%
* %
)
%
.
3
" #
,
#
,% (
%
0+%
0
&' ( %
)
1
%
%
1
1
(
1
:
% ;
1+%
$
1+%
U
&'
'
-
(
)
-
( -
%
U
R (
F %$
-
84
1
$ %
U
,. Y
0 c
.
$
1
%,
1
%
*
' -
%
\
b
0(
, (
1
&'
9 %
(
(
c
.
%
(
%
,%
.
1
-
.
%
.43
(
E
%
%
%
8(
&'
( %
<
1
(
&'
%
;( 1
1+%
%
& 3
%
(
1
%$
*)
b
1
+
-
%
(
.
P
E
%
%
? ,
D%
.
%
%
&A
8%
1
*
G
%
%
%+%
)
( %
%,
1
%
:
)
%&A
-
"
%
%
U
/
&'
)
% .
!
"
PESQUISA SEQUENCIAL
O método mais simples de determinar a presença, ou não, de um elemento numa
seqüência, é percorrê-la a partir do seu início, efetuando comparações, até que o
elemento seja encontrado ou o fim da seqüência seja alcançado. Este método é chamado
de pesquisa seqüencial.
Dados :
vetor de n elementos (n conhecido)
elemento a ser pesquisado no vetor
Resultado:
Se o elemento existe, mostra-se a sua posição ou o total de ocorrências deste no vetor.
Se o elemento não existe, mostra-se uma mensagem de falha.
As considerações que podem ser feitas sobre os dados de entrada (vetor), são do
tipo: o vetor esta ou não ordenado; o elemento ocorre uma única vez (pesquisa única) ou
repetidas vezes no vetor (pesquisa única). Isso acarreta os seguintes tipos de pesquisa:
a. Desordenada Única
b. Desordenação Múltipla
c. Ordenada Única
d. Ordenada Múltipla
Pesquisa Binária
O método de pesquisa seqüencial é fácil de escrever e é razoavelmente eficientes
para seqüências com poucos elementos. Entretanto, para seqüências de tamanho
considerável, que ocorrem na maioria das aplicações existentes, a utilização do método
torna-se inviável. Uma estratégia interessante e eficiente é utilizada no método de
pesquisa binária.
Descrição Geral do Método:
•
•
•
•
•
•
Definir intervalo inicial (i, f) de busca
Determinar a posição média do intervalo(m = (i+f) DIV 2)
Comparar o elemento da posição média (v[m]) com o elemento E:
Caso sejam iguais então terminou as pesquisa
Caso contrário definir o novo intervalo de busca
Aplicar sucessivamente o passo anterior até encontrar E ou não existir mais o
intervalo de busca
São aspectos fundamentais do método:
•
•
vector de entrada tem que estar ordenado
intervalo de busca inicial é (i,f) = (1,n)
85
!
"
• intervalo de busca, considerado a cada iteração, é definido do seguinte modo:
(i,m-1), se (E < v[m])
(m+1,f), se (E > v[m])
tendo a metade do tamanho do intervalo original
• O teste de repetição é (i <= f) e Não Achou
Dados :
vetor de n elementos (n conhecido)
elemento a ser pesquisado no vetor
Resultado
Se o elemento existe, mostra-se a sua posição ou o total de ocorrências deste no vetor.
Se o elemento não existe, mostra-se uma mensagem de falha
Os problemas de ordenação são comuns tanto em aplicações comerciais quanto
científicas. Entretanto, raro são os problemas que se resumem à pura ordenação de
seqüências de elementos. Normalmente, os problemas de ordenação são inseridos em
problemas de pesquisa, intercalação e atualização. Isto torna ainda mais importante o
projeto e a construção de algoritmos eficientes e confiáveis para tratar o problema.
O nosso objectivo é analisar os seguintes tipos de ordenação :
a. Selection Sort
b. Bubble Sort
c. Insertion Sort
a. Selection Sort
Este método é um dos mais simples e intuitivos dentre os métodos existentes.
Sua estratégia é seleccionar o menor elemento da sequência considerada e colocá-lo no
início da sequência. Assim, dada uma sequência de tamanho n, várias iterações são
efectuadas, sendo que a cada vez que esta estratégia é aplicada, uma nova sequência é
gerada pela eliminação do menor elemento da sequência original.
Código em C
/**
* Retorna -1 caso não encontre ou a posição
* caso encontre.
*/
int procura(char vetor[], int tamanho, char elementoProcurado) {
int i;
for (i = 0; i < tamanho; i++) {
if (vetor[i] == elementoProcurado) {
return i;
}
}
86
!
"
return -1;
}
& 3
( 5
1
%
%
,
%
:
+
1
1
. 6
%$
%
A
:%$
%
&
%
; %
%
,
(
%
%
. #
%
. 0
%
%
%
%$
%
%
)
%
%
(
. 6
, (
'
%
(
%
%
-
(
-
.
$
% .
B
%*
%
%
%
(
(
%
%
%$
$ ;-
*
1
%
%
5
%
,
G
(
$
H
1
G
BUSCA-BINÁRIA (V[], inicio, fim, e}
i recebe o índice no meio de inicio e fim
se V[i] é igual a e
então devolva o índice i
# encontrei e
senão se V[i] vem antes de e
então faça a BUSCA-BINÁRIA(V, i+1, fim, e)
senão faça a BUSCA-BINÁRIA(V, inicio, i-1, e)
Código em C
int PesquisaBinaria(char chave,char k[],int N)
{
int inf,sup,meio;
inf=0;
sup=N-1;
while (inf<=sup) {
meio=(inf+sup)/2;
if (chave==k[meio])
return meio;
else if (chave<k[meio])
sup=meio-1;
else
inf=meio+1;
87
%
8
!
}
return -1;
"
/* não encontrado */
}
6.1.1 Exercício %$
)
1
:S
1 %
. )T %
(
R
88
;.
!
89
"
!
6.1.2 Exercício ) %
1
? ,
1+%
.
./
90
"
&'
%$
F
.
!
91
"
!
6.1.3 Exercício <
%
%
1
&'
F
? ,
' %
)
)
%$
./
.
= #
> E
1#
2)
#
? @
#
)
#'
# #
# #!
= #
2) > @
F
%
G
H
#I
)
A J
)
>#I )@
>A J' @
#
I >>#I!
)@$*@
'#
#
-' #
#
A J
)
#K
#I
>A J' @
%&
%&
% #
CD
! #(
#
D
?
?
?(
#
92
#!
%
&'
1+% .
&'
"
&'
!
7+
!
%
&'
%
%+%
%
1+%
%
(
%
-%
'
6)
&' %
,% .
)%
,
6
%
A
%
&' %
% .
1
\
1+% . B
%
.
&'
-
%
G
R;
&' /
%
*
:
%
<
;.
R;
&'
1
)
"
)
&'
%$
.
2
1
%
:
%
&'
)
'
;
%
%
)
%
.
-8 6 ((#
(
&'
(
1
.
%
&' :
.
&'
%
1+% . 6
,
%
$ %
(
( '
&A . %
)
(
' - %
%
1
&'
*
)%
:
&A .
%
H602 F
% .
-
%
%*
1
( '
1
.
%
.
:[ ;
1
,% .
%
%
%
BUBBLESORT (V[], n)
1
houveTroca <- verdade
# uma variável de controle
2
enquanto houveTroca for verdade faça
93
$
9
&A
-
$ @
;( %
%
9 (
;
%
) . H$
@
-
!
3
4
5
6
7
"
houveTroca <- falso
para i de 1 até n-1 faça
se V[i] vem depois de V[i + 1]
então troque V[i] e V[i + 1] de lugar e
houveTroca <- verdade
Implementação em C
void bubble(int x[],int n)
{
int troca, i, j, aux;
for (i = n-1; i > 0; i--)
{
// o maior valor entre x[0] e x[i] vai para a posição x[i]
troca = 0;
for (j =0 ; j < i-1; j++)
{
if (x[j] > x[j+1])
{
aux = x[j];
x[j] = x[j+1];
x[j+1] = aux;
troca = 1;
}
}
if (!troca) return;
}
}
94
!
Implementação em Raptor Bubble Sort:
95
"
!
2)
J
#
#
)
>#-' @ >
'@
5
)
>5 #K @
> # 5 # 5!
@
L)
%&
5
5!
#
#K
#
96
7(
CD M //
"
!
"
= #
2)
> E
/ #
? @
N
)
N
# N
N
= #
97
N!
2) > @
!
98
"
!
!
%
%
%
"
#"%
(
&'
G
:
(
-
&' (
E
%&' ( %
1
;(
%
&'
: <R;
.
Código em C
void selectionSort(int vetor[],int tam)
{
int i,j;
int min,aux;
for (i=0;i<tam-1;i++)
{
min=i;
for (j=i+1;j<tam;j++)
{
if (vetor[j]<vetor[min])
min=j;
}
aux=vetor[i];
vetor[i]=vetor[min];
vetor[min]=aux;
}
}
99
!
"
Implementação em Raptor do algoritmo de ordenação por Selecção:
100
!
"
Implementação dos subprogramas Troca e Carregar Lista:
= #
2)
> E
/ #
? @
N
)
N
# N
N
= #
101
N!
2) > @
!
/
&' (
6
(
%
&'
1
(
&' ( 1
%
-
1
1
%
&
.
%
1
E
%
)
&'
8
.
Implementação em C
void insertSort(int a[], size_t length) {
int i, j, value;
for(i = 1; i < length; ++i) {
value = a[i];
for (j = i - 1; j >= 0 && a[j] > value; --j) {
a[j + 1] = a[j];
a[j] = value;
}
}
}
102
.
%
1
1
"
%
%
%
!
Implementação em Raptor:
103
"
!
"
= #
2)
> E
/ #
? @
N
)
N
# N
N
= #
104
N!
2) > @
!
"
9#
#
0
%
#$
% &'
,
Rd[d( #$
)
%
1
,% . ?
%
%
.
-
%
-
&'
Código em C
void shellSort( int * vet, int size ){
int i , j , value;
int gap = 1;
do {gap = 3*gap+1;} while ( gap < size );
do {
gap /= 3;
for ( i = gap; i < size; i++ ){
value =vet[i];
j = i - gap;
while ( j >= 0 && value < vet[j] ){
vet [j + gap] =vet[j];
j -= gap;
}
vet [j + gap] = value;
}
} while ( gap > 1);
}
105
&' .
!
Implementação em Raptor:
106
"
!
107
"
!
Procedimento Inicializar a Lista com 100 elementos:
= #
2)
> E
/ #
? @
N
)
N
# N
N
= #
N!
2) > @
108
"
!
"
: ";
I %3
I %3
0. .F. P
! %
%
.
-
&'
Rd" ( 1
%
.
,
B
*
Rd"
%
(
-
.
,% . 6
&'
b
(
.43
'
'
c
.
.
%
) ' #/! ! ! : ";
R. 0
)
u:
. 0
u: ;
G u:
;
%
;
)
& G u:
%
$
%
%
-
U
;
.
109
$
%
%
-
!
"
Algoritmo em português estruturado
proc quicksort (x:vet[n] int; ini:int; fim:int; n:int)
var
int: i,j,x,aux;
início
i <- ini;
j <- fim;
x <- x[(ini + fim) div 2];
repete
enquanto (x[i] < x) faça
i <- i + 1;
fim-enquanto;
enquanto (x[j] > x) faça
j <- j - 1;
fim-enquanto;
se (i <= j) então
aux <- x[i];
x[i] <- x[j];
x[j] <- aux;
i <- i + 1;
j <- j - 1;
fim-se;
até_que (i >= j);
se (j > ini) então
exec quicksort (x, ini, j, n);
fim-se;
se (i < fim) então
exec quicksort (x, i, fim, n);
fim-se;
fim.
Implementação em raptor (versão recursiva – não executável em
Raptor)
110
!
J
#
###
I#
F #N
%&
#
7(
111
"
!
Implementação do procedimento quicksort:
112
"
!
# ###
5 I#
# I >>### !
I# @$*@
)
)
# #'
# #!
)
# 5-'
5 5K
#
-'5
# #
# #
# 5
# 5
# #!
5 5K
#'5
5###
I#
5
F #N
#
-I#
###
#
F #N
113
"
!
Implementação da rotina que carrega a Lista:
> E
/
= #
#
2)
? @
N
)
N
# N
N
= #
N!
2) > @
114
"
!
Implementação em C
void sort(int array[], int begin, int end) {
if (end - begin > 1) {
int pivot = array[begin];
int l = begin + 1;
int r = end;
while(l < r) {
if (array[l] <= pivot) {
l++;
} else {
r--;
swap(array[l], array[r]);
}
}
l--;
swap(array[begin], array[l]);
sort(array, begin, l);
sort(array, r, end);
}
}
Implementaçao usando 'fat pivot':
void sort(int array[], int begin, int end) {
int pivot = array[begin];
int i = begin + 1, j = end, k = end;
int t;
while (i < j) {
if (array[i] < pivot) i++;
else if (array[i] > pivot) {
j--; k--;
t = array[i];
array[i] = array[j];
array[j] = array[k];
array[k] = t; }
else {
j--;
swap(array[i], array[j]);
} }
i--;
swap(array[begin], array[i]);
if (i - begin > 1)
sort(array, begin, i);
if (end - k
> 1)
sort(array, k, end);
}
115
"
!
--
/ "@
"
11.1.1
!
#
'
" ' "5#
"#
"
'< "
Notas sobre integração de uma função
Integral simples:
xDireita
f ( x) * dx
xEsquerda
6
)
,
.
%
%
-
&'
)
%
).
#!
#
D
116
)6 1
:);.
S )T
%
1
!
Integração usando a Regra de Simpson
11.1.2
#
%
% %
(
(
,
<
.
%
&'
%
<
%
'.
<
'(
A < .
%
<
*
. ' #
n
&' ;. C
A
1
% '
'
&' :);(
( % %
% &'
% %
<
<
-
)
<
,
1
.
D
∆X * f ( xEsquerda + i * ∆X − X / 2)
i =1
Que pode ser re-escrita como:
( xDireita − xEsquerda) / n *
n
f ( xEsquerda + ∆X (i − 1 / 2))
1=1
" %
"
!
'
D
117
'
%
,
&' :);
,
:,
!
N=numero de sub-intervalos no intervalo de
∆X = ( xDireita − xEsquerda ) / n = Largura do sub-intervalo
f ( xEsquerda + i * ∆X − ∆X / 2) = Altura do sub-intervalo
%
#
D
118
"
!
119
"
!
% P
)
)
"
I CD
O
1# #
/
1#
H
> 1# # K
@$ 1#
H
O
#) #
1
O
8 $*
!
#
)
# ' 1#
H
#) #
I #
! >0B B K*B
@B
#) #
#) # !
# #!
120
H
I CD
!
% P
)
)
"
I CD
O
1# #
/
1#H
> 1# # K
@$ 1#H
O
#) #
1
O
8 $*
!
#
)
# ' 1#H
#) #
I
! >0B B K*B
@B
#) #
#) #
#
!
#!
121
#
H
I CD
!
"
Notas sobre integração usando a técnica de Monte Carlo
-% %
&'
!
0
.
&' ( :); 1
0
$
,
%
%%
:
%
8
&' ;
%
%
)
)
:); %
&' .
(
v
2
)
" %
w
>
:>
:w
'
5
*
gB
1
w
gB >
*
;g :); % %
Vg :>
:w
,
;
*
Vg :>
!ag :);
>6 1
% $
1
*
*
;;h!h:)
*
<)6 1
;
! = ' #D
*
*
*
<)
:); g
!
!g
&' (
% $
.
:);. I
D
g !h:)6 1
,
!
&A
S% ) T
%
'
;
1
&'
%
. ' #
<
:)6 1
( )
!(
S% ) T
:%
!;
1
>
;;g
)6 1
Vgw
Vg>
Vg>ag>
;
* Vg!
*
Vg)
*
*
122
)
:);
!
%
#
D
123
"
!
"
/ +
0 "
Pergunta 1 (2 valor)
Coloque por ordem crescente de data de aparecimento as seguintes
linguagens de programação (da mais antiga para a mais recente)
Fortran
LISP
BASIC
C#
JAVA
C
C++
Visual Basic
Cobol
Pergunta 2 (2 valores)
Em termos metodológicos no desenho e implementação algoritmica usamos
essencialmente duas abordagens a:
Top-Down e a Bottom-up
Explique de forma clara em que consistem estas abordagens e em que
situações aplicaria um e outro ou ambos.
Pergunta 3 (2 valores)
Qual a diferença entre função e procedimento? Em ambos podemos usar
parâmetros, explique o que são, para que se usam e que tipos de passagens
existem( quanto ao modo como é feita a passagem) ?
Pergunta 4 (3 Valores)
a)Analise o seguinte algoritmo em VisualAlg 2.0 e escreva qual o resultado do
mesmo para um numero de elementos igual a 10?
b)Substitua a estrutura de controlo REPETIR … ATE () por uma ENQUANTO
() FAZER … FIMENQUANTO
algoritmo "FIBO"
// Função :FIBO
// Autor :JORGE MOTA
// Data : 29-01-2007
// Secção de Declarações
var
124
!
"
n,a,b,nFin: inteiro
inicio
// Secção de Comandos
escreva("Numero de elementos:")
Leia (nFin)
n <- 0
a <- 0
b <- 1
REPITA
escreval(a)
escreval(b)
n <- n + 2
a <- a + b
b <- b + a
ATE (n > (nFin-2))
fimalgoritmo
Pergunta 5 (3 valores)
Desenvolva um algoritmo em Raptor (fluxograma) que permita converter uma
string para maiúsculas:
Exemplo:
esTe e um teste de algoritmia.
ESTE E UM TESTE DE ALGORITMIA
Pergunta 6 (3 valores)
Implemente em raptor (fluxograma) e em C um algoritmo que calcule a altura
ao solo de um passageiro durante um passeio na roda gigante tal que :
Vamos imaginar, que uma roda leva 12 cadeiras igualmente espaçadas ao
longo do seu perímetro, que o seu raio mede 10 metros e que o ponto mais
baixo atingido ao longo do percurso círcular está a 0,5 metros do solo. Sabe-se
também que uma roda demora cerca de 30 segundos a efectuar uma rotação
completa.
125
!
"
Com : h=10.sen(pt/15), t pertencente ao intrevalo fechado de [0,30].
Pergunta 7 (2 Valores)
Implemente iterativamente o seguinte seguinte algoritmo (função) de cálculo de
um factorial:
"
"
!
%&
$
&
%1N
%
%6"
!
%2($
"
"
"
Pergunta 8 (3 Valores)
Explique o algoritmo de ordenação Bubble Sort, implemente o mesmo em
raptor (Fluxograma) para uma ordenação crescente, partindo do princípio que a
lista a ordenar está contida num array de nome LISTA e que tem n elementos.
126
!
"
Teste Tipo Prática
Pergunta 1
Implemente em linguagem Visual Raptor( ou em Fluxograma tradicional) e em
linguagem C um algoritmo que permita estimar o valor do integral de uma
função simples f(x): 3 x 2 − 2 x , no intervalo (0,3) usando a regra de integração
numérica de Simpson.
Notas para a implementação: A regra de Simpson usa rectângulos para
aproximar a área (integral) no intervalo (a,b) de uma função f(x). A área de
cada rectangulo é calculada usando como base a largura de cada rectangulo e
como altura o valor da função f(x) calculada no ponto médio de cada rectângulo
e no final é somado o conjunto das áreas. Este valor final é o valor aproximado
do integral naquele intervalo.
Resposta
(
#
% %
%
,
&' :);(
(% %
% &'
&' :);
(
<
'
&'
,
%
<
A
%
<
< .
1
'
% ' ;.
.
%
%
<
<
'(
% %
:,
A
1
:
%
R
<
A
127
<
-
'.
,
)
&'
*
&' ;. C
% '
,
R Y
!
-- - , . ' #
'
n
11.1.4
D
∆X * f ( xEsquerda + i * ∆X − X / 2)
i =1
Que pode ser re-escrita como:
( xDireita − xEsquerda) / n *
n
f ( xEsquerda + ∆X (i − 1 / 2))
1=1
" %
!
'
D
11.1.5 N = numero de subintervalos no intervalo de integração
11.1.6 ∆X = ( xDireita − xEsquerda ) / n = Largura do subintervalo
11.1.7 f ( xEsquerda + i * ∆X − ∆X / 2) = Altura do subintervalo
Implementação em Raptor
/
*
F
#
*
A
#J
>0B B K*B
@
# J
%& 2 J !A #J!
# H
*6 D
' ! (
128
#
H
#) #
"
!
% P
)
)
"
I CD
O
1# #
/
1#H
> 1# # K
@$ 1#H
O
#) #
1
O
8 $*
!
#
)
# ' 1#H
#) #
I
! >0B B K*B
@B
#) #
#) #
#
!
#!
129
#
H
I CD
!
"
Implementação em Linguagem C:
/**********************************************************/
/*
*/
/* Autor:
JM
*/
/* Data:
25 Janeiro, 2007
*/
/* Disciplina: Introdução a Ciência dos Computadores
*/
/* Professor:
Jorge Mota
*/
/* Descrição:
Este programa integra uma função, embebida*/
/*No código e representada por F, no intervalo definido
*/
/*A a B usando a regra de Simpson.
*/
/*
*/
/**********************************************************/
#include
#include
#include
#include
<math.h>
<stdio.h>
<stdlib.h>
<limits.h>
/* Usar a biblioteca matemática */
#define SEED 5
/* Formula */
#define A
#define B
#define FORMULA
#define F_STRING
1.0
3.0
(3 * x * x - 2 * x)
"(3 * x * x - 2 * x)"
/* Esta é a função matemática a ser integrada.
/* Tem uma variável x como entrada e devolve F(x).
*/
*/
double f(double x)
{
return FORMULA;
}
/* Esta função integra f entre xEsquerda e xDireita usando a regra de
simpson */
/* É feita uma divisão da função f em nDivs rectângulos
*/
/* e para cada rectângulo é calculada a área do mesmo usando como
altura o ponto médio de cada sub-divisão.
*/
/* A função requer que no intervalo (xEsquerda e x Direita),
calculemos o numero de divisões.
*/
/* O valor do integral no intervalo é o somatório das areas
rectangulares. Quantas mais sub-divisões mais preciso é o resultado.
*/
double integrar_rect(double xEsquerda, double xDireita, double
f(double), int nDivs)
{
int i;
/* Variavel contadora
*/
double area = 0.0;
/* area estimada */
double deltaX = (xDireita - xEsquerda)/nDivs;
/* largura do Subdivisão
*/
double midpointX;
/* ponto medio */
130
!
"
midpointX = xEsquerda + deltaX/2.0;
for (i = 0; i < nDivs; ++i)
{
area += f(midpointX) * deltaX;
midpointX += deltaX;
}
/* Acumula a área
*/
/* proximo rectangulo*/
return area;
}
/* Main() é responsável por chamar o método que calcula a integração*/
/* e imprimir a area calculada
*/
int main(void)
{
int n;
double s;
/* numero de rectangulos */
/* area estimada pela regra de simpson
*/
srand(SEED);
printf("\n");
printf("Integrar F(x) = %s de %5.3f to %5.3f\n", F_STRING, A, B);
printf("\n");
s = integrar_rect(A, B, f, n);
printf("
Regra de Simpson: Area com 1024 sub-intervalos
= %9.6f\n", s);
return 0;
}
Esta pergunta vale 20 valores em 20.
Critérios para correcção:
Se o aluno consegue descrever em português corrente os passos do algoritmo 10%
Se aluno estrutura convenientemente o algoritmo em funções(Métodos e Constantes) 10%
Se o aluno comenta correcta e completamente o código 10%
Se o aluno define o algoritmo de integração correctamente, separando convenientemente
variáveis, ciclo de calculo acumulado da área e impressão formatada do output em Raptor 30%
Se o aluno define o algoritmo de integração correctamente, separando convenientemente
variáveis, ciclo de calculo acumulado da área e impressão formatada do output em C 20%
Se o Nome das variaveis está adequado a sua função e não gera confusão com nomes
reservados 5%
Se o algoritmo em Raptor funciona sem erros 10%
Se o algoritmo em C funciona Correctamente 5%
131
!
/D
#%
! .
:>R )
"
! +88
Licenciatura em Informática
1º Ano - 1º Semestre
Frequência - Resolução
Data : 5-02-2007
Parte Teórica
Duração : 60 Minutos
Prof. : Jorge Mota
Introdução a Ciência dos
Computadores – 1º Ano
Numero :
Nome :
Pergunta 1 (2 valor)
Explique o que é a Heap e a Stack num modelo de memória de uma linguagem
de programação de alto nível como o C. Fale um pouco sobre a preocupação
que deve ter com estas estruturas quando se usam ponteiros e alocação
dinâmica de memória.
Resposta:
Uma arquitectura tradicional de memória para um programa em C, ou
linguagens similares, inclui as seguintes áreas:
Heap
Stack
Variaveis Globais
Instruções Programa
Em linguagens como o C podemos dinâmicamente alocar espaço na Heap, e
usar este espaço para as nossas estruturas de dados. A gestão do espaço
alocado fica da responsabilidade do programador que deve ter a
responsabilidade de limpar (libertar) este espaço sempre que já não for
necessário. Normalmente usa comandos de alocação dinâmica de espaço na
132
!
"
Heap, do tipo malloc(size). Este espaço é depois manipulado/ endereçado por
estruturas tipo ponteiro. Se isto não acontece podemos criar situações de erro
grave de sistema por falta de espaço, nomeadamente:
1) Quando a stack cresce e não dispõem de mais espaço.
2) Quando tentamos alocar mais espaço na Heap.
Esta é também uma fórmula comum de ataque aos programas, ficando o
computador a mercê de um ataque de Hacker.
A Stack é a área de memoria gerida pelo próprio programa, para as variaveis
locais, parametros e outros.
As variaveis globais e constantes usam o espaço reservado ao programa (no
topo ou no inicio da memoria usada pelo programa).
Pergunta 2 (2 valores)
Implemente em VisualAlg e C um algoritmo que calcule os numeros primos até
um determinado valor inteiro.
Resposta:
Um número primo é aquele que só é divisivel pela unidade e ele próprio.
Se pretendemos imprimir a lista de numero primos até um valor, vamos fazer
um ciclo que itera até este valor e para cada um testa se é primo (força bruta),
se for é impresso senão passa ao seguinte.
Para n=100
Temos a seguinte lista:
2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97
Em VisulAlg:
algoritmo "Primos"
// Função : Calcular Primos
// Autor : JM
// Data : 23-02-2007
// Secção de Declarações
var
sai,i,j,n:inteiro
inicio
// Secção de Comandos
escreva ("Ler quantos numeros(>4):")
leia (n)
escreval(2)
133
!
"
escreval(3)
para i<-4 ate n faca
sai<-0
j<-2
enquanto (j<i) e (sai=0) faca
se ((i%j)=0) entao
sai<-1
senao
j<-j+1
fimse
fimenquanto
se sai=0 entao
escreval(i)
fimse
fimpara
fim
Em C:
#include <stdio.h>
void main(void)
{
int sai,i,j,n;
printf("Numeros primos at-->");
scanf("%d",n);
for(i=4;i<n;i++)
{
j=2;
sai=0;
while((j<i) && (sai==0))
{
if (i%j==0)
sai=1;
else
j=j+1;
}
if (sai==0)
printf("\n%d ",i);
}
printf("\nTerminou o calculo");
}
Pergunta 3 (2 valores)
Na estruturação de algoritmos e implementação em linguagens de alto nível é
comum decompormos o programa em problemas mais pequenos. A
implementação destas unidades mais pequenas em linguagens como o C ou
linguagens algoritmicas como o VisualAlg é feita sob a forma de funções ou
134
!
"
procedimentos. Explique como implementar em VisualAlg e C procedimentos e
funções e como se processam os diversos tipos de passagens de parâmetros.
Resposta:
Quer o C quer o VisualAlg possuem Funções e Procedimentos e respectivas
passagens de parãmetros por valor e referência.
Usamos Funções sempre que pretendemos atomizar funcionalidades do nosso
programa e que seja devolvido um valor. Em C isto é feito implicitamente
designando o nome da <função>. Em VisualAlg 2.0 usamos a palavra
reservada funcao. Para os procedimentos o C usa igualmente a forma implicita
só que não é especificado nenhum tipo de dados a devolver - void.
Já o visualAlg 2.0 utiliza a palavra reservada Procedimento.
Todas estas construções suportam passagem de parãmetros por valor e
referência ou seja no primeiro a variavel chamadora não é alterada e na
segunda o que usamos é uma referência para a mesma memória onde está
instanciada a variavél chamadora, quer dize,r é como usar um aliás para esta
variavel.
Sintaxe em VisualAlg:
funcao <nome-de-função> [(<seqüência-de-declarações-de-parâmetros>)]:
<tipo-de-dado>
// Secção de Declarações Internas
inicio
// Secção de Comandos
fimfuncao
procedimento <nome-de-procedimento> [(<seqüência-de-declarações-deparâmetros>)]
// Secção de Declarações Internas
inicio
// Secção de Comandos
fimprocedimento
Passagem de parâmetros por referência (negrito) por valor a (italico):
procedimento soma (x,y: inteiro; var resultado: inteiro)
funcao soma (x,y: inteiro): inteiro
…
Em C:
Void nome(<tipo> var,<tipo> *var)
{
135
!
"
…
}
int nome(<tipo> var,<tipo> *var)
{
…
Return n
}
Pergunta 4 (3 Valores)
a)Analise o seguinte algoritmo em VisualAlg 2.0 e escreva qual o resultado do
mesmo para um numero de elementos igual a 12?
b)Substitua a estrutura de controlo ENQUANTO () FAZER … FIMENQUANTO
por uma REPETIR … ATE () .
algoritmo "FIBO_ENQUANTO"
// Autor :JORGE MOTA
// Data : 29-01-2007
// Substituir um repetir por enquanto
// Secção de Declarações
var
n,a,b,nFin: inteiro
inicio
// Secção de Comandos
escreva("Numero de elementos:")
Leia (nFin)
n <- 0
a <- 0
b <- 1
enquanto (n<=nFin-2) faca
escreval(a)
escreval(b)
n <- n + 2
a <- a + b
b <- b + a
136
!
"
fimenquanto
fimalgoritmo
Resposta:
a)
n
a
b
N<=nFin-2
Escreva a
Escreva b
0
0
1
V
0
1
2
1
2
V
1
2
4
3
5
V
3
5
6
8
13
V
8
13
8
21
34
V
21
34
10
55
89
V
55
89
12
144
233
F
Sequência Impressa: 0,1,1,2,3,5,8,13,21,34,55,89
b)
algoritmo "FIBO_Repetir"
// Autor :JORGE MOTA
// Data : 23-02-2007
// Substituir um repetir por enquanto
// Secção de Declarações
var
n,a,b,nFin: inteiro
inicio
// Secção de Comandos
escreva("Numero de elementos:")
Leia (nFin)
n <- 0
a <- 0
b <- 1
repetir
escreval(a)
escreval(b)
n <- n + 2
a <- a + b
b <- b + a
ate que (n>nFin-2)
fimalgoritmo
Pergunta 5 (3 valores)
Desenvolva um algoritmo em Raptor (fluxograma) que permita converter uma
string para maisculas e que tenham sido subtraídos os espaços a mais:
Exemplo:
137
!
esTe
e um teste de algoritmia.
"
ESTE E UM TESTE DE ALGORITMIA
Nota : o underscore representa simbólicamente espaço.
Resposta:
A
KK
A
)#
JQ .I
>A
A
@
%
A J
#
)
#
)#
A
#
'0*
>A J' @ >#
'@
A J
> 'RS@
>-' **@
A J
A
%
A
%!
K0*
A
A J
# #!
%& A
Pergunta 6 (3 valores)
138
%(
%
A
%!
A
%
A
%!
!
"
Implemente em raptor (fluxograma) e em C um algoritmo que calcule a altura
ao solo de um passageiro durante um passeio na roda gigante a partir do
numero (inteiro) de cadeira que conta abaixo de si:
Vamos imaginar, que uma roda leva 12 cadeiras igualmente espaçadas ao
longo do seu perímetro, que o seu raio mede 10 metros e que o ponto mais
baixo atingido ao longo do percurso círcular está a 0,5 metros do solo. Sabe-se
também que uma roda demora cerca de 30 segundos a efectuar uma rotação
completa.
Com : h=10.sen( ), t pertencente ao intervalo fechado de [0,30].
Resolução:
Vamos considerar que o passageiro só conta as cadeiras de um dos lados.
Assim temos o seguinte definição para o problema:
Se o número de cadeiras é 0 então o passageiro esta a 0,5 m do solo.
Se o número de cadeira é inferior a 3 então a altura aproximada é de h=10,5(n)*10*sen(30).
Se o número de cadeira é de 3 então a altura ao solo é de 10,5 m.
Se o número esta entre 4 e 6 (ou seja 5) então h=10,5+n*10*sen(30).
Se o número de cadeiras é de 7 então a altura é de 20,5 m ao solo.
139
!
"
# #
#
'
,
?
T
-0
,
?
TK> @B
>%#$0@
B#
'0
,
?
T
-S
,
?
T! > @B
#>%#$0@
B
,
%&
*?
T
%&
,
) #
' !,
(
Pergunta 7 (2 Valores)
Implemente iterativamente em fluxograma o seguinte seguinte algoritmo
(função) de cálculo de um factorial:
"
"
!
%&
$
&
%1N
%
%6"
!
%2($
"
"
"
Resposta:
Implementação em Fluxograma:
140
2 HU# (
!
I
#
I CD V Q
)
#
)
#-
A
I
IB#
#
#K
#
!I(
)
O
I
%&
"
!! '
141
)
6
I
#) # # O
#?
!
' #'
%
s %
@
%
'
"
')
.$@
:
;U
:;
^
U
g %
:@
:R ;U
%
R gi e @
(
;U
_
%
:
;
^
(U
gRU
: g UagRU
<< ;
^
g hU
_
U
_
Pergunta 8 (3 Valores)
Explique o algoritmo de ordenação Insertion Sort, implemente o mesmo em
raptor (Fluxograma) para uma ordenação crescente, partindo do princípio que a
lista a ordenar está contida num array de nome LISTA e que tem n elementos.
Resposta:
Insertion sort, ou ordenação por inserção, é um algoritmo simples de ordenação,
eficiente quando aplicado a um pequeno número de elementos. Em termos gerais, o que
faz é percorrer um vector de elementos da esquerda para a direita e à medida que avança
vai deixando os elementos mais à esquerda ordenados. O algoritmo de inserção
funciona da mesma maneira como muitas pessoas ordenam cartas num jogo de cartas
como o poquer.
142
!
143
"
!
/ D
#%
I. $
!
+88
5 " ! = 3 ?"
/'
!
1º Ano - 1º Semestre
Resolução parte prática da
Frequência e exame.
Duração : 60 Minutos
Prof. : Jorge Mota
Engenharia Informática
Introdução a Ciência dos
Computadores – 1º Ano
Data : 5-02-2007
Parte Prática
Numero :
"
Nome :
Pergunta 1
Implemente em linguagem Visual Raptor( ou em Fluxograma tradicional) e em
linguagem C um algoritmo que permita estimar o valor do integral de uma
função simples f(x) exemplo: 3 x 2 − 2 x , no intervalo (1,3) usando técnica de
integração de Monte Carlo.
Notas para a implementação: ver descrição da técnica em abaixo.
144
!
-- - 4 . ' #
RR.R.d v
'
2
,
-- - -RR.R.R ! g
RR.R.R` w
11.1.16
gB
*
RR.R.RY>
RR.R.R[
D
g !h:)6 1
11.1.10
:>
!
'
5
1
!ag :);
w
*
*
;g :); % %
<" " !
:); g
" %
gB >
*
<)
)
*
:w
Vg :>
%
;
:w
*
*
8
;;h!h:)
<)6 1
;
! = ' #D
>6 1
% $
1
*
1
>
*
Vg :>
Vg>ag>
Vgw
)6 1
;
* Vg!
Vg>
*
Vg)
*
;;g
*
)
) #
<
:)6 1
()
;
%
!(
!
0
e ?f
# $
:
%
%
)
&' .
)
:); (
&'
S% ) T
:);. I
% $
%
,
.
:);
!
.
%
"
&' ( :); 1
%%
&' ;
% :%
1
&' (
%
,
!;
Resposta
((+
(+
(
((+
(+
(/ 1)
( .+
$^
3$ ^
"
%
+
K
((+
(+
(7 .$Z
*?B E
E
L
%
C
,
g +K
%
3x 2 − 2 x
+K
)E
%
%
L
)?S
-
V
E
(+
%
?
* ) (,
#
"
E
:
%
&
?
??
rx=(xDireita-xEsquerda)* random/(LONG_MAX))+xEsquerda
ry=M*random()/(LONG_MAX)
A constante LONG_MAX representa o máximo numero que pode ser gerado
pelo random em raptor será igual a 1 e em gcc por exemplo está
definida em limits.h
5)Iterar os 1024 pontos gerados aleatóriamente. No nosso caso
implementado por um ciclo contado tendo o cuidado de para cada x e y
gerado calcular o valor da função F(x) e verificar se é inferior ao Y
gerado. No caso de ser incrementar o contador de pontos que depois nos
irá permitir estimar a área.
6)Finalmente calcular a area pela proporção de numeros gerados que são
inferiores a F(rx) relativamente a area da caixa de restrições.
145
!
"
(contagem/nPontos)*(M*(xDireita-xEsquerda))
Implementação em Raptor:
Programa principal, limita-se a inicializar variaveis e a chamar a função de cálculo pela
técnica de integração de Monte Carlo(mc) e apresentar o valor calculado.
.
" ,8
"
*?
,
M
0
%
*
"
%&
H
)
# J
'!
)
*
(
146
!
"
Função que implementa o calculo do integral pela técnica de integraçãode Monte Carlo
(mc):
147
!
148
"
!
"
Finalmente o subprograma que implementa a função a integrar (Hardcoded):
I4
0B B K*B
Implementação em Linguagem C:
/**********************************************************/
/*
*/
/* Autor:
JM
*/
/* Data:
25 Janeiro, 2007
*/
/* Disciplina: Introdução a Ciência dos Computadores
*/
/* Professor:
Jorge Mota
*/
/* Descrição:
Este programa integra uma função, embebida*/
/*No código e representada por F, no intervalo definido
*/
/*A a B usando a Técnica de Integração de Monte Carlo.
*/
/*
*/
/**********************************************************/
#include
#include
#include
#include
<math.h>
<stdio.h>
<stdlib.h>
<limits.h>
/* Usar a biblioteca matemática */
#define SEED 5
/* Formula */
/*
#define A
1.0
#define B
3.0
#define M
21.0
#define FORMULA (3 * x * x - 2 * x)
#define F_STRING "(3 * x * x - 2 * x)"
*/
/* Esta é a função matemática a ser integrada.
/* Tem uma variável x como entrada e devolve F(x).
*/
*/
double F(double x)
{
return FORMULA;
}
/* Esta função integra f entre xEsquerda e xDireita usando o método de
integração de Monte Carlo */
/* É desenhado caixa usando os valores definidos pelo intervalo
xEsquerda e xDireita e o minimo e máximo como base e topo do mesmo.
149
!
"
Para o valor máximo devemos estimar um valor adequado de acordo com a
gráfico da função.
*/
/* São gerados pontos aleatóriamente dentro desta caixa de valores e
determinado se o valor gerado se encontra acima ou abaixo da função F
*/
/* A fracção de pontos gerados abaixo da função é a mesma que a
fracção da área da caixa abaixo da função ou seja o valor do integral
da mesma no intervalo considerado. Esta consideração só é valida para
um numero significativo de pontos*/
/*ATENÇÃO estamos a considerar que a constante LONG_MAX é o máximo
valor possivel de ser gerado pela função rand(). Está sempre
dependente do compilador. Neste caso consideramos que está definida em
limits.h (gcc) */
double integrar_mc(double xEsquerda, double xDireita, double
f(double), int nPontos, double M)
{
int i;
/* Variavel contadora
*/
int contagem=0;
/* Numero de ponto de abaixo da função*/
double rx; /* valor aleatório x no intervalo de valores da caixa*/
double ry; /* valor aleatório y no intervalo de valores da caixa*/
double f_y; /*valor de y= valor da função no ponto aleatório rx*/
for (i=0; i<nPontos;++i)
{
/*Escolher um pontos aleatório na caixa de valores. Os valores
rx e ry devem escolhidos independentemente*/
rx=(xDireita-xEsquerda)* rand()/((double) (LONG_MAX))+xEsquerda);
ry=M*rand()/((double) (LONG_MAX));
/* verificar se o ponto está abaixo da função*/
f_y=F(rx);
if (ry<f_y)
contagem++;
}
return (contagem/((double)(nPontos))*(M*(xDireita-xEsquerda)));
}
/* Main() é responsável por chamar o método que calcula a integração*/
/* e imprimir a area calculada
*/
int main(void)
{
int n;
double mc;
/* numero de pontos */
/* area estimada pela técnica de Monte Carlo
*/
srand(SEED);
printf("\n");
printf("Integrar F(x) = %s de %5.3f to %5.3f\n", F_STRING, A, B);
printf("\n");
n=1024;
printf("n = %d\n", n);
150
!
"
mc = integrar_mc(A, B, F, n,M);
printf("Método Monte Carlo: Area com n pontos = %9.6f\n", mc);
return 0;
}
Esta pergunta vale 20 valores em 20.
Critérios para correcção:
Se o aluno consegue descrever em português corrente os passos do algoritmo 10%
Se aluno estrutura convenientemente o algoritmo em funções(Métodos e Constantes) 10%
Se o aluno comenta correcta e completamente o código 10%
Se o aluno consegue especificar a forma de calculo dos numeros gerados aleatóriamente na
caixa de restrições 10%
Se o aluno define o algoritmo de integração correctamente, separando convenientemente
variáveis, ciclo de calculo acumulado da área e impressão formatada do output em Raptor 20%
Se o aluno define o algoritmo de integração correctamente, separando convenientemente
variáveis, ciclo de calculo acumulado da área e impressão formatada do output em C 20%
Se o Nome das variaveis está adequado a sua função e não gera confusão com nomes
reservados 5%
Se o algoritmo em Raptor funciona sem erros 10%
Se o algoritmo em C funciona Correctamente 5%
151
!
-+ 6 (#
=
bRcF %$ (
: 0 (
*
( /
&'
&'
0 (
";.
b c#%$
(P
b`c#
Z
"
( C Completo e Total( :
( Rdd ;.
( Algorithms and Software Principles( :
$( 2$
5( Rdd[;.
bYc#
( 0,
b[c$
G 444.
!
(!
% .
152
H
.
(:
";.
<