algoritmia e programação

Algoritmia e

Programação em Pascal

(Texto atualizado para pós-acordo)

Hélio Vilas

Braga – Junho de 2001

Manual de Programação Introdução à Algoritmia

Eng. Hélio Vilas Página 2

Indíce

Cap 1. ALGORITMIA ................................................................................................................................ 4

1.1. O que é um Algoritmo? ..................................................................................................................... 4

1.2. O Método Top-Down ........................................................................................................................ 5

1.3. Tipos de Dados ................................................................................................................................. 6

1.3.1. Variáveis, Constantes e Identificadores ...................................................................................... 6

1.3.2. Regras para a construção de Identificadores................................................................................ 6

1.3.3. Classificação dos Tipos de Dados................................................................................................. 7

1.4. Operadores, Operações Elementares e Expressões ........................................................................... 8

1.4.1. Operadores Aritméticos ............................................................................................................. 8

1.4.2. Operadores Relacionais (de comparação) ................................................................................... 8

1.4.3. Operadores Lógicos .................................................................................................................... 9

1.4.4. Operadores de Cadeias de Caracteres ......................................................................................... 9

1.4.5. Operadores Funcionais ou Funções............................................................................................. 9

1.4.6. Expressões: Escrita comum e em Programação .......................................................................... 10

1.4.7. Prioridade dos Operadores ....................................................................................................... 10

1.5. Noções de Lógica ............................................................................................................................ 11

1.5.1. Negação (NOT) ......................................................................................................................... 11

1.5.2. Conjunção (AND) ...................................................................................................................... 11

1.5.3. Disjunção (Or) .......................................................................................................................... 11

1.6. Atribuição, Entrada e Saída de dados ............................................................................................... 12

1.6.1. Atribuição ................................................................................................................................ 12

1.6.2. Entrada de dados ...................................................................................................................... 12

1.6.3. Saída de dados.......................................................................................................................... 12

1.7. Traçagem de algoritmos .................................................................................................................. 14

1.8. Fluxogramas ................................................................................................................................... 15

1.9. Exercícios Propostos ....................................................................................................................... 16

Cap 2. ESTRUTURAS DE CONTROLO........................................................................................................ 17

2.1. Estrutura Sequencial ....................................................................................................................... 17

2.2. Estruturas Condicionais................................................................................................................... 18

2.2.1. Estrutura Condicional Simples (Se .. Então) ............................................................................... 18

2.2.2. Estrutura Condicional Dupla (Se .. Então .. Senão) ..................................................................... 19



2.2.3. Estrutura Condicional Múltipla (Caso .. Seja) ............................................................................. 19

2.3. Estrutura Repetitivas (ou Cíclicas) ................................................................................................... 20

2.3.1. Estrutura Enquanto .. Fazer ....................................................................................................... 21

2.3.2. Estrutura Repetir .. Até ............................................................................................................. 22

2.3.3. Estrutura Para .. Fazer ............................................................................................................... 24


Cap 3. ESTRUTURAS DE DADOS .............................................................................................................. 27

3.1. Vetores e Matrizes – Arrays............................................................................................................. 27

3.1.1. Operações sobre Vetores ......................................................................................................... 28

3.1.2. Pesquisa de um elemento num Vetor ....................................................................................... 29

3.1.3. Ordenação dos elementos de um Vetor .................................................................................... 29

3.1.4. Matrizes – Arrays Multidimensionais ........................................................................................ 30

3.2. Cadeias de Caracteres – strings ....................................................................................................... 32

3.2.1. Vetores de Cadeias de Caracteres – Arrays de Caracteres .......................................................... 34


Cap 4. INTRODUÇÃO À LINGUAGEM PASCAL .......................................................................................... 37



CAP 1. ALGORITMIA

1.1. O que é um Algoritmo?

Do Latim Algorithmu, palavra usada para designar “o conjunto de fases de pormenor por que é preciso

passar para chegar à solução de um problema”. Em Informática o seu significado é similar, i.e.,

Algoritmo é o conjunto ordenado de passos (instruções) para a resolução sequencial de um problema .

Um computador é uma máquina sequencial (executa instruções sequencialmente), pois só inicia a

execução de uma instrução após ter terminado a anterior, assim, um algoritmo pode ser visto como a

descrição numa linguagem quase natural (chamada linguagem algorítmica, pseudocódigo ou ainda

Português estruturado) da sequência de instruções a ser executada pelo computador para a

resolução de um problema.

Dado um problema, a sua resolução num computador será objeto de um conjunto de fases até se

obter a solução final. Podemos considerar as três fases seguintes:

1- Análise do problema – que implica a compreensão e real definição do problema, o que

realmente se pretende, que dados são fornecidos, desses, quais os necessários e que outros

teremos que considerar, que resultados iremos obter;

2- Elaboração do Algoritmo (e/ou Fluxograma) recorrendo ao método de análise Top-Down e às

estruturas algorítmicas adequadas (apresentadas mais à frente).

3- Implementação do Algoritmo obtido numa Linguagem de Programação (no nosso caso a

linguagem Pascal), e sucessivos testes e correções da implementação até se obter a solução

final ou programa .

Nota:

Sendo o âmbito deste curso a formação de técnicos de informática, cujas funções poderão ser,

entre outras, a de programador, será importante realçar que um programador tem como função

resolver problemas que lhe são propostos (prestação de um serviço).

Nesta cóptica, a especificidade da implementação de um problema deverá ser transparente para o

utilizador final pois a ele só interessam a entrada de dados (input) e a saída de resultados (output)

devendo estas operações ser suficientemente claras e objetivas.



1.2. O Método Top-Down

A abordagem de um problema segundo uma conceção descendente, em inglês top-down, é um

método de tratamento de problemas do geral para o particular, em que se parte dos pontos mais

gerais e por simplificação (análise) se chega aos aspetos mais particulares. Diz-se então que o

método Top-Down consiste na divisão de um problema em problemas cada vez mais pequenos até se

obter um nível de especificação considerado aceitável (dividir para reinar).

Poder-se-á afirmar que se atingiu um nível de especificação considerado aceitável sempre que as

operações encontradas na análise top-down possam ser implementadas diretamente usando as

instruções da linguagem algorítmica (nível da linguagem algorítmica).

Um problema a ser resolvido num computador, poderá sempre ser dividido em pelo menos três

subproblemas: 1- entrada de dados, 2- cálculos e 3- apresentação de resultados. Haverá ainda um

quarto que diz respeito à terminação do programa e que deverá existir em todos os algoritmos. Para

uma melhor compreensão do método top-down observe-se o seguinte exemplo:

Exemplo:

Problema: Dados os valores de dois operandos, calcular a sua soma.

Na análise do problema constatamos que o utilizador do programa terá que introduzir os dois valores

(quaisquer) dos operandos (entrada de dados) dos quais pretende obter a soma, o computador

assimila esses valores e realiza as operações necessárias ao cálculo do resultado.

Note-se que no enunciado não é feita qualquer referência à saída de resultados, no entanto esta

terá que existir para que o resultado da operação possa ser visualizado pelo utilizador.

Aplicando o método top-down o problema fica com

o seguinte especto:

Note que numerados e entre parênteses rictos

temos a descrição dos vários blocos ou

subproblemas obtidos. Faltam especificar as

operações a realizar nos blocos 1, 2 e 3, no entanto

estas operações poderão ser implementadas

diretamente em Linguagem Algorítmica através de

instruções simples tal como veremos mais adiante.

Algoritmo Soma

1 – [Entrada de dados]

Leitura dos dois operandos;

2 – [Cálculos]

Cálculo da soma;

3 – [Apresentação de resultados]

Apresentação da soma ao utilizador;

4 – [Terminar]

Sair (do programa);



1.3. Tipos de Dados

1.3.1. Variáveis, Constantes e Identificadores

O objetivo principal da utilização de um computador é a manipulação de dados1 ou informação2. Os

dados num programa podem ser usados sob a forma de constantes ou variáveis:

Constantes – são valores que se mantêm inalterados durante a execução de um programa;

Variáveis – são entidades que podem assumir diferentes valores ao longo da execução de um

programa.

As constantes podem ser escritas sob a forma de valores diretos ou associadas a identificadores. As

variáveis são sempre associadas a identificadores (que por sua vez estão associados a tipos de

dados). Os identificadores são nomes que se atribuem a constantes, variáveis ou outros elementos

usados dentro de um programa.

Nota:

De uma forma simplista, uma variável, pode ser vista como um recetáculo onde é armazenado um

dado valor.

1.3.2. Regras para a construção de Identificadores

Os identificadores (nomes de variáveis ou constantes) têm que obedecer às seguintes regras:

1. O primeiro carácter tem que ser uma letra (a..z, A..Z);

2. Os restantes caracteres podem ser letras, algarismos ou o carácter de ligação “_ “;

3. O nome não pode conter espaços;

4. As palavras reservadas das linguagens de programação não podem ser usadas;

5. Não podem ser usados caracteres acentuados (ex.: ç, é, ã, õ, ê, etc.).

Combinando variáveis, constantes e operadores obtêm-se expressões. As variáveis e constantes

estão sujeitas às operações possíveis de acordo com os seus tipos de dados.

1 - Dados são elementos primários, designações ou representações simbólicas de factos ou medidas.

2 - Informação são dados estruturados ou organizados entre si em conjuntos significativos.



Exemplos:

Identificadores Válidos Identificadores Inválidos

nome

Max_Min

EB110

Contador

i

W52

soma

idade

João

B3#C

!cont

Read

Var

Begin

Va lor1

3soma

1.3.3. Classificação dos Tipos de Dados

Consideram-se os seguintes tipos de dados:

Tipos de Dados Em Pascal Gama de Valores

1 Simples

1- Inteiro

2- Real

3- Carácter

4- Booleano (Lógico)

- Integer

- Real

- Char

- Boolean

-32768 a 32 767

2,9E-39 a 1,7E38

Todos os caracteres ASCII

True (V) ou False (F)

2 Cadeia de Caracteres String 1 a 255 caracteres ASCII

3 Estruturados

1- Matriz ou Vetor

2- Registo

3- Conjunto

4- Ficheiro

- Array

- Record

- Set

- File

A ver mais à frente

neste manual

(Capítulo 3 e seguintes)

A gama de valores em cada tipo de dados pode ainda variar consoante a linguagem de programação

utilizada.

Exemplos

325 – Inteiro

-3457 – Inteiro

34574 – Real (ultrapassa a gama dos inteiros)

2,45E12 – Real

2,3*10E-3 – Inválido

‘a’ – Carácter

‘ ‘ – Carácter (espaço)

Falso – Lógico

‘bota gel’ – Cadeia de caracteres

‘Green Ville’ – Cadeia de caracteres



1.4. Operadores, Operações Elementares e Expressões

Os operadores dividem-se em 5 grupos:

1– Aritméticos;

2– Relacionais (ou de comparação);

3– Lógicos;

4– de Cadeias de Caracteres;

5– Funcionais.

1.4.1. Operadores Aritméticos

Designação Operador

Multiplicação (asterisco)

Divisão (barra – slash) /

Adição +

Subtração -

Divisão Inteira (Truncada) DIV

Resto da Divisão MOD

As operações entre dados do tipo inteiro apresentam resultados inteiros à exceção da divisão de dois

inteiros cujo resultado pode ser um real. Os resultados de operações entre valores reais são sempre

valores reais.

1.4.2. Operadores Relacionais (de comparação)


Igual =

Diferente <>

Menor <

Menor ou igual <=

Maior >

Maior ou igual >=

Todos os tipos de dados podem ser sujeitos a operações relacionais (ou de comparação), o resultado

assume sempre um de dois valores possíveis: verdadeiro (V) ou Falso (F).



1.4.3. Operadores Lógicos


Negação NOT

Conjunção (e lógico) AND

Disjunção (ou lógico) OR

Tal como nas operações relacionais, o resultado das operações lógicas assume sempre um de dois

valores possíveis: verdadeiro (V) ou Falso (F).

1.4.4. Operadores de Cadeias de Caracteres


Concatenação +

Todos os Relacionais =, <>, <, <=, >, >=

Exemplos

‘Infor’ + ‘mática’ = ‘Informática’

‘Al’ + ‘ca’ + ’chofra’ = ‘Alcachofra’

‘Boa Noite’ < ‘Bom dia’ (Verdadeiro)

‘Olá’ < ‘Oi’ (Falso)

Nota:

Nas operações de comparação de cadeias de caracteres são utilizados os seguintes critérios:

1º– a ordem alfabética, 2º– a quantidade de caracteres e 3º– valor do código ASCII (apenas em

algumas linguagens de programação).

1.4.5. Operadores Funcionais ou Funções.


Quadrado (Square) SQR( )

Raiz Quadrada (Square Root) SQRT( )

Módulo (valor absoluto) ABS( )

Seno SIN( )

Concatenação de duas strings CONCAT( )



Os operadores funcionais fazem parte da linguagem Pascal e encontram-se reunidos em unidades

(Units – bibliotecas de funções ou procedimentos) consoante o assunto a que dizem respeito, por

exemplo a Unit Dos engloba funções e procedimentos relativos ao sistema operativo.

Algumas funções e procedimentos de âmbito geral não estão incluídas em nenhuma biblioteca em

particular fazendo parte da própria linguagem.

1.4.6. Expressões: Escrita comum e em Programação

Na escrita corrente de expressões é vulgar omitirem-se os operadores por serem considerados

implícitos (aliás isso mesmo é ensinado na matemática), em programação todos os operadores têm

de ser explicitados ou ocorrerão situações de erro inesperadas. Então vejamos, a expressão

matemática 2ab2 em programação será escrita da forma: 2*a*b*b.

Exemplo

Escrita Comum em programação

3(2a+b2) 3*(2*a+b*b)/(3*c-2*a) 3c – 2a

1.4.7. Prioridade dos Operadores

Quando numa expressão figuram variados operadores, torna-se necessário conhecer as regras de

prioridade (ou precedência) na execução das operações de forma a obter resultados esperados. As

regras de prioridade dos operadores nas Linguagens de Programação são as mesmas que na

Matemática, primeiro os parênteses e depois conforme a tabela seguinte:

Mais Alta – Not (Operadores Unários)

* / Div Mod And

+ – Or

Mais Baixa = <> < > <= >=

Há ainda que considerar duas regras:

1ª – quando aparecem dois ou mais operadores com igual precedência, as operações devem ser

executadas pela ordem apresentada, da esquerda para a direita;



2ª – Os parênteses alteram a ordem das operações, funcionando dentro dos parênteses a regra

anterior.

1.5. Noções de Lógica

Os operadores lógicos estabelecem uma relação entre os operandos, tendo como resultado um valor

lógico que ou é verdadeiro ou falso.

1.5.1. Negação (NOT)

A negação é um operador unário que opera sobre um valor lógico e dá o seu valor negado.

Vejamos a Tabela de Verdade da Negação:

Para designar o operador negação são também utilizados os símbolos:

~ , e

Propriedade da negação:

~ ( ~ ( a ) ) = a

1.5.2. Conjunção (AND)

A conjunção é um operador lógico binário (opera sobre

dois operandos) que só dá resultado verdadeiro quando os

dois operandos tiverem valor verdadeiro.

Para designar o operador conjunção são também utilizados

os símbolos: e

Propriedades da Conjunção:

i) a b = b a (Comutativa)

ii) (a b) c = a (b c) (Associativa)

iii) a 1 = 1 a = a (Elemento Neutro)

iv) a 0 = 0 a = 0 (Elemento Absorvente)

v) a a = a (Idempotência)

1.5.3. Disjunção (Or)

A disjunção é um operador binário que só dá resultado

Falso quando os dois operandos tiverem valor Falso.

a ~ a

1 0

0 1

a b a b

0 0 0

0 1 0

1 0 0

1 1 1

a b a + b

0 0 0

0 1 1

1 0 1

1 1 1



Para designar o operador disjunção são também utilizados os símbolos: + e V

Propriedades da Disjunção:

i) a + b = b + a (Comutativa)

ii) (a + b) + c = a + (b + c) (Associativa)

iii) a + 0 = 0 + a = a (Elemento Neutro)

iv) a + 1 = 1 + a = 1 (Elemento Absorvente)

v) a + a = a (Idempotência)

1.6. Atribuição, Entrada e Saída de dados

1.6.1. Atribuição

A operação de atribuição consiste em atribuir a uma variável um valor. Este pode ser um valor

constante ou uma expressão. Esta operação representa-se em Algoritmia pelo símbolo .

Supondo que uma variável já contem um valor, ao ser-lhe atribuído um outro valor, o segundo vai

sobrepor-se ao primeiro ficando armazenado na variável o segundo valor. Assim o valor armazenado

numa variável será sempre o último valor atribuído a essa variável.

Z 4, significa que a variável Z possui a partir deste momento o valor 4. Se tivermos agora cubo Z

* Z * Z, a execução será a seguinte: primeiro é calculado o valor da expressão (64) e em seguida é

atribuído à variável cubo, ou seja, primeiro é calculado o segundo membro e só depois é efetuada a

atribuição.

1.6.2. Entrada de dados

Outra forma de atribuir valores a variáveis é pela entrada de dados através dos periféricos de entrada

sendo o mais utilizado o Teclado. Quando num programa são introduzidos dados estes têm que ser

armazenados em variáveis (endereços de memória) para poderem ser processados. A função Ler() da

linguagem algorítmica, atribui a uma variável o valor lido de um periférico de entrada. Esta função

funciona tal como a atribuição, de forma destrutiva para os valores que as variáveis a ler possuíam.

1.6.3. Saída de dados

Para visualizar dados ou resultados no exterior, eles terão que ser enviados para um dos periféricos

de saída – saída de dados, vulgarmente Monitor e/ou Impressora. A função algorítmica Escrever( )

permite realizar essa ação. Pode-se assim, mostrar os valores que as variáveis possuem em



determinado instante ou alertar o utilizador para determinado facto através do envio de uma

mensagem (constante do tipo cadeia de caracteres). Observemos um exemplo para melhor

compreensão.

Exemplo

Escrever(‘Quais as notas dos dois testes’)

É escrita no ecrã a mensagem (cadeia de caracteres) avisando o utilizador sobre introdução de

valores

Ler(nota1, nota2)

O computador fica à espera que sejam fornecidos dois valores que guarda nas variáveis

Med (nota1+ nota2)/2

Somam-se os valores das variáveis, o resultado é dividido por 2 e guardado na variável Med

Escrever(‘A média é:’, Med)

Escreve no monitor a mensagem (cadeia de caracteres) e o valor da variável Med

Obs. As funções Ler e Escrever podem manipular um conjunto de uma ou mais variáveis

(separadas por vírgulas) tal como se pode ver nas instruções seguintes:

Ler(a) é lida uma variável;

Ler(b, c) são lidas duas variáveis (os seus valores);

Escrever(a, b) são apresentados os valores de duas variáveis

Escreve(‘valor de’, c) é apresentado o valor de uma variável.

Estamos agora em condições de rescrever o

algoritmo visto atrás (exemplo da soma de dois

números) usando as instruções algorítmicas

adequadas e segundo o método de análise top-

down.

Nota:

Repare na alteração do nome do algoritmo

para Soma2, pois não podem existir

identificadores repetidos, o nome da variável e

nome do algoritmo (neste caso).

Algoritmo Soma2

1 – [Entrada de dados]

Escrever(‘Primeiro operando:’)

Ler(Op1)

Escrever(‘Segundo operando:’)

Ler(Op2)

2 – [Cálculo da Soma]

Soma Op1 + Op2;

3 – [Apresentação de Resultados]

Escrever(‘A Soma é:’, Soma)

4 – [Terminar]

Sair



1.7. Traçagem de algoritmos

Como sabe um algoritmo é uma sequência de instruções (ações) a serem executadas numa ordem

bem definida, sendo cada instrução clara e sem ambiguidades.

Um algoritmo é constituído por um nome (título) que seja sugestivo em relação à função que ele

implementa, a sequência de ações que resolvem o problema (ver exemplo anterior, algoritmo

Soma2), cada passo deve ter uma descrição e caso tenha mais que uma instrução elas serão

executadas pela ordem que aparecem. O algoritmo termina com a palavra sair.

Põe-se então a questão: como saber se o algoritmo resolve o que se pretende?

Uma forma de verificar sem a implementação do algoritmo em nenhuma linguagem de programação

será executá-lo manualmente através da simulação das instruções constituintes.

Este processo designa-se por traçagem (do inglês dry running).

A traçagem consiste na construção de uma tabela com os seguintes elementos por colunas: Passo,

Iteração (a ver no próximo capítulo), Variáveis e a Saída.

Arbitrando valores de entrada para dos quais se sabe a saída a obter, inicia-se a execução do

algoritmo sequencialmente registando em cada linha da tabela os valores: o passo, a i teração, os

valores das variáveis e atribuições, a(s) saída(s) que vão acontecendo até se atingir o final do

algoritmo, verificando-se assim se resolveu ou não o problema.

Voltemos a analisar o algoritmo Soma2 e realizando a respetiva traçagem tomando 15 e 23 para

valores dos operandos.

Algoritmo Soma2

1 – [Entrada de dados] Escrever(‘Primeiro operando:’) Ler(Op1) Escrever(‘Segundo operando:’) Ler(Op2)

2 – [Cálculo da Soma]

Soma Op1 + Op2; 3 – [Apresentação de Resultados]

Escrever(‘A Soma é:’, Soma) 4 – [Terminar]

Sair

Obs. O valor esperado para a saída é 38, dado que a soma dos dois operandos é 38. Analisemos:

Traçagem

Passo Op1 Op2 Soma Saída

1 15 23

2 – – 38

3 – – – A Soma é: 38

No passo 1 foram lidos os valores dos operandos, no passo 2 e na coluna correspondente foi colocado

o carácter “–“ para designar que os valores dos operandos se mantêm, ou seja, se pretendesse -mos

usar alguma dessas variáveis noutra operação o valor seria o que foi atribuído no passo 1. O passo 4,

Sair, não é registado na traçagem.



1.8. Fluxogramas

Os Fluxogramas, também chamados de diagramas de fluxo, são uma representação gráfica de um

algoritmo, descrevendo-o de forma simples e fácil de entender. Esta representação, que utiliza um

conjunto de símbolos, é conhecida universalmente, é também uma das mais antigas e mais utilizadas

embora o seu uso tenha diminuído significativamente com o aparecimento das linguagens de

programação estruturadas.

No desenho de fluxogramas usa-se um conjunto de símbolos dos quais se apresentam apenas os

principais (com interesse a este nível):

Função Símbolo Início Retorno .......................................................................... Retorno Entrada e Saída de dados ................................................ Processamento de dados ................................................ Caixa de Decisão .............................................................

Vejamos agora o fluxograma correspondente ao nosso, já célebre, algoritmo Soma2.

Temos assim o nosso fluxograma constituído por cinco símbolos:

1º Início do fluxograma

2º Entrada de dados

3º Processamento

4º Saída de resultados

5º Fim do fluxograma

Nota:

Repare que no 2º símbolo podiam omitir-se as instruções Escrever(), ficariam só as instruções Ler(Op1) e Ler(Op2).

Inicio

Escrever(‘Primeiro operando:’) Ler(Op1) Escrever(‘Segundo operando:’) Ler(Op2)

Escrever(‘A Soma é:’, soma)

Soma Op1 + Op2

Fim



1.9. Exercícios Propostos

1 – Identifique o tipo de cada um dos seguintes dados:

‘Maria dos Prazeres’

- 2345

Falso

‘3.500$00’

8,7345E22

45340

2 – Qual o resultado de cada uma das seguintes operações?

34 Mod 10

23 Div 4

18 > 14,5

3,437 = 422

15 <= -27

7 * 4

3 – Transforme as expressões de modo a poderem ser usadas em programação.

4 – Diga o que entende por:

a) Algoritmo;

b) Método Top-Down;

5 – Para os problemas seguintes desenvolva: o algoritmo, fluxograma e traçagem (arbitrando, neste

último, valores que lhe pareçam aceitáveis):

a) Dada a medida do lado de um quadrado, calcular a área (área = l x l = l 2)

b) Para um aluno, dadas as notas dos três períodos calcular a média final do ano;

c) Calcular a área e perímetro de um retângulo, dadas as medidas do comprimento e da largura

(área = comp x larg e Perímetro = 2 x comp + 2 x larg);

d) Calcular a área do triângulo dada a medida da base e a altura (área = b x h /2);

e) Calcular a área e o perímetro de um círculo (área = Pi x r2 e Perímetro = 2 x Pi x r);

f) Dados dois operandos calcular a Soma e o Produto;

g) Calcular a área do trapézio dadas as medidas das bases e a altura (área = (B + b)/2 x h);

3x2 + 7

(x-2)2

7(ab2 +1)

ab2

52 x 2ab

a+b2



CAP 2. ESTRUTURAS DE CONTROLO

Na resolução de um problema é frequente surgirem situações que vão além do uso sequencial de

instruções. Como por exemplo:

1 - Analisar uma condição ou condições de forma a determinar qual ou quais as ações a executar;

2 - Repetir um conjunto de instruções um determinado número de vezes, ou até que se verifique

uma condição ou ainda enquanto se verificar uma condição;

3 - Conjuntos de instruções que se repetem em diversos pontos do programa, havendo interesse

em transforma-las num subprograma, por forma a ser invocado apenas pelo nome e

parâmetros respetivos (a tratar posteriormente neste manual).

Temos assim apresentadas as estruturas de controlo usadas em programação. Para melhor

compreensão vejamos o quadro seguinte:

Estruturas

De

Controlo

Sequencial – ordenação sequencial de instruções

Condicionais

Simples Se ... Então

Dupla Se ... Então

Senão

Múltipla Caso ... Seja

Repetitivas

(ou Cíclicas)

Repetir ... Até

Enquanto ... Fazer

Para ... Fazer

2.1. Estrutura Sequencial

A estrutura de controlo sequencial, consiste na ordenação das instruções de um

algoritmo de modo a que sejam executadas em sequência sem possibilidade de

omitir nenhuma. Ao lado encontra-se o Fluxograma típico desta estrutura.

Exemplos deste tipo de estrutura são todos os algoritmos vistos até aqui dado

que todas as instruções são executadas sequencialmente.

Inicio

Acão 1

Acão n

Fim



2.2. Estruturas Condicionais

As estruturas condicionais realizam uma instrução ou conjunto de instruções ( ações) dependendo do

cumprimento ou não de uma condição ou instrução booleana, i.é., consoante o valor da condição é

verdadeiro (V) ou falso (F).

Existem três tipos básicos de estruturas condicionais: simples, dupla e múltipla.

2.2.1. Estrutura Condicional Simples (Se .. Então)

Esta estrutura é caracterizada pela avaliação ou teste de uma condição, i.é:

– se a condição é verdadeira executa uma ação ou conjunto de ações;

– se a condição é falsa, não efetua qualquer ação e sai do bloco (passa à ação seguinte).

É apresentado em seguida o fluxograma genérico desta estrutura bem como o algoritmo

contemplando a situação de termos uma instrução ou um conjunto de instruções.

Algoritmo (Sintaxe )

Uma Instrução Conjunto de Instruções

...

Se (cond) Então Ação

...

...

Se (cond) Então

Inicio Acção1 ... Acão n

Fim ...

Nota:

Repare na utilização dos delimitadores início e fim quando a estrutura engloba um conjunto de ações a realizar, situação comum a todas as estruturas à exceção da Repetir Até(cond).

Exemplo: dados dois números calcular o maior.

Algoritmo Maior

1- [Leitura de dados] Escrever(‘Primeiro número:’) Ler(a) Escrever(‘Segundo número:’) Ler(b)

2- [Cálculo e apresentação do maior] Se (a > b) Então

Escrever(‘O maior é:’, a)

Se (a < b) Então Escrever(‘O maior é:’, b)

Se (a = b) Então Escrever(‘Os números são iguais’)

3- [Terminar] Sair

Acão 1

Acão n

Cond

V

F



2.2.2. Estrutura Condicional Dupla (Se .. Então .. Senão)

Esta estrutura é caracterizada pela avaliação ou teste de uma condição, i.é:

– se a condição é verdadeira executa uma ação ou conjunto de ações;

– se a condição é falsa, executa uma outra ação ou conjunto de ações.

É apresentado em seguida o fluxograma genérico desta estrutura bem como o algoritmo

contemplando a situação de termos uma instrução ou um conjunto de instruções.

Algoritmo (Sintaxe )


...

Se (cond) Então Acção1

Senão Acão x

...

... Se (cond) Então

Inicio Acção1 Acão n

Fim Senão

Inicio Acão i Acão x

Fim ...

Exemplo: dado um número verificar se é positivo, negativo ou zero.

Algoritmo Sinal

1- [Leitura de dados]

Escrever(‘Qual o número:’) Ler(x)

2- [Verificação do sinal]

Se (a = 0) Então Escrever(‘O número é zero’)

Senão

Se (a > 0) Então Escrever(‘O número é positivo’)

Senão Escrever(‘O número é negativo’)

3- [Terminar]

Sair

2.2.3. Estrutura Condicional Múltipla (Caso .. Seja)

A estrutura condicional múltipla é caracterizada pela avaliação do valor de uma variável que pode ter

como resultado n (finito) valores distintos (1, 2, 3, ... n) seguindo-se a execução de uma das n

sequências de ações distintas.

Sintaxe de uma estrutura – refere-se à forma que essa estrutura pode tomar (ou algoritmo

genérico).

Acão 1

Acão n

Cond

V

F

Acão i

Acão x



Embora não contemplado por alguns autores será importante realçar que esta estrutura pode conter

um cláusula Senão que será executada quando o valor da variável não coincidir com nenhum dos n

valores (constantes) possíveis.

É apresentado em seguida o fluxograma genérico desta estrutura bem como o algoritmo com e sem a

cláusula Senão.

Algoritmo (Sintaxe)

Sem Senão Com Senão

Caso (Var) Seja

1: S1

2: S2

n: Sn

fim

Caso (Var) Seja

1: S1

2: S2

n: Sn

Senão Sx fim

Var é uma variável e S1, S2, Sn e Sx representam uma instrução ou conjunto de instruções.

A estrutura Caso embora não use delimitador início necessita ter delimitador fim.

Exemplo: Ler um dia da semana de 1 a 7 e apresentar o respetivo nome.

Algoritmo Dias

1- [Leitura de dados]

Escrever(‘Qual o dia:’) Ler(dia)

2- [Apresentação do nome do dia]

Caso (dia) Seja 1: Escrever(‘Domingo’) 2: Escrever(‘Segunda’) 3: Escrever(‘Terça’) 4: Escrever(‘Quarta’)

5: Escrever(‘Quinta’) 6: Escrever(‘Sexta’) 7: Escrever(‘Sábado’)

Senão Escrever(‘Dia Errado!!!)

fim

3- [Terminar]

Sair

2.3. Estrutura Repetitivas (ou Cíclicas)

As estruturas repetitivas (também chamadas de cíclicas ou iterativas) são indicadas quando existem

tarefas com carácter repetitivo, aplicando tratamento idêntico a conjuntos homogéneos d e dados.

Basta indicar uma vez a sequência de operações (ações a realizar) e repeti-las as vezes necessárias.

S1

Var

S2 Sn Sx

=1 Senão = n =2



É de extrema importância a correta definição do controlo do ciclo (número de iterações a efetuar)

podendo mesmo ocorrer um número de iterações diferente do previsto originando naturalmente

resultados errados.

A cada ciclo está associada uma condição cujo valor permitirá, ou não, terminar a repetição de ações.

O valor lógico da condição de controlo do ciclo deve ser suscetível de alterar no decorrer do

processamento, permitindo a paragem (fim do ciclo) caso contrário estaremos perante um ciclo

infinito que executará um número infinito de vezes.

2.3.1. Estrutura Enquanto .. Fazer

Esta estrutura caracteriza-se pela execução repetida de um processo (ação ou conjunto de ações)

enquanto se verifica o valor lógico verdadeiro de uma condição. Quando o valor lógico for falso

terminará o processamento iterativo. Pode ainda acontecer que a sequência de ações nunca seja

executada caso a condição seja falsa à partida. O teste da condição é feito no início do ciclo.

Apresenta-se a seguir o fluxograma e algoritmo respetivo:

Algoritmo (Sintaxe)


...

Enq (cond) Fazer

Acção1

...

... Enq (cond) Fazer

Inicio Acção1

Acão n Fim

...

Exemplo: Dado um inteiro positivo, calcular a soma de todos os números até esse número.

Algoritmo SomaSeq

1- [Inicializações]

Soma 0

I 1

2- [Leitura do número]

Escrever(‘Um número positivo:’)

Ler(N)

3- [Cálculo da Soma]

Enq (I < N) Fazer Início

Soma Soma + I

I I +1 fim

4- [Apresentação da Soma]


5- [Terminar]

Sair

Acão 1

Acão n

Cond

V

F



2.3.2. Estrutura Repetir .. Até

Esta estrutura permite que um conjunto de ações se repita até que uma determinada condição se

verifique (seja verdadeira). Como o conjunto de ações é executado antes do teste da condição, será

executado pelo menos uma vez. Esta estrutura é a aconselhada sempre que se quer fazer a validação

de uma entrada de dados (por exemplo: um número positivo).

Fluxograma e algoritmo respetivo:

Algoritmo (Sintaxe)


...

Repetir

Acção1

Até (cond)

...

...

Repetir

Acção1

Acão n

Até (cond)

...

Nota:

Esta estrutura mesmo quando engloba um conjunto de ações não usa início e fim.

Exemplo1: Dada uma sequência de n inteiros positivos, calcular o máximo e a sua posição.

Algoritmo MaxSeq


Max 0

I 1

2- [Leitura do nº de elementos da sequência]

Repetir Escrever(‘Nº de elementos da seq:’) Ler(N)

Até (N > 0)

3- [Leitura da seq. e cálculo do máximo] Repetir

Repetir Escrever(I,‘º elemento:’) Ler(x)

Até (x > 0)

Se (x > Max) Então início

Max x

Pos I fim

I I + 1

Até (I > N)

4- [Apresentação do Máximo]

Escrever(‘O Máximo é:’, Max)

5- [Terminar]

Sair

Acão n

Cond

V

F

Acão 1



Repare na necessidade de inicializar o máximo com um valor suficientemente pequeno de forma

que o primeiro número lido (positivo) seja superior a ele.

Vejamos outro exemplo, usando agora as estruturas repetir e enquanto com o Fluxograma respetivo:

Exemplo2: Ler um inteiro positivo e escrever os seus algarismos por ordem inversa.

(Ex. 123 –> algarismos: 3, 2 e 1).

Algoritmo DaAlgarismos Fluxograma


Repetir

Escrever(‘Qual o número:’)

Ler(x)

Até (x > 0)

2- [Decomposição e apresentação do nº em algarismos]

Enq (x > 0) Fazer

início

Resto x Mod 10

Escrever(Resto)

x x Div 10 fim

3- [Terminar]

Sair

Ainda o mesmo exemplo mas transformando o número num outro escrito por ordem inversa dos

seus algarismos

F

V

F

V

Início

Ler(x)

x > 0

Resto x Mod 10

Escrever(Resto)

x x Div 10

Fim

x > 0



Exemplo3: o número 123 dá o número 321.

Algoritmo InvNum 1- [Inicializações]

Inv 0


Repetir

Escrever(‘Qual o número:’) Ler(x)

Até (x > 0)

3- [Decomposição do nº e cálculo do invertido]

Enq (x > 0) Fazer início

Resto x Mod 10

Inv Inv * 10 + Resto

x x Div 10 fim

4- [Apresentação do nº invertido] Escrever(‘O nº invertido é:’, Inv)

5- [Terminar] Sair

2.3.3. Estrutura Para .. Fazer

Esta estrutura realiza a repetição da execução de um conjunto de ações, sendo controlado

automaticamente o número de vezes que o ciclo vai executar. É a estrutura adequada sempre que se

conhece previamente o número de vezes que o ciclo vai executar (o número de iterações).

Para o referido controlo automático é necessário definir uma variável numérica, o seu valor inicial e

final (o incremento é fixo e realizado pela própria estrutura). O ciclo termina quando o valor da

variável ultrapassar o valor final previamente definido. A condição é avaliada no início de cada

iteração. Vejamos o Algoritmo e respetivo fluxograma.

Algoritmo (Sintaxe)


...

Para i 1 até n Fazer

Acção1

...

...

Para i 1 até n Fazer Início

Acção1 Acão n

fim ...

Nota:

Para i 1 até n Fazer, deve ler-se: para i igual a (ou, a tomar o valor) 1 até n fazer.

Acão n

V

F

Acão 1

i 1 até n



Toda a estrutura Para .. Fazer pode ser convertida numa Enq .. Fazer. O inverso só é verdadeiro se a

condição de saída da estrutura Enq .. Fazer for expressa por uma variável numérica de incremento

constante (unitário). Caso se transforme uma estrutura Para .. Fazer numa Enq .. Fazer é necessário

inicializar a variável de controlo e efetuar o incremento.

Exemplo: Dado um inteiro positivo, calcular a soma de todos os números de 1 até esse número.

Algoritmo SomaSeq


Soma 0


Repetir Escrever(‘Um número positivo:’) Ler(x)

Até (x > 1)

3- [Cálculo da Soma]

Para i 1 até x Fazer

Soma Soma + I

4- [Apresentação da Soma]


5- [Terminar]

Sair

Obs. Este exercício foi resolvido atrás quando da apresentação da estrutura Enq .. Fazer.

Traçagem do algoritmo anterior. Valores 0, -1 e 5.

Passo Iteração i x Soma Saída

1 0

A Soma é: 15

2 1 2 3

0 -1 5

– – –

3

1

2

3

4

5

1

2

3

4

5

1

3

6

10

15

4

Caso a variável de controlo de um ciclo comece em 1 com incrementos unitários verificamos que o

valor da variável coincide com o valor da iteração parecendo esta coluna desnecessária, isto porém,

nem sempre acontece.




Para os problemas seguintes desenvolva: o algoritmo, fluxograma e traçagem (arbitrando valores

que lhe pareçam aceitáveis):

1 - Dados três números calcular o maior (se forem iguais deve avisar para esse facto);

2 - Dados dois operandos e uma operação (+, -, / e *) implementar uma calculadora de quatro

operações (0/n = Erro, sugestão: estrutura caso ... seja);

3 - Ler um número inteiro positivo N e escrever todos os números ímpares inferiores a N;

4 - Calcular a soma e média de uma sequência de n números (fim = 0);

5 - Dada uma sequência de n números inteiros contar o número de zeros, pares e ímpares;

6 - Calcular o valor de uma potência dados a base e o expoente pertencentes a Z;

7 - Ler um número na base 10 e convertê-lo para base 2;

8 - Ler um número na base 2 e convertê-lo para base 10;

9 - Ler um número inteiro positivo e verificar se é primo;

10 - Dado um número inteiro N calcule todos os números primos inferiores a N.

Nota: um número é primo se não tiver divisores entre 2 e n .



CAP 3. ESTRUTURAS DE DADOS

Até aqui, apenas se tem falado e trabalhado com dados de tipos simples (inteiro, real, carácter e

booleano ou lógico), ou seja, dados em que cada variável opera apenas com um determinado valor

de cada vez. No entanto, é possível agrupar um conjunto de dados numa mesma variável, estando

assim na presença de dados estruturados.

Uma estrutura de dados é um conjunto caracterizado pela sua organização e pelas operações que se

podem executar sobre a referida estrutura.

Os dados estruturados sobre os quais vai incidir o nosso estudo são os seguintes:

Algoritmia Pascal

1- Matriz ou Vetor

2- Cadeia de Caracteres

3- Registo

4- Conjunto

5- Ficheiro

1- Array

2- String

3- Record

4- Set

5- File

O tipo cadeia de caracteres pode também ser considerado um tipo de dados estruturados pois é um

construído à custa de um conjunto de dados do tipo carácter (1 a 255 caracteres ASCII).

Neste capítulo vão ser abordados apenas os tipos Matriz e Cadeia de Caracteres (os restantes serão

abordados no Capítulo 5 e seguintes)

3.1. Vetores e Matrizes – Arrays

Este tipo de dados estruturado é o mais comum. Na tradução para português pode ser designado

como vetor ou matriz.

Um array (vetor ou matriz)é um tipo de dados que agrupa numa mesma variável um conjunto de

valores do mesmo tipo (inteiro, real, booleano, carácter, cadeia de caracteres, array ou registo).

Pode ser definido como sendo uma estrutura de armazenamento de dados (em memória – logo

volátil), ou ainda, um conjunto finito e ordenado de elementos homogéneos (do mesmo tipo).

Quando se refere ordenado significa que é possível identificar qualquer um dos seus elementos, i.é,

o 1º, 2º, 3º, etc.



Entende-se por vetor, um array unidimensional que é constituído por uma lista de dados ordenados

segundo um índice, índice esse que identifica o número de ordem ou posição que cada elemento

ocupa na lista.

O seu armazenamento na memória do computador é feito em posições ordenadas e adjacentes,

podendo assim, cada elemento ser considerado como uma variável simples atribuída a uma posição

de memória.

Exemplo: Vejamos o array Num de n posições.

7 15 -2 ... 22

Num[1] Num[2] Num[3] Num[...] Num[n] Por exemplo: o valor do array Num na posição 2 é referenciado como Num[2] e é igual a 15.

3.1.1. Operações sobre Vetores

Sobre vetores podem realizar-se as seguintes operações:

1. Atribuição

Fazendo: Num[2] 0 e Num[n] -11 passamos a ter:

7 0 -2 ... -11

Num[1] Num[2] Num[3] Num[...] Num[n] 2. Leitura/Escrita

Escrever(‘Insira o 5º elemento do Array:’)

Ler(Num[5]); Na posição 5 do array ficará armazenado o valor introduzido pelo utilizador. Escrever (Num[1]) – apresentará no monitor o valor: 7

Escrever (Num[2]) – apresentará no monitor o valor: 15

3. Atualização: inserção, alteração e eliminação de elementos

As operações de inserção, alteração e eliminação podem ser efetuadas através da leitura ou

atribuição de valores às posições do array.

4. Pesquisa de um elemento

5. Ordenação dos elementos

As operações de pesquisa e de ordenação são efetuadas através de um conjunto de ações e de

algoritmos próprios, como se descreve nas páginas seguintes.



3.1.2. Pesquisa de um elemento num Vetor

O algoritmo seguinte permite ler os n (n – valor genérico) elementos de um vetor A e em seguida lê

um outro elemento que será pesquisado no vetor, i.é., verifica se ele existe.

Algoritmo Pesquisa


Enc Falso

k 1

2- [Leitura do Array]

Para i 1 até n Fazer início

Escrever(i,‘º elemento:’) Ler(A[i])

fim

3- [Leitura do elemento a pesquisar]

Escrever(‘Elemento a pesquisar:’) Ler(x)

4- [Pesquisa]

Enq (( ~ Enc) ( k <= n)) Fazer início

Se (x = A[k]) Então início

Enc Verdadeiro

Pos k fim

k k + 1 fim

5- [Apresentação do resultado da pesquisa]

Se (Enc) Então Escrever(‘Elemento encontra-se na posição:’, Pos)

Senão Escrever(‘O elemento’, x ,’não existe no array!!!’)

6- [Terminar] Sair

3.1.3. Ordenação dos elementos de um Vetor

Veremos agora como ordenar de forma ascendente ou descendente os elementos de um vetor,

supondo o vetor já preenchido com os respetivos valores.

Para se realizar uma ordenação Descendente ou

decrescente basta trocar o operador relacional na

condição do Se de > para <.

Numa traçagem com 6 elementos:

7, -2, 0, 150, 18 e 92 obtêm-se as seguintes

sequências até à sequência final (a sombreado)

Iterações j It

eraç

ões

i

-2 7 0 150 18 92

-2 0 7 150 18 92

-2 0 7 150 18 92

-2 0 7 18 150 92

-2 0 7 18 92 150



Algoritmo Ordena (ordenação Ascendente ou Crescente)

1- [Ordenação do vetor]

Para i 1 até n-1 Fazer

Para j i + 1 até n Fazer

Se (A[i] > A[j]) Então início

Aux A[i]

A[i] A[j]

A[j] Aux fim

2- [Apresentação do vetor ordenado]

Para i 1 até n Fazer Escrever(A[i])

3- [Terminar]

Sair

3.1.4. Matrizes – Arrays Multidimensionais

Até ao momento temos tratado de arrays unidimensionais ou vetores, mas pode haver necessidade

de usar arrays bidimensionais ou mesmo multidimensionais.

Os arrays bidimensionais (tabelas) possuem os seus elementos dispostos como se vê a seguir e são

identificados por dois índices, podemos mesmo considerar uma tabela como sendo um vetor de

vetores.

Aspeto genérico de uma matriz:

A[1,1] A[1,2] A[1,3] A[1,4] ... A[1,m]

A[2,1] A[2,2] A[2,3] A[2,4] ... A[2,m]

A[3,1] A[3,2] A[3,3] A[3,4] ... A[3,m]

A[4,1] A[4,2] A[4,3] A[4,4] ... A[4,m]

... ... ... ... ... ...

A[n,1] A[n,2] A[n,3] A[n,4] ... A[n,m]

Em que A[i,j] se refere ao elemento que se encontra matriz A na linha i e na coluna j.

Para a matriz X podemos afirmar:

X[1,1]= 7 X[1,2]= -5 X[1,3]= 14

X[2,1]= 2 X[2,2]= 0 X[2,3]= 18 e por aí adiante.

7 -5 14

2 0 18

8 9 -1

Esta matriz diz-se que é uma matriz de

ordem n x m (ler n por m), i.é, tem n

linhas e m colunas

X



Exemplo de um problema envolvendo Matrizes.

Problema: Pretende-se um algoritmo que dadas duas matrizes Anxm e Bnxm da mesma ordem

(mesmo nº de linhas e o mesmo nº de colunas) calcule a matriz Cnxm = Anxm + Bnxm.

Algoritmo SomaMat

1- [Leitura das Matrizes A e B]


Para j 1 até m Fazer início

Escrever(‘Elemento a’,i,j,’: ‘) Ler(A[i,j])

fim


Para j 1 até m Fazer início

Escrever(‘Elemento b’,i,j,’: ‘) Ler(B[i,j])

fim

2- [Cálculo da matriz C]


Para j 1 até m Fazer

C[i,j] A[i,j] + B[i,j]

3- [Apresentação da matriz C]


Para j 1 até m Fazer Escrever(C[i,j])

4- [Terminar] Sair

A Multiplicação de Matrizes poderá ser tema de um trabalho prático a implementar mais tarde em

linguagem Pascal.

Note que, para multiplicar duas matrizes é condição necessária que o número de colunas da

primeira matriz seja igual ao número de linhas da segunda, i.é., se tivermos as matrizes:

Anxm e Bpxm pela multiplicação A x B iremos obter a matriz Cnxm. Poderá considerar 100

como valor limite para linhas e colunas (uma matriz A100x100 de inteiros ocupa 20.000 Bytes

de memória)

Nota:

As matrizes bidimensionais são sempre

processadas por linhas (o mesmo

acontecendo com o seu armazenamento em

memória).

Assim, e por exemplo, para a leitura dos

elementos de uma matriz Anxm (n linhas e m

colunas) temos dois ciclos Para..Fazer

encaixado.

O ciclo exterior percorre a matriz por linhas (de

1 até n).

O ciclo interior percorre todos os elementos

de uma linha (que é igual ao número de

colunas).



3.2. Cadeias de Caracteres – strings

Uma cadeia de caracteres é uma sequência de caracteres (letras, algarismos e caracteres especiais e

de controlo, incluindo o espaço vazio – carácter 255 da tabela ASCII), vulgarmente delimitada por

apóstrofes (ou plicas). Uma cadeia de caracteres que não possua nenhum carácter, diz -se uma cadeia

vazia.

Ao número de caracteres de uma string chama-se comprimento da string. Em Pascal uma string pode

ter comprimento fixo ou variável, vejamos um exemplo:

Nome1 : String[10]; é a declaração em Pascal de uma string com comprimento fixo de 10;

Nome2: String; é a declaração de uma string com comprimento variável, 1 a 255 caracteres; uma

string em Pascal pode também ser tratada como um array de caracteres.

O tipo String não é um tipo standard, está contemplado no Turbo Pascal mas no Pascal Padrão

designa-se porque Packed Array, tendo no entanto algumas diferenças.

Caracteres da Tabela ASCII:

Alfabéticos (a, b, c, ..., z, A, B, ..., Z);

Numéricos (0,1,2,3, ..., 9);

Especiais (+, -, %, $, #, &, ..., <, >, ...);

De Controlo (não se escrevem ou imprimem “non printable” mas desempenham funções

especiais, por exemplo: 7 – Bell, 10 – Line Feed, 13 – Carriage Return, 27 - Escape).

Exemplo: NovaLinha: String[2] = #13#10; Escrever a string NovaLinha é equivalente a

carregar em Enter, pois a string contem 2 caracteres de controlo (13 e 10):

#13 Carriage Return – põe o cursor no início da linha atual (coluna 1);

#10 Line Feed – muda o cursor para uma nova linha (mantendo a coluna).

Algumas Operações possíveis sobre cadeias de caracteres:

1 - Atribuição – ()

Nome ‘Natasha Marisa dos Prazeres e Morais’; é atribuído o nome entre plicas à variável

do tipo string Nome.

2 - Entrada/Saída – Ler( ) e Escrever( )

Escrever(‘Escreva o seu apelido:’); é apresentada a string Escreva o seu apelido:

Ler(Apelido); é guardado o nome introduzido na variável Apelido;



3 - Cálculo de Comprimento – Comp(str)

Comp(str) dá como resultado o número de caracteres da string;

Comp(Nome) = 36; Nome é a variável usada em 1.

Comp(‘Maria’) = 5

4 - Comparação – (usando os operadores relacionais: =, <>, <, <=, >, >=)

Duas cadeias A e B são iguais se:

– tiverem o mesmo comprimento;

– os caracteres homólogos são iguais;

Obs. Note que o carácter A (ascii 65) é diferente do carácter a (ascii 97).

5 - Concatenação – +

Esta operação consiste em reunir duas ou mais cadeias de caracteres numa só, conservando,

no entanto, a ordem dos caracteres no interior de cada uma. O operador atua como um

operador aritmético adicionando a segunda cadeia à primeira de forma adjacente.

A ‘Bora lá’, B ‘estudar’, C ‘TLP’,

S A + ‘ ‘ + B + ‘ ‘ + C

Escrever(S);

daria como resultado: ‘Bora lá estudar TLP’

6 - Extração de parte(s) de uma cadeia – Sub( )

Sub(cadeia, início, comprimento) – dá a subcadeia da cadeia de caracteres começando na

posição início e com o comprimento estabelecido. Exemplos:

Sub(‘Algoritmo’,1,5); daria como resultado: ‘Algor’

Sub(‘Algoritmo’,3,4); daria como resultado: ‘gori’

7 - Pesquisa – Pos( )

Pos(cadeia1, cadeia2) – pesquisa a cadeia2 na cadeia1 e dá resultado 0 se não encontrar ou

diferente de zero que será a posição de início da cadeia2.

Pos(‘Algoritmo’, ’algor’); daria como resultado: 0

Pos(‘Algoritmo’, ’Algor’); daria como resultado: 1

Pos(‘O Manel e Maria foram à festa’, ’x’); daria como resultado: 0

Pos(‘O Manel e Maria foram à festa’, ’foram’); daria como resultado: 17



8 - Inserção – Inserir( )

Inserir(cadeia1, posição, cadeia2) insere a cadeia2 na cadeia1 a partir da posição

especificada.

Inserir(‘Quem tolo’,5, ‘dá tudo o que tem é ’); resultado: ‘Quem dá tudo que tem é tolo’

Inserir(‘Hoje cinema’, 5, ‘vou ao ’); resultado: ‘Hoje vou ao cinema’

9 - Eliminação – Apagar( )

Apagar(cadeia, posição, comprimento) apaga o comprimento de caracteres na cadeia a

partir da posição especificada.

Apagar(‘Penso, logo existo!!’,11,7); daria o resultado: ‘Penso, logo!!’

10 - Conversão – Valor( ) e Cadeia( )

Valor(cadeia) – converte a cadeia para um valor; em pascal Val(s, v, c);

Cadeia(número) – converte o número numa cadeia; em pascal Str(v, s);

Sendo: s – string; v – Value; c - code;

Exemplos:

Valor(‘1234’) transforma a string ‘1234’ no valor 1234;

Cadeia(456) transforma o número 456 na string ´456’

3.2.1. Vetores de Cadeias de Caracteres – Arrays de Caracteres

Um vetor, como já foi dito anteriormente, pode armazenar dados do tipo, entre outros, carácter ou

cadeia de caracteres. Quando o vetor é do tipo carácter, armazena em cada posição um elemento

desse tipo ou seja um carácter ascii de 0 a 255. Porém, se o vetor é do tipo cadeia de caracteres

armazena em cada posição uma cadeia de caracteres, podendo também ser acedidos

individualmente.

Esta particularidade pode, numa primeira abordagem, parecer de pouca mas se pensarmos em

termos da entrada/saída de dados do tipo cadeia de caracteres (ex. nomes, moradas, ...) torna-se

mais percetível a sua importância.

Seria razoavelmente desagradável elaborar um algoritmo (programa) para lidar com entrada/saída de

dados deste tipo fazendo o processamento carácter a carácter, senão vejamos um problema

exemplo: Ler os nomes e idades de n alunos de uma turma e ordená-los por ordem ascendente de

nome.



Algoritmo NomeIdade (ordenação Ascendente)

1- [Leitura do número de alunos]

Repetir

Escrever(‘Número de alunos da turma: ’) Ler(n)

Até (n > 0) 2- [Leitura dos Nomes e Idades]


início

Escrever(‘Nome do Aluno nº’,i,’: ‘) Ler(Nome[i])

Repetir

Escrever(‘Idade do Aluno nº’,i,’: ‘) Ler(Idade[i])

Até ((Idade[i]) > 0) (Idade[i]) < 100)) fim

3- [Ordenação dos Nomes e Idades]

Para i 1 até n-1 Fazer

Para j i + 1 até n Fazer

Se (Nome[i] > Nome[j]) Então início

NomAux Nome[i]

Nome[i] Nome[j]

Nome[j] NomAux

IdadAux Idade[i]

Idade[i] Idade[j]

Idade[j] IdadAux fim

4- [Apresentação Nomes e Idades Ordenados]

Para i 1 até n Fazer Escrever(Nome[i],’...........’, Idade[i])

5- [Terminar] Sair

Existe ainda um outro tipo de vetores, os vetores de registos, que serão analisados mais à frente

neste Manual quando da apresentação do tipo de dados Registo.

Nota:

O nome do aluno é lido de uma só vez, ou

seja, o vetor Nome é aqui tratado como

um vetor de cadeias de caracteres (é lida

uma cadeia de caracteres de cada vez – um

nome).

Se assim não fosse os nomes teriam que

ser lidos carácter a carácter o que além de

fastidioso exigiria um algoritmo

consideravelmente mais elaborado por

forma a simular esta facilidade.

A idade do aluno é validada num intervalo

que vai de zero a cem anos (por exemplo).

Repare ainda na ordenação, é ordenado o

nome e a respectiva idade, i.é., quando é

trocado um nome tem que ser efectuada a

troca na idade respectiva.

A apresentação de dados é feita numa só

linha, nome e idade.




Para os problemas seguintes desenvolva: o algoritmo e respetivo fluxograma: 1 - Ler um vetor de 20 elementos e um valor a pesquisar nesse vetor. Efetuar a pesquisa e avisar o

utilizador se o elemento existe ou não no vetor e a sua posição.

2 - Ler o total de vendas mensal (em unidades monetárias) de duas lojas durante seis meses e

verificar qual das lojas teve maior volume de vendas nesse semestre.

3 - Dada uma sequência de n números calcular: o máximo, o mínimo, a diferença entre o máximo

e o mínimo. Deverá ainda contar as ocorrências de elementos da sequência iguais a essa

diferença;

4 - Num concurso para admissão de empregados administrativos, os 100 candidatos selecionados

terão de prestar uma prova de dactilografia com a duração de 5 minutos. Pretende-se elaborar

um algoritmo que dado o nome, o número de palavras e o número de erros de cada candidato

determine a pontuação e resultado obtidos sabendo que:

Pontuação = [número de palavras – (12 x número de erros)] / 5

e o resultado do teste tem os seguintes valores:

Pontuação < 45 ....................................................Reprovado

46 < Pontuação < 52 .............................................Novo Teste

Pontuação > 52 ....................................................Aprovado

5 - Ler um texto de no máximo 200 caracteres (palavras separadas por um espaço) e contar o

número de palavras, de vogais e espaços.

6 - Dados dois vetores V1[] e V2[] com 20 elementos cada, adicionar os elementos de índice impar

colocando o resultado da operação num terceiro vetor Res[]. Caso o índice seja par, a operação

a realizar deve ser a subtração.

7 - Ler os nomes dos 20 alunos de uma turma e as notas dos três períodos e calcular a média final

dando indicação sobre o resultado final, aprovado ou reprovado. Um aluno terá como

resultado aprovado se a média for maior ou igual a 9.45.


Página 37

CAP 4. INTRODUÇÃO À LINGUAGEM PASCAL

BREVEMENTE!!!

algoritmia e programação

Documents