ENG06842 - Prof. Jacson...

UNIVERSIDADE FEDERAL DO ESPÍRITO SANTOCENTRO DE CIÊNCIAS AGRÁRIASDEPARTAMENTO DE ENGENHARIA RURAL

ENG06842

PROGRAMAÇÃO I

PARTE 1

Prof. Geraldo Regis Mauri

CCA-UFESAgosto - 2009

ENG06842 – Programação I

Apresentação

A disciplina Programação I (ENG06842) visa dotar os acadêmicos de uma

visão geral do processo de programação e da investigação das técnicas e

ferramentas que podem ser utilizadas para a geração de programas

estruturados. Ao final do curso, os acadêmicos deverão ser capazes de

conhecer e entender os principais conceitos referentes à construção de

algoritmos estruturados e à implementação desses algoritmos na

Linguagem Pascal.

Esta apostila foi elaborada a partir das notas de aula, dos livros da

bibliografia recomendada e de outros materiais encontrados na Internet, e

visa auxiliar na compreensão dos conceitos abordados ao longo do curso,

bem como promover a prática na construção de algoritmos através de um

grande número de exercícios apresentados no final de cada capítulo.

Esta apostila deve ser usada somente como material complementar, e

NUNCA como única fonte de estudo, ou seja, o seu objetivo não é

substituir os livros, é mostrar aos alunos o curso que os aguarda,

possibilitando um planejamento prévio do estudo e do aprendizado.

Considero que a programação deve ser entendida como uma “arte” de

construir algoritmos, sendo que estes são métodos ou “receitas” para se

resolver problemas.

A melhor forma de aprender a programar é programando, assim como a

melhor forma de aprender a dirigir é entrar num automóvel e sair com ele

por aí, ou seja, o simples fato de ler esta pequena e simples apostila não

basta para aprender a programar.

Por fim, estou à disposição de todos que se aventurem a acompanhar este

curso, tanto para tirar dúvidas quanto para receber críticas e sugestões.

2


Contato: [email protected] ou [email protected]

Este material está disponível para download no site:

http://www.grmauri.pro.br.

3

http://www.grmauri.pro.br/

mailto:[email protected]

mailto:[email protected]


Sumário

Apresentação ............................................................................................................................... 2 1.Lógica de programação ............................................................................................................ 5 1.1.Introdução ............................................................................................................................ 5 1.2.Instruções .............................................................................................................................. 5 1.3.Seqüências lógicas ................................................................................................................ 6 1.4.Exercícios .............................................................................................................................. 7 2.Resolução de problemas através do computador ................................................................... 11 2.1.Introdução .......................................................................................................................... 11 2.2.Programação ........................................................................................................................ 15 2.3.Programas ............................................................................................................................ 17 2.4.Exercícios ............................................................................................................................ 17 3.Algoritmos ............................................................................................................................. 18 3.1.Introdução ........................................................................................................................... 18 3.2.Principais características dos algoritmos ............................................................................ 19 3.3.Regras para construção de algoritmos ................................................................................ 20 3.4.Refinamentos sucessivos ..................................................................................................... 23 3.5.Representação de algoritmos .............................................................................................. 25 3.6.Exercícios ............................................................................................................................ 30 4.Elementos fundamentais de programação .............................................................................. 32 4.1.Tipos básicos de dados ........................................................................................................ 32 4.2.Constantes .......................................................................................................................... 33 4.3.Variáveis ............................................................................................................................. 34 4.4.Identificadores ..................................................................................................................... 35 4.5.Comentários ....................................................................................................................... 36 4.6.Expressões aritméticas ....................................................................................................... 38 4.7.Expressões lógicas .............................................................................................................. 39 4.8.Prioridade entre operadores ................................................................................................ 40 4.9.Comandos de atribuição ...................................................................................................... 41 4.10.Comandos de entrada e saída ............................................................................................ 42 4.11.Esquema genérico em pseudolinguagem .......................................................................... 42 4.12.Exercícios .......................................................................................................................... 44 5.Estruturas de controle ............................................................................................................. 49 5.1.Seqüencial ........................................................................................................................... 49 5.2.Condicional ......................................................................................................................... 49 5.3.Repetição ............................................................................................................................. 51 5.4.Loop infinito ....................................................................................................................... 54 5.5.Variáveis especiais .............................................................................................................. 55 5.6.Exercícios ............................................................................................................................ 57 6.Técnicas de verificação de algoritmos ................................................................................... 63 6.1.Exercícios ............................................................................................................................ 65 Referências ................................................................................................................................ 69

4


1. Lógica de programação

1.1. Introdução

Desde os primórdios da história da computação existe uma base de

conhecimento que não mudou e não mudará “nunca” – a Lógica de

Programação.

A Lógica de Programação pode ser associada diretamente com o

Raciocínio Matemático, onde o importante é a interpretação de um

problema e a utilização correta de uma fórmula. O saber da Lógica está

no “praticar”.

Não existem “fórmulas” em computação, o que existe é o

aperfeiçoamento de nossa forma de pensar e raciocinar sobre um

problema, podendo extrair do mesmo uma solução eficiente e eficaz, sob

um determinado ângulo de visão. Assim, verificamos que é preciso

aprender a pensar sobre os problemas, extraindo deles o máximo de

informações.

A solução que criamos para um determinado problema necessita ser

exteriorizada e expressa numa linguagem publicamente conhecida. Assim,

utilizamos a lógica de programação para desenvolver nossas soluções e os

“algoritmos” para apresentar essas soluções ao mundo.

A lógica de programação é necessária para pessoas que desejam trabalhar

com desenvolvimento de sistemas e programas, pois ela permite definir a

seqüência lógica para o desenvolvimento destes.

Então, o que é lógica de programação? É a técnica de encadear

pensamentos para atingir determinado objetivo.

1.2. Instruções

Na linguagem comum, entende-se por instruções “um conjunto de regras

ou normas definidas para a realização ou emprego de algo”. Em

5


informática, porém, instrução é a informação que indica a um computador

uma ação elementar a executar.

Convém ressaltar que uma ordem isolada não permite realizar o processo

completo, para isso é necessário um conjunto de instruções colocadas em

ordem seqüencial lógica. Por exemplo, se quisermos fazer uma omelete

com queijo, precisaremos colocar em prática uma série de instruções:

picar o queijo, bater os ovos, acrescentar o queijo, etc...

É evidente que essas instruções têm que ser executadas em uma ordem

adequada – não se pode fritar o queijo e depois adicioná-lo aos ovos.

Dessa maneira, uma instrução tomada em separado não tem muito

sentido; para obtermos o resultado, precisamos colocar em prática o

conjunto de todas as instruções, na ordem correta.

Então, pode-se definir instruções como sendo um conjunto de regras ou

normas definidas para a realização ou emprego de algo. Em informática, é

o que indica a um computador uma ação elementar a executar.

1.3. Seqüências lógicas

Pode-se definir uma seqüência lógica como sendo um conjunto de passos

executados até atingir um objetivo ou solução de um problema.

Até mesmo as coisas mais simples, podem ser descritas por seqüências

lógicas. Por exemplo:

“Chupar uma bala”

• Pegar a bala

• Retirar o papel

• Chupar a bala

• Jogar o papel no lixo

6


1.4. Exercícios

1. Crie uma seqüência lógica para tomar banho.

2. Há três suspeitos de um crime: o cozinheiro, a governanta e o

mordomo. Sabe-se que o crime foi efetivamente cometido por um ou

por mais de um deles, já que podem ter agido individualmente ou não.

Sabe-se, ainda que:

• se o cozinheiro é inocente, então a governanta é culpada;

• ou o mordomo é culpado ou a governanta é culpada, mas não os

dois;

• o mordomo não é inocente.

Logo:

(a) a governanta e o mordomo são os culpados

(b) o cozinheiro e o mordomo são os culpados

(c) somente a governanta é culpada

(d) somente o cozinheiro é inocente

(e) somente o mordomo é culpado.

3. Qual o número que completa a seqüência: 1, 3, 6, 10, ...

(a) 13

(b) 15

(c) 12

(d) 11

(e) 18

4. Faça a seqüência lógica para somar dois números e multiplicar o

resultado pelo primeiro número.

5. Qual o número que completa a seqüência: 1, 1, 2, 3, 5, ...

(a) 5

(b) 6

(c) 7

7


(d) 8

(e) 9

6. Descreva com detalhes a seqüência lógica para trocar um pneu de um

carro.

7. Num concurso de saltos, Maria foi, simultaneamente, a 13ª melhor e

13ª pior. Quantas pessoas estavam em competição?

(a) 13

(b) 25

(c) 26

(d) 27

(e) 28

8. Bruno é mais alto que Joaquim. Renato é mais baixo que o Bruno.

Então, Joaquim é o mais alto dos três.

( ) Verdadeiro

( ) Falso

9. Faça um algoritmo para trocar uma lâmpada.

10. O preço de um produto foi reduzido em 20% numa liquidação. Qual

deverá ser a percentagem de aumento do preço do mesmo produto

para que ele volte a ter o preço original?

(a) 15%

(b) 20%

(c) 25%

(d) 30%

(e) 40%

11. Chapeuzinho Vermelho ao entrar na floresta, perdeu a noção dos

dias da semana. A Raposa e o Lobo Mau eram duas estranhas criaturas

que freqüentavam a floresta. A Raposa mentia às segundas, terças e

quartas-feiras, e falava a verdade nos outros dias da semana. O Lobo

8


Mau mentia às quintas, sextas e sábados, mas falava a verdade nos

outros dias da semana.

Um dia Chapeuzinho Vermelho encontrou a Raposa e o Lobo Mau

descansando à sombra de uma árvore. Eles disseram:

Raposa: “Ontem foi um dos meus dias de mentir”

Lobo Mau: “Ontem foi um dos meus dias de mentir”

a) A partir dessas afirmações, Chapeuzinho Vermelho descobriu qual

era o dia da semana. Qual era?

b) Em qual dia da semana é possível a Raposa fazer as seguintes

afirmações?

Eu menti ontem.

Eu mentirei amanhã.

12. João quer ir ao cinema assistir ao filme “Matrix”, mas não tem

certeza se o mesmo está sendo exibido. Seus amigos, Maria, Luis e

Julio têm opiniões discordantes sobre se o filme está ou não em cartaz.

Se Maria estiver certa, então Julio está enganado. Se Julio estiver

enganado, então Luís está enganado. Se Luis estiver enganado, então

o filme não está sendo exibido. Ora, ou o filme “Matrix” está sendo

exibido, ou João não irá ao cinema. Verificou-se que Maria está certa.

Logo:

(a) O filme “Matrix” está sendo exibido

(b) Luis e Julio não estão enganados

(c) Julio está enganado, mas Luis não.

(d) Luis está enganado, mas Julio não.

(e) João não irá ao cinema.

9


10


2. Resolução de problemas através do computador

2.1. Introdução

Todos os computadores, independentemente dos seus tamanhos e/ou

fabricantes, são conceitualmente semelhantes ao esquema da figura

abaixo (há algumas diferenças, mas não trataremos aqui dos casos

especiais). Essa figura apresenta uma “máquina hipotética” para a qual

criaremos nossos programas.

CPU (Unidade Central de Processamento)

Unidade Lógica e Aritmética

(2)

Unidade de Controle(3)

Dispositivo de saída(5)

Dispositivo de entrada(1)

Memória Principal(4)

Fluxo de controle

Fluxo de dados

CPU (Unidade Central de Processamento)

Unidade Lógica e Aritmética

(2)

Unidade de Controle(3)

Dispositivo de saída(5)

Dispositivo de entrada(1)

Memória Principal(4)

Fluxo de controle

Fluxo de dados

Cada uma das partes constituintes da figura acima tem os seguintes

significados:

(1) Dispositivo de entrada (o teclado, mouse, etc...): É o meio pelo qual

os dados que serão trabalhados pelo algoritmo vão ser introduzidos

em nosso computador hipotético;

(2) Unidade Lógica e Aritmética (ULA): Parte responsável pelas

operações matemáticas e avaliações lógicas;

(3) Unidade de Controle: Exerce controle sobre as demais partes do

nosso computador. É uma verdadeira gerente que distribui tarefas

às outras unidades;

11


(4) Memória: Guarda o algoritmo a ser executado e os dados a serem

utilizados pelo mesmo. Todo dado fornecido ao computador e o

resultado de suas operações ficam guardados na memória;

(5) Dispositivo de Saída (vídeo, impressora, etc...): É o meio que se

dispõe para apresentação dos resultados obtidos.

Resumidamente, pode-se afirmar que existem quatro operações básicas

que qualquer computador pode executar:

a) operações de entrada e saída: ler dados do teclado e escrever dados

na tela são exemplos destas operações. Elas servem para introduzir

dados na memória do nosso computador e exibir os dados que já

estejam lá armazenados;

b) operações aritméticas: são utilizadas na realização de operações

matemáticas (adição, subtração, multiplicação e divisão);

c) operações lógicas e relacionais: têm aplicabilidade em comparações,

testes de condições lógicas (2>6?; X=Y?);

d) movimentação de dados entre os vários componentes: as operações

aritméticas são executadas na Unidade Lógica e Aritmética,

necessitando da transferência dos dados para essa unidade e da

volta do resultado final para ser guardado na memória.

Os computadores podem ser usados de forma eficiente na solução de

certos tipos de problemas. Os problemas que suportam tratamento por

computador, em geral, envolvem grandes quantidades de dados ou são

problemas de natureza complexa, exigindo a execução de um grande

número de passos para alcançar a solução. Basicamente são problemas na

área de processamento de dados e na área científica.

O computador é uma ferramenta que permite a realização do

processamento automático (ou eletrônico) de dados. Define-se por

Processamento de Dados qualquer atividade que, utilizando informações

(ou dados), efetua transformações para obter novas informações (ou

12


dados) como resultado. Entretanto, o computador é uma máquina capaz

de executar processos de acordo com regras precisamente definidas,

sendo que:

• Existe um repertório finito de instruções elementares que o

computador entende e é capaz de executar.

• Os elementos desse repertório finito podem ser agrupados (ou

programados) de modo a dar origem a um número infinito de

combinações. Exemplos:

o Música (composta pela combinação das 7 notas musicais)

o Representação decimal de números reais (a partir de dígitos

de 0 a 9)

A tarefa desempenhada pelos computadores é apenas parte do processo

de solução de problemas, sendo todo esse processo descrito pelas

seguintes etapas:

i) Entendimento do problema;

ii) Criação de uma seqüência de operações (ou ações) que, quando

executadas, produzem a solução para o problema;

iii) Execução desta seqüência de operações.

iv) Verificação da adequação da solução.

As etapas de entendimento do problema, criação de seqüência de ações e

verificação da adequação da solução são tarefas desempenhadas por

pessoas. Já a execução das operações pode ser desempenhada por

computadores. Os computadores têm a capacidade de executar processos

complicados e com grande quantidade de informações com rapidez e

confiabilidade.

Exemplo: Suponha que queiramos resolver o seguinte problema: a partir

de dois números que serão informados, calcular a soma dos mesmos. Se

13


você fosse encarregado de efetuar essa tarefa, seria bem provável que

utilizasse os passos a seguir:

a) saber quais são os números;

b) calcular a soma dos números;

c) responder à questão com o valor do resultado.

Entretanto, o computador é “burro”, apesar de ele saber somar, ele não

sabe o que é “saber” e nem “responder”. A seguir é apresentada uma

forma de como esse mesmo problema seria resolvido em termos das

operações básicas citadas anteriormente:

a) operação de entrada de dados dos números;

b1) movimento do valor dos números entre a memória e a ULA;

b2) operação aritmética de somar os 2 números;

b3) movimentação do resultado da ULA para guardar na memória;

c) operação de saída do resultado, que está guardado na memória,

para o dispositivo de saída desejado.

Deve-se salientar que os passos b1 e b3, normalmente, ficam embutidos

na operação matemática, não sendo explicitados.

Em resumo, pode-se dizer que escrever algoritmos ou, em última análise,

programar consiste em dividir qualquer problema em muitos pequenos

passos, usando uma ou mais das quatro operações básicas citadas.

Esses passos que compõem o algoritmo são denominados de comandos

(ou instruções). Os comandos de uma linguagem de programação podem

estar mais próximos da máquina (linguagens de baixo nível) ou serem

mais facilmente entendidos pelo homem (linguagens de alto nível). A

seqüência de operações básicas, dada anteriormente, para resolver o

problema de adicionar dois números, está em uma linguagem de baixo

14


nível para o nosso computador hipotético. Em uma linguagem de alto nível

teríamos um resultado assim:

l eia (X,Y);

SOMA X + Y;

e screva (SOMA);

2.2. Programação

É o ato de agrupar instruções em seqüências de forma que, quando

seguidas, produzem um resultado esperado, ou seja, é a seqüência de

planejamento, projeto, escrita e testes de instruções desempenhadas pelo

computador. É uma arte e uma ciência.

Arte porque existem muitas maneiras de se realizar o trabalho de

programação. Existe espaço para uma considerável dose de criatividade. É

também uma ciência, porque existem algumas regras que devem ser

seguidas, porque é necessário o uso de lógica e porque existem alguns

métodos rigorosos de programação que asseguram a eficiência, economia

e a utilidade dos programas gerados.

O trabalho de programação pode se tornar mais fácil se o dividirmos

sistematicamente em partes menos complexas (esta técnica denomina-se

“dividir para conquistar”).

Um programa é considerado confiável quando conseguir fazer com que o

computador cumpra com o objetivo proposto. Os programas construídos

devem ser eficazes quando realizam a tarefa definida, e eficientes

quando utiliza os melhores meios para realizá-la.

O maior problema na construção de programas é a complexidade; esta

complexidade representa a quantidade de situações diferentes que um

problema pode apresentar e que devem ser previstas na solução do

mesmo. Portanto, ao se construir um programa, o objetivo principal é

vencer a complexidade do problema a ser solucionado.

15


A fim de lidar com esta complexidade, pode-se dividir a programação em

duas fases distintas:

Problema

Solução na forma de algoritmo

Solução na forma de programa de computador

(1) Fase de resolução do problema

(2) Fase de implementação

Problema

Solução na forma de algoritmo

Solução na forma de programa de computador

(1) Fase de resolução do problema

(2) Fase de implementação

• Modelização (ou Resolução) do Problema: determinação do modelo de

solução para o problema proposto na forma de um “algoritmo

computacional”. Assim, a elaboração de um algoritmo é o primeiro

passo para a preparação de um programa de computador. Este

algoritmo deve ser independente da linguagem de programação que

será utilizada.

• Implementação : é a transformação (ou codificação) do algoritmo em

alguma Linguagem de Programação adequada ao modelo elaborado.

Programação estruturada: é uma forma de programação de computadores

que preconiza que todos os programas possíveis podem ser reduzidos a

apenas três estruturas: seqüência, decisão e iteração. A programação

estruturada orienta os programadores para a criação de estruturas

simples em seus programas, usando as sub-rotinas e funções. Foi a forma

dominante na criação de software entre a programação linear e a

programação orientada por objetos. Apesar de ter sido sucedida pela

programação orientada por objetos, pode-se dizer que a programação

estruturada ainda é marcantemente influente, uma vez que grande parte

das pessoas ainda aprendem programação através dela. Além disso, por

exigir formas de pensar relativamente complexas, a programação

orientada ao objeto até hoje ainda não é bem compreendida ou usada

pela maioria.

16


2.3. Programas

Os programas de computadores nada mais são do que algoritmos escritos

numa linguagem de computador (Pascal, C, Cobol, Fortran, Visual Basic,

etc...) e que são interpretados e executados por uma máquina, no caso

um computador.

2.4. Exercícios

1. Cite e explique com suas palavras as operações básicas executadas

pelos computadores.

2. Imagine que o computador queira multiplicar dois números e depois

dividir o resultado por 2 (tira a média). Descreva os passos para o

computador realizar essa tarefa (utilizando a entrada e manipulação

pela ULA, memória etc...).

3. Descreve com suas palavras o significado de um “comando”.

4. Qual a possível diferença entre um programa eficiente e eficaz? Um

mesmo programa pode ser eficiente e eficaz?

5. Defina com suas palavras o que é implementação.

6. Qual a principal característica da programação estruturada?

17


3. Algoritmos

3.1. Introdução

A palavra algoritmo, à primeira vista, parece estranha. Embora possua

designação desconhecida, está constantemente presente em nosso

cotidiano: a maneira como uma pessoa toma banho é um algoritmo.

Outros algoritmos freqüentemente encontrados são:

• instruções para se utilizar um aparelho eletrodoméstico;

• uma receita para preparo de algum prato;

• guia de preenchimento para declaração do imposto de renda;

• a regra para determinação de máximos e mínimos de funções por

derivadas sucessivas;

• a maneira como as contas de água, luz e telefone são calculadas

mensalmente; etc.

Existem diversos conceitos para algoritmo, sendo os principais descritos

abaixo:

• “Um conjunto finito de regras que provê uma seqüência de

operações para resolver um tipo de problema específico” [KNUTH]

• “Seqüência ordenada, e não ambígua, de passos que levam à

solução de um dado problema” [TREMBLAY]

• “Processo de cálculo, ou de resolução de um grupo de problemas

semelhantes, em que se estipulam, com generalidade e sem

restrições, as regras formais para a obtenção do resultado ou da

solução do problema” [AURÉLIO]

Formalmente, um algoritmo é uma seqüência finita de passos (instruções)

que levam a execução de uma tarefa. Pode-se pensar em algoritmo como

uma receita, uma seqüência de instruções que resultam em uma meta

específica. Estas tarefas não podem ser redundantes nem subjetivas na

sua definição, devem ser claras e precisas.

18


A importância do algoritmo está no fato de especificar uma seqüência de

passos lógicos para que o computador possa executar uma tarefa

qualquer, pois o mesmo por si só não tem vontade própria, faz apenas o

que é mandado. Com uma ferramenta algorítmica, pode-se conceber uma

solução para um dado problema, independendo de uma linguagem

específica e até mesmo do próprio computador. Duas frases resumem a

importância dos algoritmos:

• “A noção de algoritmo é básica para toda a programação de

computadores”. [KNUTH - Professor da Universidade de Stanford, autor da coleção “The art of

computer programming”]

• “O conceito central da programação e da ciência da computação é o

conceito de algoritmo”. [WIRTH - Professor da Universidade de Zurique, autor de diversos

livros na área e responsável pela criação de linguagens de programação como ALGOL, PASCAL e

MODULA-2]

Como exemplos de algoritmos, pode-se citar os algoritmos das operações

básicas (adição, multiplicação, divisão e subtração) de números reais.

Outros exemplos seriam os manuais de aparelhos eletrônicos, como um

telefone celular, que explicam passo-a-passo como, por exemplo,

armazenar um número de telefone de contato, uma receita de bolo, a

solução de uma equação do 2º grau, uma pesquisa na lista telefônica, etc.

3.2. Principais características dos algoritmos

Todo algoritmo deve apresentar algumas características básicas:

• ter fim;

• não dar margem à dupla interpretação (não ambíguo);

• capacidade de receber dado(s) de entrada do mundo exterior;

• poder gerar informações de saída para o mundo externo ao

ambiente do algoritmo;

• ser efetivo (todas as etapas especificadas no algoritmo devem ser

alcançáveis em um tempo finito).

19


Pode-se dizer então que o algoritmo é uma seqüência de instruções, e

cada instrução representa uma AÇÃO que deve ser entendida e realizada.

Surge então uma questão:

Como saber se já existe detalhes suficientes em um

algoritmo para que a AÇÃO possa ser entendida e

realizada?

Vai depender do agente que irá executar o algoritmo. No caso de

algoritmos computacionais, sabe-se que o computador possui um conjunto

limitado de instruções (ver Capítulo 2) e o algoritmo deve ser expresso

nos termos destas instruções.

Essas ações podem ser vistas como uma série finita e bem definida de

passos ou regras que, quando realizadas, atingem um objetivo

previamente definido.

Assim, outra definição para algoritmos poderia ser: Algoritmo é a

descrição de um conjunto de ações que, obedecidas, resultam numa

sucessão finita de passos, atingindo um objetivo esperado.

Dessa forma, nota-se que o que importa no algoritmo é o efeito das ações

para a obtenção do resultado esperado. Para isso, deve-se fazer uso de:

• ações simples e bem definidas (não ambíguas);

• seqüência ordenada de ações;

• seqüência finita de passos.

3.3. Regras para construção de algoritmos

Para escrever um algoritmo precisa-se descrever a seqüência de

instruções de maneira simples e objetiva. Para isso deve-se utilizar

algumas técnicas:

• Usar somente um verbo por frase

• Imaginar que você está desenvolvendo um algoritmo para pessoas

que não trabalham com informática

20


• Usar frases curtas e simples

• Ser objetivo

• Procurar usar palavras que não tenham sentido dúbio

Entretanto, ao montar um algoritmo, precisa-se primeiro dividir o

problema apresentado em três fases fundamentais:

Entrada Processamento SaídaEntrada Processamento Saída

Onde:

• Entrada : são os dados de entrada do algoritmo.

• Processamento : são os procedimentos utilizados para chegar ao

resultado final.

• Saída : São os dados já processados.

Exemplo: Imagine o seguinte problema: Calcular a média final dos alunos

de Lógica e Técnica de Programação. Os alunos realizarão quatro provas:

P1, P2, P3 e P4. Onde: Média Final = (P1 + P2 + P3 + P4)/4. Para montar o

algoritmo proposto, deve-se fazer três perguntas:

a) Quais são os dados de entrada?

R: P1, P2, P3 e P4

b) Qual será o processamento a ser utilizado?

R: Somar todos os dados de entrada e dividi-los por 4

c) Quais serão os dados de saída?

R: A média final

Algoritmo

• Receba a nota da prova1

• Receba a nota de prova2

• Receba a nota de prova3

• Receba a nota da prova4

• Some todas as notas e divida o resultado por 4

• Mostre o resultado da divisão

21


Por fim, pode-se enumerar as diretrizes para construção de um algoritmos

da seguinte maneira:

1. Identificação do problema: determinar o que se quer resolver ou

qual objetivo a ser atingido.

2. Identificação das “entradas de dados”: informações fornecidas, a

partir das quais se desenvolverão os cálculos.

3. Identificação das “saídas de dados”: as informações a serem

geradas como resultado.

4. Identificação das regras e limitações do problema ou das limitações

do agente executante (ex: se o agente fosse uma calculadora não-

científica, iriam existir limitações no cálculo de funções, por

exemplo).

5. Determinação do que deve ser feito para transformar as “entradas”

em “saídas”. Neste ponto deve ser determinada a seqüência de

ações que leve à solução do problema. Para isto é preciso:

a. observar as regras e limitações já identificadas.

b. determinar ações possíveis de serem realizadas pelo agente.

6. Construção do algoritmo, utilizando uma das formas de

representação de algoritmos (ver Seção 3.5).

7. Teste da solução - execução de todas as ações do algoritmo,

seguindo o fluxo estabelecido para verificar se ele está realmente

gerando os resultados esperados ou detectar possíveis erros em sua

descrição (ver Capítulo 6).

Deve-se destacar que essas diretrizes são “genéricas” e podem ser

usadas ou adaptadas na organização dos passos que irão compor a

solução de um determinado problema, ou seja, na criação de um

algoritmo para atingir um objetivo determinado.

22


3.4. Refinamentos sucessivos

Um algoritmo é considerado completo se os seus comandos forem do

entendimento do seu agente. Num algoritmo, um comando que não for do

entendimento do agente terá que ser desdobrado em novos comandos,

que constituirão um refinamento do comando inicial, e assim

sucessivamente, até que todos os comandos sejam entendidos pelo

agente.

Por exemplo, o algoritmo para calcular a média aritmética de dois

números pode ser escrito da seguinte forma:

• Receba os dois números

• Calcule a média dos dois números

• Exiba o resultado

Pode-se notar que, o comando “Calcule a média dos dois números” pode

ser desdobrado em:

• Some os dois números

• Divida o resultado por 2

Após esse refinamento, o algoritmo pode ser considerado completo, a

menos que o agente não saiba fazer as operações de adição e divisão, ou

não seja capaz de entender diretamente algum comando.

A partir de um algoritmo completo, pode-se reescrevê-lo inserindo o

refinamento na posição do comando que foi refinado. Assim sendo, obtém-

se:

• Receba os dois números

• Some os dois números

• Divida o resultado por 2

• Exiba o resultado

23


Reescrever um algoritmo completo com os refinamentos sucessivos

inseridos nos seus devidos lugares, permite ter uma visão global de como

o algoritmo deve ser executado.

Exemplo: Ensinar robô a fazer um bolo.

“Bata no liquidificador 2 cenouras, 4 ovos e 1 xícara de óleo. Já na

batedeira, adicione fermento e açúcar a gosto. Leve ao forno como um

bolo normal”.

1º Passo: Identificar ambigüidades, indefinições e efeitos não previsíveis.

Ex: Fermento e açúcar a gosto???? (Quanto é a gosto?). Como um bolo

normal???? (O que é um bolo normal?).

1º refinamento:

• bata no liquidificador 2 cenouras, 4 ovos e 1 xícara de óleo por 2

minutos.

• colocar na batedeira e acrescentar um tablete de fermento e 1

xícara de açúcar, bata por 3 minutos.

• leve ao forno por 1 hora.

2º Passo: Novamente identificar ambigüidades... Ex: Bata no liquidificador

2 cenouras, 4 ovos e 1 xícara de óleo???? (O que é bater no

liquidificador?).

2º refinamento:

• pegar o liquidificador

• inserir 2 cenouras

• inserir 4 ovos

• inserir 1 xícara de óleo

• ligar o liquidificador

• esperar por 2 minutos

• desligar o liquidificador

24


3º Passo: Mais uma vez identificar ambigüidades... Ex: Pegar o

liquidificador??? (Aonde? Como?).

3º refinamento:

• ir até o armário

• abrir a porta do armário

• estender as mãos até o liquidificador

• segurá-lo

• ir até a mesa

• posicionar o liquidificador sobre a mesa

• soltá-lo

• e assim por diante... até que todas as ações possam ser

compreendidas pelo robô.

À medida que o algoritmo passa a ser maior e mais complexo, esta visão

global torna-se menos clara e, neste caso, um algoritmo apresentado com

os refinamentos sucessivos separados oferece uma melhor abordagem

para quem precisar entendê-lo.

Exemplo: Imagine o algoritmo do Windows, todo escrito de forma

seqüencial, e com todos os refinamentos. O entendimento e a análise

desse algoritmo seriam praticamente impossíveis. Dessa forma, esse

algoritmo deve ser “modularizado”, ou seja, os refinamentos devem ser

apresentados de forma independente. A modularização será estudada

mais a diante.

3.5. Representação de algoritmos

A descrição de um algoritmo de forma clara e fácil de ser seguida ajuda no

seu desenvolvimento, depuração (correção de erros) e a subseqüente

transformação do mesmo num programa.

Descrição Narrativa: especificação verbal dos passos em linguagem

natural, ou seja, faz-se uso do português para descrever algoritmos.

25


Vantagens: O português é bastante conhecido por nós;

Desvantagens: a linguagem natural é prolixa (normalmente, escreve-se

muito para dizer pouca coisa) e imprecisa e freqüentemente pouco

confiável como um veículo de transferir informação. Sua utilização pode

ser adotada, entretanto, para a apresentação de comentários (ver Capítulo

4) sobre o algoritmo (ou parte dele), esclarecendo ou realçando pontos

específicos.

Exemplo: Calcular a média de um aluno.

• Receba a nota da prova 1




• Some todas as notas e divida o resultado por 4

• Mostre o resultado da divisão

• Se a média for maior ou igual a 7,0, mostre APROVADO, senão

REPROVADO

Diagrama de blocos (Fluxograma) : uso de ilustrações gráficas para

transmitir informações (Ex. gerais: mapas, diagramas explicativo para

montagem de aparelhos, etc.). Um diagrama de blocos apresenta de

forma gráfica a lógica de um algoritmo, enfatizando passos individuais e o

fluxo de execução. No diagrama de blocos existem símbolos padronizados

para início, entrada de dados, cálculos, saída de dados, fim, etc. O

diagrama de blocos é uma forma padronizada e eficaz para representar os

passos lógicos de um determinado processamento. Com o diagrama

podemos definir uma seqüência de símbolos, com significado bem

definido, portanto, sua principal função é a de facilitar a visualização dos

passos de um processamento. Esses símbolos são apresentados a seguir:

Indica o INÍCIO ou FIM de um processamento.

Exemplo: Início do algoritmo.

26


Terminal

Entrada

Saída

Processamento

Condição

Terminal

Entrada

Saída

Processamento

Condição

Indica entrada de dados. Exemplo: Digite a

nota da prova 1.

Processamento em geral. Exemplo: Calculo de

dois números.

Mostra informações ou resultados. Exemplo:

Mostre o resultado do calculo.

Verifica uma a validade de uma condição.

Exemplo: Se a média for inferior a 7,0 então o

aluno está reprovado, senão ele está aprovado.

Vantagens:

• Uma das ferramentas mais conhecidas;

• Figuras dizem muito mais que palavras;

• Padrão mundial

Desvantagens:

• Pouca atenção aos dados, não oferecendo recursos para descrevê-

los ou representá-los;

• Complica-se à medida que o algoritmo cresce.


27


Linguagem algorítmica ou Pseudolinguagem : linguagem especial

para expressão de algoritmos; funciona como uma “linguagem

simplificada de programação”, utilizando expressões concisas e pré-

definidas para representar as ações e o fluxo de execução. É uma

descrição textual, estruturada e regida por regras que descrevem os

passos executados no algoritmo. Utiliza-se palavras-chaves, indentação,

apenas um passo por linha, onde normalmente usa-se um símbolo para

indicar o final do passo (como por exemplo o ponto-e-virgula “;”), etc.

Nesse curso, será utilizada uma pseudolinguagem denominada Portugol,

pois ela possui uma estrutura similar à linguagem de programação Pascal,

que também será utilizada neste curso.

Obs: Indentação é um termo aplicado ao algoritmo para indicar que os

elementos hierarquicamente dispostos têm o mesmo “avanço”

relativamente à posição (y,0). Na maioria das linguagens a indentação

tem um papel meramente estético, tornando a leitura do código fonte

muito mais fácil (read-friendly), porém é obrigatória em outras. Python e

Haskell, por exemplo, utilizam-se desse recurso tornando desnecessário o

uso de certos identificadores de blocos ("início" e/ou "fim"). A verdadeira

valia deste processo é visível em arquivos de código fonte extensos, não

se fazendo sentir tanto a sua necessidade em arquivos pequenos

(relativamente ao número de linhas). Para qualquer programador, deve

28


ser um critério a ter em conta, principalmente, por aqueles que pretendam

partilhar o seu código com outros. A indentação facilita também a

modificação, seja para correção ou aprimoramento, do código fonte.

Existem centenas de estilos de indentação, mas, basicamente, ela se

consiste na adição de tabulações no início de cada linha na quantidade

equivalente ao número de blocos em que cada linha está contida.

Vantagens:

• Usa o português como base;

• Pode-se definir quais e como os dados vão estar estruturados;

• Passagem quase imediata do algoritmo para uma linguagem de

programação qualquer.

Desvantagens:

• Exige a definição de uma linguagem não real para trabalho;

• Não padronizado.


algoritmo CALCULA_MEDIA;var

P1, P2, P3, P4, MEDIA: real;in icio

l eia (P1);leia (P2);leia (P3);leia (P4);MEDIA (P1 + P2 + P3 + p4) / 4;e screva (MEDIA);se MEDIA ≥ 7,0 então escreva (‘APROVADO’);senão escreva (‘REPROVADO’);fim-se;

fim.

29


3.6. Exercícios

1. Defina algoritmo com suas palavras.

2. Cite 3 exemplos de algoritmos que você costuma utilizar no seu dia-a-

dia. Procure algoritmos diferentes dos já citados nessa apostila.

3. Cite as características básicas de um algoritmo.

4. Um algoritmo não pode conter um comando como “Escreva todos os

números inteiros positivos”. Por quê?

5. Cite três regras básicas para construção de um algoritmo.

6. Imagine que você terá que fazer um algoritmo para calcular o saldo de

uma pessoa no final do mês. Quais seriam as entradas, saídas e o

processamento necessário para esse algoritmo.

7. Escreve um algoritmo para resolver a questão anterior utilizando a sua

resposta (entradas, saídas e processamentos).

8. Faça o refinamento sucessivo (pelo menos 3 refinamentos) para o

algoritmo abaixo.

• Abrir minha caixa de e-mails;

• Escrever um novo e-mail;

• Enviar o novo e-mail;

• Fechar minha caixa de e-mails;

9. Defina com suas palavras o que é descrição narrativa e cite suas

vantagens e desvantagens.

10. Defina com suas palavras o que é um diagrama de blocos e cite suas

vantagens e desvantagens.

11. Faça um diagrama de blocos para cada algoritmo que você

apresentou na questão 2.

12. Descreva as vantagens e as desvantagens das pseudolinguagens.

30


13. Em sua opinião, qual a melhor forma de se representar algoritmos?

Justifique sua resposta.

14. Escreva cada algoritmo que você apresentou na questão 2 em

linguagem algorítmica.

31


4. Elementos fundamentais de programação

4.1. Tipos básicos de dados

Um tipo define um padrão de comportamento para constantes e variáveis.

Por exemplo, objetos do tipo fruta podem ser descascados, objetos do tipo

carro não.

• tipo carro = civic, punto, bmw, ferrari.

• tipo fruta = banana, mamão, laranja, maçã, goiaba.

A partir dos tipos, pode-se saber quais as ações possíveis de serem

realizadas sobre as constantes e variáveis. Ex: Não é possível multiplicar

duas palavras, porém é possível multiplicar dois números inteiros.

Os principais tipos pré-definidos em programação são:

Inte iro : toda e qualquer informação numérica que pertença ao conjunto

dos números inteiros (negativa, nula ou positiva). Ex: -32, 0 e 15. Nos

algoritmos esse tipo é descrito como inteiro.

Real: toda e qualquer informação numérica que pertença ao conjunto dos

números reais (negativa, nula ou positiva). Ex: -32.0, 0.1 e 15.978. Por

convenção, em programação utiliza-se o sistema internacional de

numeração, ou seja, as casas decimais são separadas por “.” e não por “,”

como no padrão brasileiro. Nos algoritmos esse tipo é descrito como real.

Lógico: toda é qualquer informação que possa assumir apenas dois

valores: verdadeiro ou falso. Ex: verdadeiro, falso. Nos algoritmos esse

tipo é descrito como booleano (devido à Álgebra Booleana, que foi criada

pelo matemático e filósofo George Boole, e é base da atual aritmética

computacional)

Literal: toda e qualquer informação composta de um conjunto de

caracteres alfanuméricos (numéricos, alfabéticos e especiais). Ex: 1, A, @.

32


Em programação, é comum utilizar dois tipos literais, o caractere e a

string.

• Caractere: apresenta apenas uma unidade literal. Por convenção,

deve-se representar esse tipo entre aspas simples. Ex: ‘a’, ‘1’, ‘@’.

Nos algoritmos esse tipo é descrito como char.

• String: apresenta uma ou mais unidades literais (no máximo 255).

Por convenção, deve-se representar esse tipo entre aspas simples.

Ex: ‘a’, ‘a1b343’, ‘[email protected]’, ‘João da Silva’. Nos algoritmos

esse tipo é descrito como string. Também pode ter tamanho pré-

definido, nesse caso, string[10], por exemplo, permite no máximo 10

caracteres, e não 255.

É possível acrescentar novos tipos de dados (como tipo fruta, tipo carro,

etc.) ao conjunto de tipos conhecidos de qualquer linguagem de

programação. Esse tema será tratado posteriormente.

4.2. Constantes

Constante é um determinado valor fixo que não se modifica ao longo do

tempo, durante a execução de um programa, ou seja, não variam no

decorrer do algoritmo. Conforme o seu tipo, a constante é classificada

como sendo numérica, lógica ou literal. A declaração de constantes deve

ser feita antes da declaração das variáveis. Ex: 148, “Opção:”, -8.69,

“Tecle algo para continuar”, falso... Sintaxe geral em Portugol:

const

constante1 = valor1;

constante2 = valor2;

etc...

O tipo pode ser inteiro, real, caractere (alfanumérico) ou booleano. Ex:

const

pi = 3.14;

status = falso;

33


nome = ‘matrix’;

4.3. Variáveis

Sabe-se da Matemática que uma variável é a representação simbólica dos

elementos de um certo conjunto. Nos programas destinados a resolver um

problema no computador, cada variável corresponde uma posição de

memória, cujo conteúdo pode variar ao longo do tempo durante a

execução de um programa. Embora a variável possa assumir diferentes

valores, ela só pode armazenar um valor a cada instante.

Toda variável é identificada por um nome ou identificador. Assim, por

exemplo, num programa para calcular a área de um triângulo retângulo

pelo teorema de Pitágoras (a2 = b2 + c2), os identificadores a, b e c podem

representar as posições de memória que armazenam o valor da

hipotenusa e dos catetos.

Uma variável é composta de dois elementos básicos:

• conteúdo - valor atual da variável

• identificador - nome dado à variável para possibilitar sua

manipulação.

Declaração de Variáveis: é a criação (ou definição) de locais na memória

rotulados com o identificador da variável (ou constante) que será utilizada

no algoritmo para a manipulação de um determinado tipo de informação.

Sintaxe geral em Portugol:

var

lista de variáveis: tipo1;

lista de variáveis: tipo2;

etc...

34


O tipo pode ser inteiro, real, caractere (alfanumérico) ou booleano. Ex:

var

pi: real;

num, x: inteiro;

status: booleano;

sexo: char;

endereco: string;

nome: string[20];

Neste momento (após a declaração), as variáveis ainda não contêm

nenhum valor associado a elas. A declaração de variáveis deve ser feita

antes da definição das ações do algoritmo.

4.4. Identificadores

São nomes escolhidos para representar constantes, variáveis, tipos,

funções, procedimentos, unidades, programas e campos de um registro.

Ou seja, nome de um local onde se pode colocar qualquer valor do

conjunto de valores possíveis de um tipo associado. Usado para manipular

todos os dados variáveis do algoritmo. Pode também ser usado para

rotular valores constantes (ex: uso do identificador pi para representar o

valor constante 3.14).

Regras para definição de identificadores em pseudolinguagem (Portugol):

• devem começar por um caractere alfabético (uma letra).

• pode ser seguido de letras e/ou dígitos.

• é permitido o uso do caractere especial “_” situado entre letras e/ou

dígitos. Ex. de identificadores válidos: Operador, Nome, X, y,

ENDERECO, Aluno_01.

• não é permitido o uso de acentos, ç, ?, etc...

35


• deve representar de forma significativa o conteúdo desejado, ou

seja, deve ser um MNEMÔNICO (que se refere a memória fácil de

lembrar).

• pode ter “qualquer” comprimento, mas deve-se evitar o uso de

identificadores longos;

• letras maiúsculas e minúsculas são indiferentes (no PASCAL, mas

em C, C++ e Java por exemplo, fazem diferença);

• não podem haver identificadores repetidos;

• não pode ser uma palavra reservada.

Palavras reservadas: são palavras que fazem parte da estrutura da

linguagem e têm significados pré-determinados. Elas não podem ser

redefinidas e não podem ser utilizadas como identificadores. Por notação,

as palavras reservadas devem ser sublinhadas. Ex: inicio, fim, var, const,

etc...

Exemplos de identificadores válidos

• Aluno

• X

• A34

• NotaDoAluno

Exemplos de identificadores não válidos

• 23

• Nota do Aluno

• 1treco

4.5. Comentários

Os comentários representam qualquer texto que explique uma ação ou

um dado usado no algoritmo. Eles podem ser colocados em qualquer

ponto do algoritmo, utilizando { } como delimitadores. Os comentários

36


não interferem na lógica de um algoritmo ou programa. O objetivo dos

comentários é proporcionar maior clareza ao programa, e devem ser

expressos da seguinte forma.

{ texto }

Deve-se escrever os comentários no momento que estiver escrevendo o

algoritmo. Um programa mal documentado é um dos piores erros que um

programador pode cometer. O melhor momento para se escrever os

comentários é aquele em que o programador tem maior intimidade com o

algoritmo, ou seja, durante a sua confecção. Existem 02 tipos de

comentários que devem ser usados.

Prólogo ou cabeçalho : são comentários que contém uma identificação

geral do algoritmo.

• O que faz o algoritmo (programa ou módulo);

• Como chamá-lo ou utilizá-lo;

• Significado dos parâmetros, variáveis de entrada, de saída e

variáveis mais importantes;

• Arquivos utilizados;

• Outros módulos utilizados;

• Métodos especiais utilizados, com referências nas quais possa se

encontrar mais informações;

• Autor, data de escrita e última atualização;

Exemplo: No início do algoritmo para calcular a média dos alunos, deve-se

colocar, por exemplo, o seguinte comentário:

{ PROGRAMA PARA CALCULAR A MEDIA DE ALUNOS

}

37


{ Autor: Fulano de tal.

}

{ Data de criação: 21/08/2007 Ultima atualização: 30/07/2007

}

Comentários de linha: são comentários de passos que podem ser mais

obscuros para o leitor, como o uso de variáveis como acumuladores,

contadores, flags, etc.

Exemplo:

var

NomeDoIndividuo: string; { armazena o nome do indivíduo }

EstadoCivil: booleano; { verdadeiro significa casado,

falso solteiro }

4.6. Expressões aritméticas

Expressões cujos operadores são aritméticos e cujos operandos são

constantes e/ou variáveis do tipo numérico (inteiro ou real). Por notação,

os operadores são descritos da seguinte forma:

Operador

Operação Operandos

Resultado

+ adição inteiro, real inteiro, real– Subtração inteiro, real inteiro, real* Multiplicação inteiro, real interior,

real/ Divisão real inteiro, real real

DIV Divisão inteira inteiro inteiroMOD Resto da

divisãointeiro inteiro

Exemplo:

Expressão

Resultado

1 + 2 35.0 – 1 4.02 * 1.5 3.05 / 2 2.5

5 DIV 2 25 MOD 2 1

38


4.7. Expressões lógicas

Expressões cujos operadores são lógicos e cujos operandos são relações,

constantes e/ou variáveis do tipo lógico (booleano). É comum nos

algoritmos surgirem situações em que a execução de uma ação, ou

seqüência de ações, está sujeita a uma certa condição. Esta condição é

representada no texto do algoritmo por meio de uma expressão lógica.

Relações: são comparações realizadas entre dois valores de mesmo tipo.

Estes valores são representados na relação através de constantes,

variáveis ou expressões aritméticas, estas últimas para o caso de valores

numéricos. Os operadores relacionais, que indicam a comparação a ser

realizada entre os termos da relação, são conhecidos da Matemática, ou

seja:

= igual <> diferente

> maior que < menor que

>= maior ou igual a <= menor ou igual a

Por convenção, os símbolos descritos acima são utilizados. É interessante

destacar que o resultado de uma relação é sempre um valor lógico

(booleano), ou seja, verdadeiro ou falso. Ex: A <> B; NOME = ‘João’; B – 4

* 3 <= 0; etc.

Operadores lógicos: Existem três operadores lógicos: e, ou e não. Esses

operadores são utilizados na formação de proposições lógicas a partir de

outras já conhecidas. De forma análoga a teoria de conjuntos encontrada

na Matemática, tem-se que:

• e: usado para conjunção; uma expressão “e” é verdadeira se todas

as condições forem verdadeiras.

• ou: usado para disjunção; uma expressão “ou” é verdadeira se pelo

menos uma condição for verdadeira.

39


• não: usado para negação; uma expressão “não” inverte o valor da

expressão ou condição, se verdadeira inverte para falsa e vice-

versa.

A tabela abaixo (Tabela Verdade) descreve as possíveis situações com uso

desses operadores com dois operandos A e B. Considere V como

verdadeiro e F falso.

A B A e B A ou B não A não BV V V V F FV F F V F VF V F V V FF F F F V V

Exemplos: Suponha a existência de três variáveis A = 5, B = 8 e C =1. A

partir dessa informação, pode-se afirmar que:

Expressão Resultado(A = B) e (B > C) falso

(A <> B) ou (B < C) verdadeironão (A > B) verdadeiro

(A < B) e (B > C) verdadeiro(A >= B) ou (B = C) falso

não (A <= B) falso

Obs.: Sempre utilize parêntesis para “organizar” as expressões, tanto as

lógicas e relacionais quanto as aritméticas.

4.8. Prioridade entre operadores

Pode-se ter mais de um operador na mesma expressão. Em alguns casos,

a ordem em que são efetuadas as operações pode afetar o resultado final

da expressão.

Assim como na Matemática possui uma ordem entre os operadores (/,*,

+,-), nas expressões lógicas isso também acontece. A prioridade dos

operadores aritméticos e lógicos é descrita a seguir.

Prioridade Operador1ª parêntesis2ª aritmético

40


3ª relacional4ª não5ª e6ª ou

Exemplo: A = 1 e (B + C <> 0 ou K <= 2); A seqüência de execução nesse

exemplo é: somar B + C, comparar o resultado com 0, depois verificar se

K <= 2 e se A = 1, e finalmente fazer as comparações “ou” e “e”. Note

que nesse caso o “ou” será executado antes devido ao uso de parêntesis.

Nesse caso, ficaria mais claro escrever a expressão da seguinte forma: (A

= 1) e (((B+C) <> 0) ou (K <= 2)).

4.9. Comandos de atribuição

Serve para atribuir (ou associar) um valor a uma variável ou constante.

Sintaxe geral em pseudolinguagem: identificador expressão; onde

expressão pode ser uma: constante, variável, expressão matemática,

função matemática, expressão booleana, etc. Ou seja, é possível atribuir

um valor qualquer a uma variável, sendo que o valor atribuído precisa ser

compatível com o tipo da variável. Ex: NOME ‘Fulano de Tal’; PI 3.14;

Erro verdadeiro; Media (P1 + P2)/2;

Exemplos: Considerando as variáveis declaradas:

v ar

X: inteiro;

Y, Z: real;

Disciplina: string;

Turma: char;

Status: booleano;

Tem-se:

Casos válidos Casos inválidosX 5;

X X + 1;

Y Z;

Z Y + 5 + X;

X Y;

Z + Y 5;

5 X;

41


Turma ‘B’;

Status verdadeiro;

Disciplina ‘Química

I’;

4.10. Comandos de entrada e saída

Representam as ações básicas de algoritmos para recebimento e

apresentação de dados, respectivamente.

Entrada de dados : informações que são fornecidas ao programa pelo

“usuário” durante a resolução do problema. Entrada de dados, ou ainda

leitura de dados, seria análogo a atribuir a uma variável um valor obtido

externamente. O exemplo mais natural para leitura de dados é pedir ao

usuário fornecer valores via teclado. Mas pode-se também ler dados de

arquivos, ou ainda de outros dispositivos de entrada. Obs.: Não é possível

ler variáveis do tipo booleano. Representação em Portugol: leia

(identificador1, identificador2, ...); Ex: leia (altura, idade, sexo);

Saída de dados : informações que são mostradas ao usuário como resposta

ao problema. A saída de dados significa mostrar tais dados em um

dispositivo de saída, como vídeo, impressora ou arquivo. A forma mais

simples de saída de dados ocorre quando se escreve valores de variáveis,

constantes ou expressões no vídeo. Representação em pseudolinguagem:

escreva (expressão1, expressão2, ...); Ex: escreva (‘Seu peso ideal e: ’,

peso_ideal); escreva (‘Media final = ’, (P1 + P2)/2);

4.11.Esquema genérico em pseudolinguagem

Um esquema genérico para escrever algoritmos em pseudolinguagem é

apresentado a seguir:

Declaração de constantes

Declaração de variáveis

in ício

inicialização de variáveis; {comentários}

bloco de comandos de entrada de dados; {comentários}

42


bloco de comandos de cálculo (processamento); {comentários}

bloco de comandos de saída de dados; {comentários}

fim.

Exemplo: Algoritmo em pseudolinguagem para o problema do cálculo da

média final.

algoritmo CALCULA_MEDIA;const

NUM_NOT = 4; { constante com o número de notas }

varP1, P2, P3, P4, MEDIA: real; { variáveis com as notas e a

média }início

leia (P1); { leitura da nota da prova 1 }



leia (P4); { leitura da nota da prova 4 } MEDIA (P1 + P2 + P3 + p4) / NUM_NOT; { cálculo da média }

escreva (MEDIA); { mostrar a média }fim.

É interessante destacar que a palavra reservada “fim” no final de um

algoritmo deve sempre ser seguida por ponto, e não ponto-e-vírgula.

43


4.12. Exercícios

1. Cite os tipos básicos de dados em programação e dê exemplos.

2. Escreva o tipo de dado ideal para se representar as seguintes

informações:

a) O número da conta bancária

b) A altura de uma pessoa em metros

c) A placa de um veículo

d) O número de filhos de uma pessoa

e) A população de um país

f) A cor de um objeto

3. Defina “constante” com suas palavras e dê exemplos.

4. Quais os valores possíveis em um dado do tipo booleano?

5. O que é uma string?

6. Qual o tamanho máximo de uma string?

7. Identifique os tipos dos seguintes dados:

a) 'Processamento de Dados'

b) 0.4

c) '4.5'

d) falso

e) '?'

f) ' '

g) -5.3

h) '.05'

i) 'verdadeiro'

j) 0

8. Defina “variáveis” com suas palavras e dê exemplos.

9. Defina “declaração de variáveis” com suas palavras e dê exemplos.

44


10. Utilizando tipos primitivos de dados, crie declarações de variáveis,

que armazenem as seguintes informações: o nome de uma figura

geométrica, a quantidade de lados, a área, o perímetro e se a figura é

regular ou não.

11. Quais são as regras para definição de identificadores?

12. Assinalar os identificadores inválidos, justificando.

a) A1BC b) XA,1d c) NomeDoAluno d) 198aberto e) início

13. O que são palavras reservadas?

14. Defina “comentários” com suas palavras e dê exemplos.

15. Diferencie os comandos de atribuição, entrada e saída. Dê

exemplos.

16. Faça 02 exemplos para cada um dos conceitos abaixo:

a) entrada de dados

b) saída de dados

c) declaração de variáveis

d) inicialização de variáveis

e) atribuição do resultado de uma expressão aritmética a uma

variável

17. Qual o resultado das expressões aritméticas abaixo, sabendo-se que os

valores de X, Y e Z são, respectivamente, 1, 2 e 5 ?

a) Z mod Y div Y

b) X + Y + Z / 3

c) (X / Z) + (Z / Y) * (Z / Y)

d) Z div Y + X * Y

e) Z - (X - Y)

45


18. Escreva uma expressão para se calcular o valor de 25.

19. Preencha a tabela abaixo:

A B não A ou B

A e não B

não (A e B)

(A ou B) e (não B)

V VV FF VF F

20. Escreva o resultado das seguintes comparações:

a) 1 <> 1.0

b) 'abc' > 'ABC'

c) ' ' = ' '

d) falso = falso

e) verdadeiro <> verdadeiro

f) 'JOSE' > 'JOSEFINA'

g) '50' < '100'

21. Qual o resultado das expressões lógicas abaixo, sabendo-se que os

valores de A e B são, respectivamente, verdadeiro e falso?

a) não A e B ou A e não B

b) não (não (A ou B) e (A ou B))

c) A ou B e não A ou não B

d) (A ou B) e (não A ou não B)

22. Sabendo que A=3, B=7 e C=4, informe se as expressões abaixo são

verdadeiras ou falsas.

a) (A+C) > B ( )

b) B >= (A + 2) ( )

c) C = (B –A) ( )

d) (B + A) <= C ( )

e) (C+A) > B ( )

46


23. Sabendo que A=5, B=4 e C=3 e D=6, informe se as expressões abaixo

são verdadeiras ou falsas.

a) (A > C) AND (C <= D) ( )

b) (A+B) > 10 OR (A+B) = (C+D) ( )

c) (A>=C) AND (D >= C) ( )

24. Escreva um programa para ler o nome e o sobrenome de uma pessoa e

escrevê-los na seguinte forma: sobrenome seguido por uma vírgula e

pelo nome. Exemplo: entrada: ‘Antonio’, ‘Soares’; saída: Soares,

Antonio.

25. Escreva um algoritmo para ler uma temperatura dada na escala

Fahrenheit e exibir o equivalente em Celsius.

)32(9

5 −= FC

26. A ordem das atribuições é importante? A B e C A tem o mesmo

efeito de C A e A B? Justifique.

27. Em quais dos seguintes pares é importante a ordem dos comandos?

Justifique.

a) X Y b) X Y c) X Z d) Z Y

Y X Z X X Y X

Y

47


48


5. Estruturas de controle

Controlam a ordem e a seqüência de execução de um algoritmo. Como

apresentado no capítulo anterior em “Expressões Lógicas”, pode-se notar

que na maioria das vezes é necessária uma tomada de decisões no

andamento do algoritmo. Essas decisões interferem diretamente no

andamento do programa. Para isso, são utilizadas três estruturas:

Seqüencial, Condicional e de Repetição.

5.1. Seqüencial

Os comandos de um programa são executados na seqüência em que

aparecem, ou seja, os comandos são executados numa seqüência linear,

de cima para baixo, na mesma ordem em que aparecem. Sintaxe geral:

comando 1;

comando 2;

comando 3;

....

Exemplo:

leia (P1);

leia (P2);

leia (P3);

leia (P4);

Note que esses comandos serão executados na seqüência em que estão

escritos.

5.2. Condicional

Permite a escolha de um grupo de ações para serem executadas de

acordo com a aceitação ou não de certas condições. São testados

“parâmetros” e, a depender de seus valores, toma-se um caminho ou

outro. As condições que são testadas num algoritmo são do tipo booleano

(expressões lógicas), portanto podem ter somente dois resultados:

verdadeiro ou falso. Assim, a seleção de ações pode seguir, no máximo,

duas alternativas: uma se a condição for verdadeira e outra se a condição

testada for falsa. Existem seleções mais simples, seleções compostas de

outras seleções e seleções múltiplas.

49


Seleções simples :

Opção 1:

s e condição então

bloco de comandos 1;

f im-se ;

Exemplo:

se MEDIA < 7.0 então

escreva (‘reprovado’);

fim-se;

Opção 2:

s e condição então


senão


f im-se ;

Exemplo:



senão

escreva (‘aprovado’);

fim-se;

Seleções Compostas: Aninhamento de condições. Deve-se tomar cuidado

na utilização de se's aninhados, pois a cláusula senão é sempre

relacionada ao último se. Se dentro de algum programa precisarmos

contornar este fato, podemos fazê-lo com o delimitador fim-se.

se condição1 então


senão

s e condição2 então


f im-se ;

f im-se ;

Exemplo:

se MEDIA >= 7.0 então


senão

se MEDIA > 5.0 então

escreva (‘prova final’);

fim-se;

fim-se;

50






fim-se;

senão


fim-se;

Exemplo:


escreva (‘prova final’);

se NOTA_PF >= 5.0

então


senão


fim-se;

senão


fim-se;

Seleções múltiplas: Utilizada quando se deseja executar um entre vários

comandos (ou uma entre várias seqüências de comandos) dependendo do

resultado de uma expressão. A estrutura de seleção múltipla é descrita

como caso, e obedece a seguinte sintaxe:

caso expressão1 seja:

valor1, valor2,... : bloco de

comandos 1;

valor3, valor4,... : bloco de

comandos 2;

...

senão

bloco de comandos n;

fim-caso;

Exem plo :

caso MEDIA seja:

7.0, 8.0: escreva

(‘aprovado’);

5.0, 6.0: escreva (‘prova

final’);

senão


fim-caso;

5.3. Repetição

Pode-se ter repetições condicionais (a repetição ocorre condicionada a

uma condição lógica) e incondicionais (que tem um número pré-definido

de repetições).

51


a) Repetição condicional: existem dois tipos distintos de repetição

condicional.

Tipo 1: Condição testada no início da repetição. Sintaxe:

e nquanto condição faça

bloco de comandos;

f im-enquanto ;

Exemplo:

enquanto SOMA < 1000 faça

SOMA SOMA + 10;

fim-enquanto;

Exemplo prático:

algoritmo EXEMPLO_PRATICO; {escrever os números inteiros de 1 a

100}

var

N: inteiro;

início

N 1;

enquanto N <= 100 faça

escreva (N);

N N + 1;

fim-enquanto;

fim.

Características:

• Testa a condição antes da execução do bloco.

• Enquanto a condição for verdadeira, o bloco de comandos é

executado. Assim, o bloco de comandos pode ser executado 0 ou

mais vezes.

• Pára a execução do bloco quando a condição se tornar falsa.

Tipo 2: Condição testada no final da repetição. Sintaxe:

52


r epita

bloco de comandos;

até condição;

Exemplo:

repita

SOMA SOMA + 10;

até SOMA = 1000;

Exemplo prático:


100}

var

N: inteiro;

início

N 1;

repita

escreva (N);

N N + 1;

até N > 100;

fim.

Características:

• Testa a condição após da execução do bloco.

• Enquanto a condição for verdadeira, o bloco de comandos é

executado. Assim, o bloco de comandos é executado pelo menos

uma vez.

• Pára a execução do bloco quando a condição se tornar verdadeira

(denominada de Condição de Parada).

b) Repetição incondicional: Número pré-definido de repetições.

Sintaxe:

p ara variável_de_controle valor_inicial até valor_final faça

bloco de comandos;

f im-para ;

53


Exemplo:

para i 0 até 1000 faça

SOMA SOMA + i;

fim -para ;

Exemplo prático:


100}

var

N: inteiro;

início

para N 1 até 100 faça

escreva (N);

fim-para;

fim.

Características:

• Repete o bloco de comandos (valor_final – valor_inicial + 1) vezes.

• Incrementa (atualiza) automaticamente a variável de controle cada

vez que o bloco é executado (incremento “default” de 1 até alcançar

o valor final).

• Se o valor final definido for menor que o valor inicial, o laço (loop)

de repetição não é executado nenhuma vez.

• A variável de controle deve ser do tipo inteiro.

• A variável usada como controle da estrutura não pode ser

modificada dentro do bloco.

5.4. Loop infinito

Ao se usar estruturas de repetições deve-se tomar muito cuidado para

garantir que as repetições tenham fim, ou seja, a condição de parada seja

alcançada. Caso contrário, o algoritmo ficará preso dentro da repetição, e

54


nunca irá sair, causando um travamento do computador. Esse problema é

muito comum, e é conhecido como loop infinito.

5.5. Variáveis especiais

As variáveis representam a informação manipulada pelo algoritmo, e

portanto, pode aparecer em diversas situações. Além das já apresentadas,

existem três casos especiais:

Variáveis acumuladoras: acumula valores. Ex:

ACUMULA 1;

enquanto ACUMULA < 100 faça

leia (NUM);

ACUMULA ACUMULA + NUM;

fim-enquanto;

Variáveis contadoras: conta valores. Ex:

CONTA 0;

repita

CONTA CONTA + 1;

escreva (‘Repeti o laço ’, CONTA, ‘ vezes ‘);

até CONTA > 20;

Variáveis sinalizadoras ou flags : sinaliza erros, condições de falha de teste,

etc. São variáveis que informam que uma determinada situação foi

alcançada. Normalmente, são usadas variáveis do tipo booleano como

sinalizadores. Ex:

l eia (dia, mes, ano);

INVALIDA falso;

s e (dia<1 ou dia>31) então

{ Muda o valor do flag para sinalizar um erro ou mudança de

estado }

INVALIDA verdadeiro;

senão

55


se (mes<1 ou mes>12) então

INVALIDA verdadeiro;

f im-se ;

f im-se ;

s e INVALIDA então

escreva (‘Erro na data - dia invalido ou mes invalido’);

fim -se ;

Note que a condição no último “se” não usa operadores lógicos do tipo

INVALIDA = verdadeiro, pois como a variável INVALIDA já é booleana, ou

seja, só pode apresentar os valores verdadeiro ou falso, ela já apresenta

um resultado lógico.

Em geral, flags são utilizadas quando não conhecemos o número de

repetições e este for determinado por um valor que será lido. Assim, deve-

se utilizar um controle de repetições por entrada, também conhecido

como controle por sentinela. Para controle por flag, a melhor estratégia é

utilizar um “loop infinito” com a condição de parada sendo aplicada

através do comando pare, dentro de um comando se logo após a leitura

da variável a ser comparada com o flag.

Obs: o comando pare funciona com uma “saída forçada” de qualquer

comando de repetição. Porém, só é recomendado o seu uso dentro de um

“loop infinito”, senão pode quebrar a forma estruturada que é própria dos

comandos de repetição.

Exemplo: Este algoritmo lê um conjunto de números inteiros e exibe o

valor médio dos mesmos. Obs: a condição de saída do laço será a leitura

do valor 0 (flag).

algoritmo LACO_COM_FLAG;

var

NUM,CONT,SOMA,MEDIA: inteiro;

início

SOMA 0;

56


CONT 0;

enquanto verdadeiro faça { loop infinito }

escreva ('Digite um número inteiro (0 para encerrar): ');

leia (NUM);

se NUM = 0 então

pare;

fim-se;

SOMA SOMA + NUM;

CONT CONT + 1;

f im-enquanto ;

MEDIA SOMA div CONT;

escreva ('Média = ',MEDIA);

fim.

5.6. Exercícios

1. João Sardinha, homem de bem, comprou um microcomputador para

controlar o rendimento diário de seu trabalho. Toda vez que ele traz um

peso de peixes maior que o estabelecido pelo regulamento de pesca do

estado de Espírito Santo (50 quilos) deve pagar uma multa de R$ 4,00

por quilo excedente. João precisa que você faça um algoritmo que leia

o peso de peixes pescados e verifique se há excesso. Se houver, gravar

em outra variável a palavra ‘excesso’ e em outra variável o valor da

multa que João deverá pagar. Mostrar o valor dessas variáveis. Caso

contrário mostrar tais variáveis com o conteúdo igual à ZERO.

2. Elabore um algoritmo que leia o CPF e o número de horas trabalhadas

de um operário. Calcule o salário sabendo-se que ele ganha R$ 10,00

por hora. Quando o número de horas exceder a 50, calcule o excesso

de pagamento armazenando-o em outra variável, caso contrário zerar

tal variável. A hora excedente de trabalho vale R$ 20,00. No final do

processamento mostre o salário total e o salário excedente do

trabalhador.

3. Faça um algoritmo que mostre todos os números inteiros.

57


4. Desenvolva um diagrama que:

a. Leia 4 números;

b. Calcule o quadrado de cada um;

c. Se o valor resultante do quadrado do terceiro for >= 1000,

mostre-o e finalize;

d. Caso contrário, mostre os valores lidos e seus respectivos

quadrados.

5. Faça um algoritmo que leia um número inteiro e mostre uma

mensagem indicando se este número é par ou ímpar, e se é positivo ou

negativo.

6. A Secretaria de Meio Ambiente que controla o índice de poluição

mantém 3 grupos de indústrias que são altamente poluentes do meio

ambiente. O índice de poluição aceitável varia de 0.05 até 0.25. Se o

índice sobe para 0.3 as indústrias do 1º grupo são intimadas a

suspenderem suas atividades, se o índice crescer para 0.4 as industrias

do 1º e 2º grupo são intimadas a suspenderem suas atividades, se o

índice atingir 0,5 todos os grupos devem ser notificados a paralisarem

suas atividades. Faça um algoritmo que leia o índice de poluição

medido e emita a notificação adequada aos diferentes grupos de

empresas.

7. Qual a utilidade da estrutura de decisão?

8. Qual a diferença entre a estrutura de decisão simples e a composta?

9. Os comandos (i) e (ii) são equivalentes? Explique sua resposta.

(i) A B = C; (ii) se B = C então

A verdadeiro;

senão

A falso;

58


f im-se ;

10. Elabore um algoritmo em pseudolinguagem (utilizando os conceitos

vistos nesse capítulo) que leia um número, e se esse for positivo

armazene-o em A, se for negativo, em B. No final mostre o resultado.


vistos nesse capítulo) para ler um número e verificar se ele é par ou

ímpar. Quando for par armazenar esse valor em P e quando for ímpar

armazená-lo em I. Exibir P e I no final do processamento.


vistos nesse capítulo) para ler uma variável numérica N e mostrá-la

somente se a mesma for maior que 100, caso contrário mostrá-la com

o valor zero.

13. Tendo como dados de entrada a altura e o sexo de uma pessoa,

construa um algoritmo que calcule seu peso ideal, utilizando as

seguintes fórmulas:

a. Para homens: (72.7*ALTURA) - 58

b. Para mulheres: (62.1*ALTURA) - 44.7

14. Faça um algoritmo chamado Calculadora, onde o usuário fornece dois

valores e o operador (um dentre +, -, * e /), e o programa faz a conta.

15. Elabore dois algoritmos, um utilizando seleções compostas e outro

utilizando seleções múltiplas) que dada a idade de um nadador

classifique-o em uma das seguintes categorias:

a. Infantil A = 5 a 7 anos

b. Infantil B = 8 a 11 anos

c. Juvenil A = 12 a 13 anos

d. Juvenil B = 14 a 17 anos

59


e. Adultos = Maiores de 18 anos

16. Elabore um algoritmo que gera e escreve os números ímpares entre

100 e 200.

17. Escreva um programa que determine o grau de obesidade de uma

pessoa, sendo fornecido o peso e a altura da pessoa. O grau de

obesidade é determinado pelo índice da massa corpórea - IMC (Massa

= Peso/Altura2) através dos seguintes índices:

a. Abaixo de 19.9: Você está abaixo do peso ideal.

b. Entre 20.0 e 24.9: Parabéns! você está em seu peso normal!

c. Entre 25.0 e 29.9: Você está acima de seu peso (sobrepeso).

d. Entre 30.0 e 34.9: Obesidade moderada (grau I).

e. Entre 35.0 e 39.9: Obesidade severa (grau II).

f. 40.0 e acima: Obesidade mórbida (grau III).

18. Qual a utilidade da estrutura de repetição?

19. Em que consiste o controle de repetições por contador?

20. Em que consiste o controle de repetições por flag?

21. Qual a principal diferença entre o enquanto ... faça e o repita ... até?

22. Em que situações é mais indicado o uso da estrutura para?

23. Em que situações não podemos utilizar a estrutura para?

24. Construa um algoritmo que leia 500 valores inteiros e positivos e:

a. Encontre o maior valor

b. Encontre o menor valor

c. Calcule a média dos números lidos

25. Faça um algoritmo que determine o maior entre N números lidos. A

condição de parada é a entrada de um valor 0, ou seja, o algoritmo

deve ficar calculando o maior até que a entrada seja igual a 0 (ZERO).

60


26. Uma rainha requisitou os serviços de um monge e disse-lhe que

pagaria qualquer preço. O monge, necessitando de alimentos, indagou

à rainha sobre o pagamento, se poderia ser feito com grãos de trigo

dispostos em um tabuleiro de xadrez (tem 64 quadros), de tal forma

que o primeiro quadro deveria conter apenas um grão e os quadros

subseqüentes, o dobro do quadro anterior. A rainha achou o trabalho

barato e pediu que o serviço fosse executado, sem se dar conta de que

seria impossível efetuar o pagamento. Faça um algoritmo para calcular

o número de grãos que o monge esperava receber.

27. Faça um algoritmo que conte de 1 a 100 e a cada múltiplo de 10 emita

a mensagem ‘Múltiplo de 10’.

28. Faça três algoritmos que leiam um valor N (inteiro), e calcule o fatorial

de N. Um com repetição incondicional (para), e dois com condicional,

do tipo 1 (enquanto ... faça) e 2 (repita ... até).

29. Dado o trecho de programa abaixo:

...

leia (N)

R 1;

I 2;

enquanto I <= N-1 faça

R R * 2;

I I + 1;

f im-enquanto ;

escreva (R);

...

Reescreva-o utilizando:

a) o comando para .

b) o comando repita ... até.

30. Escreva um programa que leia o número de andares de um prédio e, a

seguir, para cada andar do prédio, leia o número de pessoas que

61


entraram e saíram do elevador. Considere que o elevador está vazio e

está subindo, os dados se referem a apenas uma subida do elevador e

que o número de pessoas dentro do elevador será sempre maior ou

igual a zero. Se o número de pessoas, após a entrada e saída, for maior

que 15, deve ser mostrada a mensagem “Excesso de passageiros.

Devem sair X”, sendo X o número de pessoas que devem sair do

elevador, de modo que seja obedecido o limite de 15 passageiros. Após

a entrada e saída no último andar, o programa deve mostrar quantas

pessoas permaneceram no elevador para descer.

31. O Botafogo deseja aumentar o salário de seus 22 jogadores. O reajuste

deve seguir as seguintes regras:

SALÁRIO ATUAL (R$) AUMENTO

0,00 a 1.000,00 20%

1.000,01 a 5.000,00 10%

acima de 5.000,00 0%

Escreva um algoritmo que:

• leia o nome e o salário atual de cada jogador;

• exiba o nome, o salário atual e o salário reajustado de cada

jogador;

• exiba o total da folha de salários do clube, antes do reajuste.

• exiba o total da folha de salários do clube, após o reajuste.

• exiba o percentual de reajuste sobre o total da folha de salários.

62


6. Técnicas de verificação de algoritmos

Um tipo de teste de algoritmo, denominado Teste de Mesa (ou Teste

Exaustivo) pode ser feito através de uma simulação do mesmo, aonde são

dados valores para os dados de entrada e vai-se preenchendo uma tabela

aonde são colocadas todas as variáveis e constantes do algoritmo.

Segue-se o fluxo de execução como se estivesse executando o algoritmo

em um computador imaginário. A cada comando de atribuição ou cálculo

de expressão o valor das variáveis deve ser atualizado. Ao final do teste

pode-se ter as seguintes situações:

• o resultado esperado foi alcançado; ou

• foram detectados erros nos comandos; ou

• foram detectados erros no fluxo de execução - erro nas estruturas

de controle.

Procure fazer testes relevantes como, por exemplo, aqueles que verificam

casos extremos e casos de exceções. Com o teste é possível identificar em

que ponto o algoritmo está falhando e fazer a correção. Algoritmos

errados podem gerar resultados errados ao serem executados por um

computador ou mesmo não gerar nada, se o computador detectar erros

graves na seqüência de operações.

Exemplo: Imagine o algoritmo abaixo para calcular a média de um aluno.

algoritmo CALCULA_MEDIA;const

NUM_NOT = 4;var

P1, P2, P3, P4, MEDIA: real;início

leia (P1);leia (P2);leia (P3);leia (P4);MÉDIA (P1 + P2 + P3 + p4) / NUM_NOT;

63


escreva (MEDIA);se MEDIA ≥ 7,0 então escreva (APROVADO);senão escreva (REPROVADO);fim-se;

fim.

O teste de mesa desse algoritmo é dado da seguinte maneira:

Passo

NUM_ALU

MEDIA P1 P2 P3 P4

0 4 - - - - -1 4 - 9.6 - - -2 4 - 9.6 5.7 - -3 4 - 9.6 5.7 6.8 -4 4 - 9.6 5.7 6.8 8.95 4 7.75 9.6 5.7 6.8 8.9

Inicialmente, os valores das variáveis são indefinidos, ou seja, não

podemos afirmar quais os valores armazenados dentro dessas variáveis.

Por convenção, diz-se que os valores dessas variáveis são “lixos”.

Na tabela verdade acima, nota-se que inicialmente, no passo 0, o valor da

constante já é definido, porém os valores das variáveis são lixos. No passo

1 do algoritmo, a variável P1 é lida e as demais continuam com lixo. E

assim sucessivamente.

No final da execução do algoritmo, podemos ver claramente os valores

armazenados em cada variável, e o valor da constante, que devido a sua

definição, não é alterado em momento algum.

64


6.1. Exercícios

1. Dado o algoritmo abaixo, faça o teste de mesa para n = 0, 1 e 3.

algoritmo fatorial;

var

n, fat, cont: inteiro; { acum é a variável de controle }

início

leia (n)

fat 1; { inicialização de fat }

para cont 2 até n faça

fat fat * cont;

fim-para;

escreva (‘o fatorial de ’, n , ‘ é ‘, fat)

fim.

2. Teste o algoritmo abaixo. Faça um Teste de Mesa, usando a tabela ao

lado do algoritmo. Lembre-se de testar os “casos críticos” (casos

extremos e casos de exceções)!

var

X, Y, N: inteiro;

início

leia (N,X)

Y 1;

enquanto X > 0 faça

Y Y * N;

X X – 1;

fim-enquanto;

escreva (Y);

fim.

X Y N X > 0

3. Elabore um algoritmo que verifique se um número positivo lido é primo

ou não. Faça um teste de mesa do algoritmo.

65


4. O que está incorreto no trecho de algoritmo abaixo?

se A > B

Maior1 A;

Maior2 B

senão

Maior1 B;

Maior2 A;

fim -se .

5. Qual o valor final das variáveis A, B e C mostradas nos algoritmos

abaixo:

var

A: inteiro;

início

A 1;

enquanto A < 100

faça

A A;

fim-enquanto;

escreva (A);

fim.

var

B: inteiro;

início

B 1;

enquanto B > 100

faça

B B;

fim-enquanto;

escreva (B);

fim.

var

C: inteiro;

início

C 1;

repita

C C;

até C < 100;

escreva (C);

fim.

6. Observe o trecho de algoritmo abaixo, considerando L1, L2 e L3 como

variáveis booleanas.

...

se L1 então

escreva ('A');

senão

se L2 então

se L3 então

escreva ('B');

66


senão

escreva ('C');

escreva ('D');

fim-se;

senão

escreva ('E');

fim-se;

fim-se;

...

Agora, responda as seguintes questões:

a) Se forem lidos V, V e V, o que será escrito pelo algoritmo?

b) Se forem lidos F, V e V, o que será escrito pelo algoritmo?

c) Se forem lidos F, V e F, o que será escrito pelo algoritmo?

d) Que valores deveriam ser lidos para que fosse escrito apenas "E"?

7. Faça o acompanhamento da execução do trecho de algoritmo abaixo e

preencha a tabela. Saída é o resultado mostrado pelo algoritmo.

...

N 0;

L 1;

enquanto N <> 6 faça

L L * (-1);

N N + 1;

se L > 0 então

escreva (N);

fim-se;

fim-enquanto;

...

N L Saída

8. Faça o teste de mesa para o algoritmo apresentado e para os

algoritmos resposta da questão 29 do capítulo anterior.

67


9. Faça o teste de mesa para o algoritmo resposta da questão 30 do

capítulo anterior. Considere o número de andares igual a 3, e o número

de pessoas que entraram igual a 5, 6 e 7 para o 1º, 2º e 3º andares

respectivamente, e que saíram igual a 3, 2 e 4.

68


Referências

[1] COLLINS, W. J. Programação estruturada com estudos de casos

em Pascal. McGraw-Hill. (1988) São Paulo. 1988. 712p.

[2] FARRER, H. et al. Algoritmos estruturados. Livros Técnicos e

Científicos. 3a ed. Rio de Janeiro. 1999.

[3] FARRER, H. et al. Pascal estruturado. Livros Técnicos e Científicos. 3a

ed. Rio de Janeiro. 1999. 278p.

[4] FORBELLONE, A. L. V.; EBERSPACHER, H. F. Lógica de programação:

a construção de algoritmos e estruturas de dados. Pearson

Education do Brasil. 2a ed. São Paulo. 2000.

[5] GUIMARÃES, A. M.; LAGES, N. A. C. Algoritmos e Estruturas de

Dados. Rio de Janeiro, LTC, 1994.

[6] MANZANO, J. A. N. G. Algoritmos: lógica para desenvolvimento de

programação. Erica. 10a ed. São Paulo. 2000.

69

ENG06842 - Prof. Jacson...

Documents

Transcript of ENG06842 - Prof. Jacson...