LÓGICA DE PROGRAMAÇÃO - UFBA

Prévia do material em texto

Curso de Lógica de Programação Prof. João Dias de Queiroz 7
CURSO DE
LÓGICA DE PROGRAMAÇÃO
Prof. João Dias de Queiroz
E-mail: jdias@ufba.br 
Home Page: www.ufba.br/~jdias
												
 SUMÁRIO
1. Introdução .......................................................................................................... 	03
1.1. Características de Funcionamento de um Computador ......................................	03
1.2. O Conceito de Algorítmo - Estruturas Básicas de Controle ...............................	05
1.3. Programação Estruturada.................................................................................. 	11
2. Portugol .............................................................................................................. 	13
2.1. Identificador ..................................................................................................... 	13
2.2. Declaração de Variáveis ................................................................................... 	13
2.3. Constantes ....................................................................................................... 	15
2.4. Comandos Básicos........................................................................................... 	15
2.4.1. Comando de Atribuição ................................................................................ 	15
2.4.2. Blocos e Comandos Básicos de Controle....................................................... 	19
 Bloco ............... ............................................................................................ 	19 
 Entrada/Saída .... .......................................................................................... 	20
 Alternativa ou Seleção .................................................................................. 	22
 Repetição ..................................................................................................... 	27
 Repetição Controlada por Contador ou por "Flag" ........................................ 	28
2.5. Regras Práticas para Construção de Algorítimos Legíveis .................................	32
3. Algorítimos com Qualidade ..................................................................................	34
3.1. Máximas de Programação ................................................................................ 	34
3.2. Metodologia de Desenvolvimento de Algorítmos ...............................................	35
3.3. Aplicação da Metodologia ................................................................................ 	36
4. Outras Estruturas.................................................................................................. 	41
4.1. Repetição com Variável de Controle .................................................................	41
4.2. Repetição com Teste no Final ...........................................................................	44
4.3. O Comando Abandone ....................................................................................		45
4.4. Alternativa de Múltipla Escolha .........................................................................	46
5. Bibliografia ..........................................................................................................	47
 1. INTRODUÇÃO
Por definição, um computador é uma máquina que a partir de dados de entrada, processa esses dados gerando saída de resultados. Porém é uma máquina muito especial.
Se observamos o funcionamento de uma máquina convencional, como por exemplo, uma máquina de moer carne, veremos o seguinte. Essa máquina tem como entrada carne (ou outro material equivalente), o processamento é moer a carne e a saída é a carne moída. Observe que essa máquina só consegue fazer isso, pois tem um comportamento bastante específico.
Já um computador tem uma característica que o diferencia das outras máquinas. Em função das instruções que são armazenadas na sua memória, um computador pode realizar as tarefas mais distintas, como por exemplo: Processar uma folha de pagamento, uma contabilidade, levar um homem à lua, ou mesmo simular jogos infantis.
Podemos concluir que o computador pode processar dados de muitas maneiras diferentes. Depende fundamentalmente de tipo de instruções que se fornece para ele. Ele obedece nossas instruções e segue o nosso raciocínio. Conclusão: Antes de usá-lo, temos que explicar para ele o que se quer que ele faça.
Durante esse curso, vamos aprender como formular essas instruções para que o computador as execute da melhor maneira possível.
1.1. Características de Funcionamento de um Computador
Para que possamos entender melhor como funciona um computador com relação à execução de uma sequência de instruções, vamos usar o exemplo de funcionamento de um robô. Um robô é uma máquina que consegue realizar uma tarefa seguindo instruções pré estabelecidas armazenadas na memória, tal qual um computador.
Suponhamos que o nosso robô é usado para pintar paredes, ou seja, ele tem mecanismos que permitem fazer a pintura de uma determinada área de uma parede.
As instruções que foram armazenadas na memória do robô foram:
 1. Pegue o pincel;
 2. Pegue a lata de tinta;
 3. Molhe o pincel na tinta;
 4. Passe o pincel na parede;
Será que o robô, com as instruções acima, teria condições de pintar uma parede ?
Obviamente não. Com a sequência de passos fornecidos, ele não conseguiria pintar toda a parede pois os passos deveriam ser repetidos até que a operação tivesse terminado. Vamos introduzir então uma estrutura de repetição, ficando a nova forma como mostrado a seguir:
 1. Enquanto não chegar no fim da parede, repita os passos 2,3,4 e 5;
 2. Pegue o pincel;
 3. Pegue a lata de tinta;
 4. Molhe o pincel na tinta;
 5. Passe o pincel na parede;
Será que conseguimos dar as instruções corretas agora ? Certamente não. Os passos 2 e 3 na verdade não precisam ser repetidos, considerando-se que para pintar a parede basta uma lata de tinta e um pincel.
Uma forma mais correta seria:
 1. Pegue o pincel;
 2. Pegue a lata de tinta;
 3. Enquanto não chegar no fim da parede, repita os passos 4 e 5;
 4. Molhe o pincel na tinta;
 5. Passe o pincel na parede;
E agora, conseguimos que o robô pinte a parede ? Observe que o robô só faz o que estiver previsto nas instruções fornecidas. Acontece que não foi fornecido para ele instruções com relação a deslocamento. Neste caso ele ficaria indefinidamente pintando um mesmo local inicial da parede, sem chegar ao final.
Uma alternativa prevendo esse deslocamento, considerando que o robô sempre começa a pintura do lado esquerdo da parede, seria:
 1. Pegue o pincel;
 2. Pegue a lata de tinta;
 3. Enquanto não chegar no fim da parede, repita os passos 4,5 e 6;
 4. Molhe o pincel na tinta;
 5. Passe o pincel na parede;
 6. Ande um passo à direita;
Bom, agora parece que ele consegue levar a bom termo a sua missão. Porém, se houver falta de tinta na lata no meio da operação, teremos problemas. A solução para isto é introduzir um teste de seleção, prevendo essa situação.
 1. Pegue o pincel;
 2. Pegue a lata de tinta;
 3. Enquanto não chegar no fim da parede, repita os passos 4,5,6 e 7;
 4. Se acabou a tinta, pegue outra lata;
 5. Molhe o pincel na tinta;
 6. Passe o pincel na parede;
 7. Ande um passo à direita;
Neste exemplo, podemos observar que as instruções se encaixam em três estruturas padrão:
. A SEQUÊNCIA SIMPLES, ou seja, a execução de passos um após o outro de forma sequencial (Ex: passos 1 e 2, passos 5, 6 e 7).
. A SELEÇÃO, ou seja, execução de determinada ação, condicionada a um teste. (Ex: passo 4).
. A REPETIÇÃO, ou seja, execução de um conjunto de passos repetidas vezes, enquanto determinada condição for verdadeira (Ex: passo 3).
Essas estruturas são suficientes para descrever qualquer procedimento a ser seguido por um computador.À sequência de passos finitos visando atingir um objetivo, dá-se o nome de ALGORÍTMO.
1.2. O Conceito de Algorítmo e as Estruturas Básicas de Controle
O conceito central da programação e da ciência da computação é o de algorítmo. Programar é basicamente construir algorítmos.
Num algorítmo devemos distinguir claramente dois aspectos complementares:
Aspecto Estático - A formulação de um algorítmo geralmente consiste em um texto contendo comandos (instruções) que devem ser executados numa ordem prescrita. Esse texto é uma representação concreta do algorítmo e tem um caráter evidentemente estático, atemporal, expandido somente no espaço (da folha de papel).
Aspecto Dinâmico - O texto não nos interessa em si, mas sim pelos efeitos que pode evocar sua execução no tempo, dado um conjunto de "condições iniciais". Cada execução de um algorítmo é um evento dinâmico, evoluindo no tempo.
A grande dificuldade na concepção e no entendimento de algorítmos é o problema do relacionamento desses aspectos, ou seja: como entender ("visualizar") as estruturas dinâmicas das possíveis execuções do algorítmo a partir da estrutura estática do texto do algorítmo.
A seguir apresentaremos de forma intuitiva o conceito de algorítmo, e as estruturas básicas de controle como forma de composição de algorítmos inteligíveis.
Uma ação é um evento que ocorre num período de tempo finito, estabelecendo um efeito intencionado e bem definido. Exemplos:
 - "Caminhar até a próxima esquina"
 - "Colocar um livro em cima de uma mesa"
 - "Descascar batatas para o jantar"
 - "Atribuir o valor 3,14 a uma variável"
Se estamos interessados em uma ação é pelo efeito que ela produz. A intenção na execução de uma ação é estabelecer esse efeito, que então naturalmente deve ser bem definido. Ações de efeito imprevisível não nos interessam aqui.
É fundamental que a ação leve um período de tempo finito para ser executada. 
Podemos considerar o estado (de um dado sistema de objetos) como sendo o conjunto de propriedades desses objetos relevantes para nós na situação considerada. Por exemplo:
a) Batatas com casca ou sem casca
b) O conjunto de valores das variáveis de um programa em certo instante da execução.
Suponhamos que se deseja descrever um evento referente à preparação de batatas por uma dona de casa. Um observador faria isso, descrevendo uma sucessão de subações envolvidas no evento:
R1
 "traz a cesta com batatas da dispensa";
 "traz a panela do armário";
 "descasca as batatas";
 "devolve a cesta à dispensa";
O ";" após cada ação indica que as ações ocorreram uma após a outra, na mesma ordem em que elas aparecem no relato.
Suponhamos que R1 seja o relato de um observador em um certo dia. No dia seguinte a dona de casa novamente descasca as batatas para o jantar, e o observador descreve o evento com um relato idêntico ao primeiro.
Podemos dizer que os dois relatos descrevem o mesmo evento ? Evidentemente não, pois trata-se de eventos distintos, ocorridos em dias diferentes, com batatas diferentes de cada vez. Por outro lado os dois eventos são muito similares, a tal ponto que os dois podem ser descritos pelo mesmo relato e que concordamos em dar aos dois eventos o mesmo nome: "uma dona de casa descasca batatas para o jantar". O que os dois eventos têm em comum ? Diremos que neles reconhecemos o mesmo padrão de comportamento.
Consideremos outro exemplo: nas diferentes execuções da operação n2, para diferentes valores de n podemos reconhecer o mesmo padrão de comportamento, e o nome que damos a todos os eventos é "elevar um número ao quadrado".
Postularemos então que em todo evento podemos reconhecer um padrão de comportamento, fazendo abstração dos possivelmente diferentes estados iniciais e efeitos. Inversamente, cada vez que o padrão de comportamento é "seguido" o evento ocorre. O efeito de um evento está totalmente determinado pelo padrão de comportamento e eventualmente pelo estado inicial. No nosso último exemplo, o estado inicial é dado pelo valor de n, e o efeito, pelo valor obtido multiplicando-se esse valor por si mesmo.
Exemplo: Qual o padrão de comportamento utilizado para gerar a sequência:
 1, 5, 9, 13, 17, 21, 25 ?
A partir do valor inicial 1, cada termo seguinte é obtido somando-se 4 ao termo anterior.
Considerando os conceitos discutidos até aqui, podemos definir algoritmo como sendo:
Descrição de um padrão de comportamento, expresso em termos de um repertório bem definido e finito de ações "primitivas", das quais damos por certo que elas podem ser executadas.
Contrariamente ao caráter descritivo do relato do observador, um algoritmo tem um caráter imperativo, motivo pelo qual a ocorrência do nome de uma ação num algoritmo também é chamada de comando.
Um algoritmo é, em outras palavras, uma norma executável para estabelecer um certo efeito desejado, que na prática será geralmente a obtenção de uma solução a um certo tipo de problema. Na nossa vida cotidiana, encontramos constantemente algoritmos: Instruções para o uso de produtos, indicações de montagem, receitas de cozinha, partituras musicais, etc. Quando perguntamos, por exemplo, qual o caminho para se chegar ao aeroporto, perguntamos de fato por um algoritmo cujo seguimento nos leva a nosso objetivo.
Vejamos como exemplo um algoritmo para descascar as batatas para o jantar que uma dona de casa poderia dar a sua nova empregada:
A1
 "traga a cesta com batatas da dispensa";
 "traga a panela do armário";
 "descasque as batatas";
 "devolva a cesta à dispensa";
O símbolo de sequenciamento ";" tem aqui as funções:
.No texto, a de separar um comando de outro.
 No evento que o algoritmo pode evocar, a de indicar que os comandos separados deverão ser executados na mesma seqüência em que aparecem no texto.
O ";" representa a mais simples das chamadas Estruturas de Controle: a SEQUÊNCIA SIMPLES.
Comparando este algoritmo com o relato do observador, cabe perguntar: o que ganhamos introduzindo o conceito de algoritmo ? Afora a trivial transposição gramatical, A1 é idêntico a R1. Temos aqui o caso particularmente simples de um algoritmo consistindo somente de uma concatenação (seqüência textual) de comandos a serem executados em sucessão. Neste exemplo, o algoritmo cujo seguimento produz o evento "descascar batatas para o jantar" e a descrição do próprio evento tal como ele ocorreu, tem exatamente o mesmo poder de expressão.
Veremos a seguir situações em que isso não ocorre. Voltando ao nosso exemplo, imaginaremos que a dona de casa após buscar a panela e antes de descascar as batatas, algumas vezes ainda coloca um avental. O relato de um observador seria então:
R2
 "traz a cesta com batatas da dispensa";
 "traz a panela do armário";
 "coloca o avental";
 "descasca as batatas";
 "devolve a cesta à dispensa";
Esse relato evidentemente não é idêntico a R1. O evento descrito em R1 e o descrito por R2 já não são tão altamente similares quanto os dois eventos que podiam ser descritos pelo mesmo relato R1. Contudo, ainda concordamos em designar os dois eventos pelo mesmo nome "descasca batatas para o jantar". Suponhamos que a dona de casa use um critério racional para decidir se ela coloca o avental ou não, por exemplo, dependendo de sua saia ser de cor clara ou não.
Então podemos escrever um algoritmo que cubra os dois tipos de eventos:
A2
 "traga a cesta com batatas da dispensa";
 "traga a panela do armário";
 se "saia é clara" então "coloque avental";
 "descasque as batatas";
 "devolva a cesta à dispensa";
O conceito de algoritmo nos permite reconhecer o mesmo padrão de comportamento nos dois eventos. Na descrição algorítmica desse padrão de comportamento aparece um novo elemento estrutural: o conectivo condicional se ... então.
A execução ou não da ação "coloque avental" depende, a cada vez que o algoritmo é seguido, do resultado (verdadeiro ou falso) da inspeção se a saia é clara ou não. O conectivo condicional representa a segunda das estruturas de controle: a SELEÇÃO ou ALTERNATIVA.
A possibilidade de um algoritmo correspondera dois ou mais acontecimentos distintos (através do uso de um ou mais se ... então) nos dá uma amostra do seu poderio.
Veremos a seguir uma outra estrutura que torna o algoritmo ainda mais vantajoso em relação a um relato convencional.
Suponha que um observador bastante meticuloso expresse o processo "descasca as batatas" em termos de ação primitiva "descasca uma batata". Se um dia a dona de casa descascar 13 batatas, e no outro 24, teremos dois relatos distintos:
R3
 "traga a cesta com batatas da dispensa";
 "traga a panela do armário";
 "descasca uma batata";			| 
 "descasca uma batata";		|
 . 		| 13 vezes
 . 		|
 . 		|
 "descasca uma batata"; 			|
 "devolva a cesta à dispensa";
R4
 "traga a cesta com batatas da dispensa";
 "traga a panela do armário";
 "descasca uma batata";		|
 "descasca uma batata";		|
 . 		| 24 vezes
 . 		|
 . 		|
 "descasca uma batata"; 		|
 "devolva a cesta à dispensa";
Para a construção de um algoritmo que corresponda aos dois relatos, precisamos reconhecer um mesmo padrão de comportamento nos dois. Vamos supor que a dona de casa é capaz de reconhecer se o número de batatas descascadas é suficiente para o jantar.
	Utilizando apenas os conectivos ";" e se ... então, precisamos ainda de mais uma suposição para podermos compor um algoritmo geral, que vem a ser a existência de um número máximo de batatas a serem descascadas em qualquer dia. Se esse número for 50, podemos escrever o algoritmo:
A3
 "traga a cesta com batatas da dispensa";
 "traga a panela do armário";
 se "saia é clara" então "coloque avental";
 se "número de batatas é insuficiente" então 		|
 "descasque uma batata"; 		|
 se "número de batatas é insuficiente" então 		|
 "descasque uma batata"; 		|
 . 		| 50 vezes
 . 		|
 . 		|
 se "número de batatas é insuficiente" então 		|
 "descasque uma batata"; 		|
"devolva a cesta à dispensa";
Além dos óbvios inconvenientes encontrados na escrita de tal algoritmo, temos ainda as seguintes objeções:
a) Ao executar o algoritmo, se a dona de casa constatar que cinco batatas foram suficientes, de fato ela não precisaria olhar para a panela outras 45 vezes para se certificar.
b) Muitas vezes é difícil dar um limite superior; pode ser que um dia surjam muitos convidados e que as batatas estejam muito pequenas, ocasionando uma falha do algoritmo.
Para fazer frente a todas essas objeções, vamos introduzir agora o conectivo repetitivo enquanto ... faça. Com ele podemos escrever o seguinte algoritmo:
A4
 "traga a cesta com batatas da dispensa";
 "traga a panela do armário";
 se "saia é clara" então "coloque avental";
 enquanto "número de batatas é insuficiente" faça
 "descasque uma batata";
 "devolva a cesta à dispensa";
O acontecimento provocado pela execução de enquanto "inspeção" faça "ação" corresponde à execução repetida do comando se "inspeção" então "ação" até a primeira vez em que a inspeção der valor falso (caso em que a "ação" não seria executada).
Com isto vemos o extremo poderio do conceito de algoritmo: um texto estático, capaz de cobrir toda uma classe de acontecimentos, no mesmo nível de detalhe do relato de um observador.
Entretanto, nesta mesma relação entre texto estático e eventos evoluindo no tempo reside um grande perigo: é facílimo construir um texto, com toda a aparência de um algoritmo, que não seja executável em tempo finito, tal como:
 enquanto "saia é clara" faça
 "descasque uma batata";
Se assumimos que o fato de descascar batatas não altera a cor da saia, torna-se impossível a execução deste algoritmo em um tempo finito, por maior que seja.
Por outro lado, se considerarmos o mesmo número de batatas para serem descascadas, o texto pode levar a resultados diferentes supondo que o ato de descascar as batatas vai escurecer a cor da saia. Estando as batatas mais sujas, a saia vai deixar de ficar clara mais rapidamente, resultando em menos batatas descascadas.
Um algoritmo deve ser determinístico, isto é, dadas as mesmas condições iniciais, deve produzir depois de executado, os mesmos resultados.
No nosso caso, só estamos interessados nos algoritmos que terminam em um tempo finito.
1.3. Programação Estruturada
Uma linguagem de programação é uma técnica de notação para programar, com a intenção de servir de veículo para:
a) Expressão de raciocínio algorítmico;
b) Execução automática de um algoritmo por um computador (programa).
A partir da década de 70, tem sido disseminado o uso de uma forma mais sistemática de programação, visando maior produtividade na construção de programas. Essa sistemática é conhecida por programação estruturada.
A programação estruturada consiste numa metodologia de projeto de programas visando:
·	Facilitar a escrita dos programas;