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
ENG06842 – Programação I
Contato: [email protected] ou [email protected]
Este material está disponível para download no site:
http://www.grmauri.pro.br.
3
ENG06842 – Programação I
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
ENG06842 – Programação I
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
ENG06842 – Programação I
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
ENG06842 – Programação I
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
ENG06842 – Programação I
(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
ENG06842 – Programação I
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
ENG06842 – Programação I
10
ENG06842 – Programação I
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
ENG06842 – Programação I
(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
ENG06842 – Programação I
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
ENG06842 – Programação I
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
ENG06842 – Programação I
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
ENG06842 – Programação I
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
ENG06842 – Programação I
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
ENG06842 – Programação I
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
ENG06842 – Programação I
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
ENG06842 – Programação I
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
ENG06842 – Programação I
• 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
ENG06842 – Programação I
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
ENG06842 – Programação I
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
ENG06842 – Programação I
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
ENG06842 – Programação I
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
ENG06842 – Programação I
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
• Receba a nota da prova 2
• Receba a nota da prova 3
• Receba a nota da prova 4
• 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
ENG06842 – Programação I
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.
Exemplo: Calcular a média de um aluno.
27
ENG06842 – Programação I
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
ENG06842 – Programação I
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.
Exemplo: Calcular a média de um aluno.
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
ENG06842 – Programação I
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
ENG06842 – Programação I
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
ENG06842 – Programação I
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
ENG06842 – Programação I
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
ENG06842 – Programação I
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
ENG06842 – Programação I
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
ENG06842 – Programação I
• 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
ENG06842 – Programação I
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
ENG06842 – Programação I
{ 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
ENG06842 – Programação I
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
ENG06842 – Programação I
• 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
ENG06842 – Programação I
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
ENG06842 – Programação I
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
ENG06842 – Programação I
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 (P2); { leitura da nota da prova 2 }
leia (P3); { leitura da nota da prova 3 }
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
ENG06842 – Programação I
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
ENG06842 – Programação I
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
ENG06842 – Programação I
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
ENG06842 – Programação I
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
ENG06842 – Programação I
48
ENG06842 – Programação I
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
ENG06842 – Programação I
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
bloco de comandos 1;
senão
bloco de comandos 2;
f im-se ;
Exemplo:
se MEDIA < 7.0 então
escreva (‘reprovado’);
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
bloco de comandos 1;
senão
s e condição2 então
bloco de comandos 2;
f im-se ;
f im-se ;
Exemplo:
se MEDIA >= 7.0 então
escreva (‘aprovado’);
senão
se MEDIA > 5.0 então
escreva (‘prova final’);
fim-se;
fim-se;
50
ENG06842 – Programação I
se condição1 então
bloco de comandos 1;
se condição2 então
bloco de comandos 2;
fim-se;
senão
bloco de comandos 3;
fim-se;
Exemplo:
se MEDIA < 7.0 então
escreva (‘prova final’);
se NOTA_PF >= 5.0
então
escreva (‘aprovado’);
senão
escreva (‘reprovado’);
fim-se;
senão
escreva (‘aprovado’);
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
escreva (‘reprovado’);
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
ENG06842 – Programação I
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
ENG06842 – Programação I
r epita
bloco de comandos;
até condição;
Exemplo:
repita
SOMA SOMA + 10;
até SOMA = 1000;
Exemplo prático:
algoritmo EXEMPLO_PRATICO; {escrever os números inteiros de 1 a
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
ENG06842 – Programação I
Exemplo:
para i 0 até 1000 faça
SOMA SOMA + i;
fim -para ;
Exemplo prático:
algoritmo EXEMPLO_PRATICO; {escrever os números inteiros de 1 a
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
ENG06842 – Programação I
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
ENG06842 – Programação I
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
ENG06842 – Programação I
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
ENG06842 – Programação I
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
ENG06842 – Programação I
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.
11. Elabore um algoritmo em pseudolinguagem (utilizando os conceitos
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.
12. Elabore um algoritmo em pseudolinguagem (utilizando os conceitos
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
ENG06842 – Programação I
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
ENG06842 – Programação I
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
ENG06842 – Programação I
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
ENG06842 – Programação I
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
ENG06842 – Programação I
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
ENG06842 – Programação I
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
ENG06842 – Programação I
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
ENG06842 – Programação I
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
ENG06842 – Programação I
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
ENG06842 – Programação I
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