Curso de Algoritmo

Prévia do material em texto

Curso de Algoritmo - Aula I 
Por: Jorge Luiz E. de Souza ( 22/05/2001 ) 
 
 Introdução 
Olá, comunidade!
Nossa primeira aula será sobre PORTUGOL, uma forma de escrita estruturada, cuja finalidade é: 
descrever em uma sequência lógica os passos para a resolução de um problema. Um detalhe 
importante do portugol é que todas as linhas devem conter uma única instrução iniciada por verbos 
no imperativo.
 O que é Algorítmo? 
É uma forma estruturada de resolver problemas numa sequência lógica, passo a passo até obter o 
resultado desejado.
Todo tipo de problema que temos no dia a dia, resolvemos através de algoritmos naturais, que 
muitas vezes não são nem percebidos como tal.
Um exemplo:
Quando você chega em sua casa a noite. O que você faz para entrar em sua casa?
Você deve estar pensando: "O que isto tem a ver com programação?". A resposta é: TUDO.
Vejamos:
Sob o ponto de vista atual (isto é, sem conhecer algoritmos estruturados) você diria:
Pense na sua resposta! 
Sob o ponto de vista de algorítmo estruturado:
Abrir o portão
Passar para o lado de dentro do terreno
Fechar o portão
Dirigir-se à porta
Pegar a chave da porta
Abrir a porta da casa
Passar para o lado de dentro da casa
Fechar a porta da casa
Pronto! Você está dentro de casa.
 Exemplo 1. Sequência entrar em casa 
Analisando os passos sequenciais seguidos pelo exemplo 1, vemos que em 8 passos simples 
podemos demonstrar através de instruções simples e bem definidas, uma SOLUÇÃO GENÉRICA 
para o PROBLEMA: ENTRAR EM CASA. Isto é, QUALQUER pessoa que olhar para estas 
Copyright (C) 1999-2000 Linux Solutions. 1
http://www.linuxsolutions.com.br/
mailto:contato@olinux.com.br
http://www.linuxsolutions.com.br/
instruções e seguí-las CONSEGUIRÁ ENTRAR EM CASA.
Observe que todo início de linha contém um IMPERATIVO. Não é por acaso!
O computador atende a COMANDOS (instruções diretas que geram uma resposta previsível e 
objetiva). Então, todas as linhas de um PORTUGOL, linguagem básica para entender os algorítmos 
devem iniciar com IMPERATIVOS.
Tente descrever EM PORTUGOL (sequência de linhas lógicas para resolver um problema, com 
linhas iniciadas por imperativos) os seguintes problemas (faça algorítmos contínuos, ignore os 
problemas mais detalhados. Por enquanto!):
Trocar o pneu de um carro.
Levantar demanhã em uma segunda-feira.
Dançar ao som de uma música (suponha que o aparelho de
som está desligado).
Ligar um computador. (se você não sabe! pesquise!)
Acender uma luz em um quarto escuro. (Isto pode ser divertido!)
Tomar um banho de piscina em um dia muito quente. (Suponha que a
piscina está em um clube e você na sua casa).
Abrir um programa de computador. (Suponha que o computador já
está ligado)
Escovar os dentes.
Colocar um CD no aparelho de som.
Ler um livro.
 Conclusão 
O PORTUGOL é uma linguagem simples que não possui muitas regras para sua escrita. Por isto é 
elucidativa a sua utilização. De forma clara, podemos enxergar que a partir de sequências de 
instruções genéricas podemos criar uma solução para um problema. E esta solução (reutilizável) 
poderia ser usada quantas vezes quizermos, desde que as condições sejam as mesmas.
Na aula que vem veremos estruturação do pensamento, desvios condicionais e refinamento de 
código. Até lá! Aguardo críticas e sugestões.
Curso de Algoritmo - Aula II 
Por: Jorge Luiz E. de Souza ( 05/06/2001 ) 
 
 Introdução 
A aula de hoje é sobre estruturação do pensamento. Em primeiro lugar, estruturação do pensamento 
nada mais é do que saber definir qual a ordem de precedência entre os comandos a serem 
executados. Noção muito importante na programação. Isto será útil quando estivermos falando em 
ESCOPO de variáveis e do próprio código. Boa aula!
 Estruturação do pensamento 
Até agora, não pensamos em DETALHES, como por exemplo:
• Condições: para fazer algo; isto é, antes de fazer uma coisa, tenho que verificar se outra já 
foi feita; 
• Desvio: se uma coisa já foi feita, não faça isto, faça aquilo. 
No pensamento estruturado existem FERRAMENTAS que auxiliam a escrita lógica para tais 
condições, são elas: SE [CONDIÇÃO] ENTÃO [COMANDO|LISTA DE COMANDOS]
Copyright (C) 1999-2000 Linux Solutions. 2
mailto:contato@olinux.com.br
Nota: mais a frente, entraremos em detalhes sobre SINTAXE (forma correta de se escrever 
comandos).
Exemplo 1:
Problema ENTRAR EM CASA, refinado.
A instrução: Abrir o portão
Poderíamos REFINAR para:
Pegar chave do portão no bolso
SE chave não está no bolso
 ENTAO Procurar na bolsa
 SE encontrou chave na bolsa então
 ENTAO Abrir o portão
 SENÃO Desesperar-se você está para
fora por tempo indeterminado
 SENÃO Abir o portão
Exemplo 2: REFINAMENTO da instrução Abrir Portão do problema ENTRAR EM CASA
Nota: Para ler o algoritmo, entenda que: cada SE tem duas condições a serem TESTADAS, a 
primeira é o ENTÃO. Caso o ENTÃO SEJA SATISFEITO, isto é, se você optar pela condição do 
ENTÂO, deve ignorar o SENÃO correspondente do SE do mesmo nível.
Por exemplo: no caso da instrução "SE chave não está no bolso", você deve optar por "Procurar na 
bolsa" (ENTÃO) a condição SENÃO correspondente seria "Abrir o portão".
"Ai meu Deus... danou-se..."
Nada disso! Entendendo:
A condição estabelecida é: "chave não está no bolso". O ENTÃO correspondente são instruções a 
serem seguidas caso ela (a condição) seja VERDADEIRA (chave não está no bolso). E O SENÃO 
correspondente, são instruções a serem seguidas quando ela (a condição) for FALSA, isto é, chave 
está no bolso. Entendeu?
Creio que com isto, já dá para você ler o resto do Algoritmo.
Com este exemplo, temos dois conceitos novos: DESVIO CONDICIONAL e REFINAMENTO DE 
CÓDIGO.
 Refinamento de código 
No pensamento estruturado, existe a preocupação de chegar a um resultado a partir de 
GENERALIZAÇÃO/ESPECIALIZAÇÃO. Isto é, a partir de uma visão MACRO de um problema, 
chegar aos detalhes e, enfim, resolver o problema.
Isto é bem mais simples e eficaz do que tentar visualizar todos os detalhes de um problema, a 
medida que vamos escrevendo o código para resolvê-lo.
Um exemplo:
No refinamento do Exemplo 2, a instrução "Desesperar-se", se pensarmos bem, poderia resultar em 
"Ligar para a esposa".
O algorítmo ficaria assim:
Pegar chave do portão no bolso
SE chave não está no bolso
 ENTAO Procurar na bolsa
Copyright (C) 1999-2000 Linux Solutions. 3
 SE encontrou chave na bolsa então
 ENTAO Abrir o portão
 SENÃO Ligar para a esposa
 SENÃO Abir o portão
Ou então:
SE você é casado
 ENTÃO Ligar para Esposa
 SENÃO Desesperar-se
O algorítmo ficaria assim:
Pegar chave do portão no bolso
SE chave não está no bolso
 ENTAO Procurar na bolsa
 SE encontrou chave na bolsa então
 ENTAO Abrir o portão
 SENÃO SE você é casado
 ENTÃO Ligar para Esposa
 SENÃO Desesperar-se
 SENÃO Abir o portão
Ou ainda:
SE você é casado
 ENTÃO Ligar para Esposa
 SENÃO SE você mora com alguém
 ENTÃO Ligar para esta pessoa
 SENÃO Desesperar-se
E por aí vai! Agora, escreva você como ficaria o código. 
O que eu quero mostrar aqui é que o refinamento serve para que, a partir de passos "macro", 
possamos visualizar a solução parcial de um problema em determinadas condições. Após termos 
resolvido o problema em condições ideais, pensaremos em verificar as EXCEÇÕES.
ENTÃO, o pensamento estruturado é uma ótima ferramenta para determinar condições ideais para a 
solução de problemas!
 Desvios condicionais 
Os desvios condicionais são utilizados para que, ao nos depararmos com determinada condição, 
tenhamos como contorná-las, de uma forma ou de outra, podendo haver desvios para os desvios e 
assim por diante.
Tenha em mente que tudo tem um limite. E se um desvio não tem limite, está claro que este não é o 
caminhopara resolver o problema.
Agora, com os conceitos de refinamento, refaça os algoritmos do capítulo anterior colocando 
desvios condicionais onde você achar próprio e refinando passos que você acha que podem ser 
refinados.
Nota: Em portugol não existem ainda regras rígidas para a elaboração da sequência de solução do 
problema, então, sinta-se a vontade para escrever o código de acordo com sua visão do problema.
 Conclusão 
Estruturação do pensamento consiste na utilização de ferramentas como refinamento de código e 
desvios condicionais para a maior consistência do código. Para a partir de uma visão macro de um 
problema podermos chegar a uma solução viável através de refinamentos sucessivos.
Copyright (C) 1999-2000 Linux Solutions. 4
Para uma fixação do conteúdo, refaça os exercícios da primeira aula utilizando estas técnicas (onde 
você achar necessário).
Na próxima aula faremos uma introdução à algoritmos. Sugestões e críticas são bem vindos!
Curso de Algoritmo - Aula III 
Por: Jorge Luiz E. de Souza ( 19/06/2001 ) 
 
 Introdução 
Preparem-se pois esta aula é bem G R A N D E! O objetivo é dar uma introdução ao algoritmo. 
Sendo assim, os conceitos básicos serão todos apresentados, deixando para o decorrer do curso as 
técnicas e explicações detalhadas sobre novos recursos assim que eles se tornarem necessários.
Preparados? Então vamos lá!
 Algoritmo 
A construção de algoritmos é regida por normas chamadas de: sintaxe de comandos. De acordo com 
a evolução no nível de programação, serão apresentadas a sintaxe de cada comando e a forma 
correta de utilizá-los. Inicialmente vamos definir o que é sintaxe.
A boa escrita exige conhecimentos de sintaxe e gramática por parte do escritor. Se o escritor 
conhece bem a língua portuguesa, irá escrever textos claros e concisos. Evitará também erros 
grosseiros que são facilmente percebidos pelo leitor.
O computador pode "ler" o código escrito por um programador através de um compilador. Um 
programa especial que converte o que o programador escreve em linguagemm de alto nível para a 
linguagem de máquina, a qual é entendida pelo computador.
Uma breve introdução ao Processamento de Dados 
A computação é um processo simples e consiste em três passos básicos. São eles: entrada de dados, 
processamento dos dados e saída de informação.
É necessário entender isto, pois não há sentido em um processamento que não gere informação útil 
ao usuário. Então, ao se programar, deve-se ter o cuidado de trabalhar os dados a fim de obter um 
resultado útil.
Exemplo - um programa para calcular automaticamente a potência N de um número X: 
Este programa receberá duas entradas: o número X, e a potência a qual será elevado. Produzindo 
como resultado o valor referente ao processamento da operação matemática potência.
Um programa assim é utilizado em calculadoras científicas, onde define-se o número pressionando, 
a tecla refernete ao mesmo, a tecla YX e a tecla do número relativo à potência. Este é um bom 
exemplo da utilização dos passos básicos mencionados anteriormente (relembrando, entrada de 
dados, processamento, saída de informação).
Por que entrada de dados e saída de informação? 
Se você ainda está se perguntando isto após a explicação anterior, aí vai a resposta.
Entrada de dados: aqui a palavra dados tem o intúito de enfatizar que o que está entrando são 
informações dispersas, cujo conteúdo se quer processar.
Saída de informação: a palavra informação, aqui, denota que após o processamento os dados foram 
ordenados e o processamento extraíu o que não era necessário ou simplesmente foi concluído com 
êxito.
Copyright (C) 1999-2000 Linux Solutions. 5
mailto:contato@olinux.com.br
Observe que no exemplo da calculadora a saída de informação se refere ao resultado da potência 
mostrado no visor da calculadora, como um resultado útil ao usuário que o requisitou.
Bem, chega de blá blá blá!
Em suma, algoritmos se propõem a resolver problemas gerando informação útil após o 
processamento dos dados de entrada.
 Convenções de escrita de algoritmos 
Todas as palavras reservadas são escritas sublinhadas. Não utiliza-se acentos e caracteres especiais 
como o ç . A escrita de literais deve ser entre apóstrofos . Tipos serão escritos em maiúsculas.
O que é uma literal? 
O computador é regido por códigos, somente entendendo estes. Cada letra para o computador é um 
código. Chamaremos letras isoladas de caractere, e um conjunto de letras chamaremos de 
LITERAL.
Obs.: Literal pode conter números, mas números não podem conter caracteres alfa, isto é, letras.
Tipos: 
Tipo é a definição de um conjunto de valores aceitos por uma vaiável. Tipos pré definidos: 
caractere, texto, inteiro, real e lógico.
 Variáveis 
Uma variável é uma posição de memória que pode conter um valor qualquer em determinado ponto 
do programa e outro valor em outro ponto do mesmo programa. Daí, o nome, variável.
As variáveis são definidas utilizando-se a palavra chave declare no início do algoritmo. À toda 
variável declarada é associado um tipo e esta variável somente poderá conter (receber) valores deste 
tipo.
Assim, se uma variável é declarada do tipo texto, seu conteúdo não poderá ser utilizados para 
cálculos matemáticos, visto que não é um número.
Exemplo:
Declare Nome:TEXTO
X: INTEIRO
Válido:
Nome "João da Silva"
X 20
Não permitido:
Nome 50
X "Maria José"
Aqui, declaramos as variáveis Nome (do tipo texto) e X (do tipo inteiro). Como Nome é uma literal, 
não poderá ter seu conteúdo utilizado por uma expressão matemática.
 Comentários 
Pode-se escrever frases explicativas tentro de um algoritmo, com fins de organização e estruturação 
do pensamento, sem que estas façam parte do código. Isto é, não serão executadas como comandos, 
nem mostradas ao usuário. Servindo somente ao propósito descrito acima.
Estas linhas devem começar com duas barras seguidas: //.
Copyright (C) 1999-2000 Linux Solutions. 6
Exemplo:
 A B //Atribuição do valor da variável B à
variável A
Convencões para sintaxe (Forma correta de utilização de um comando) 
Nota: termos entre [ ] são opcionais.
Palavras Reservadas: Algoritmo, Declare, Se, Então, Senão, Para, Enquanto, faça, até, Leia, 
Escreva, catactere, texto, inteiro, lógico.
Comandos de Atribuição 
Atribuição de valor à variável diretamente:
Leia (variável) //Requisição de entrada de valor
pelo usuário
Comandos de Saída
Escreva (Variavel [Texto])
 Como começar um algoritmo 
Todo algoritmo começa com a palavra reservada "Algoritmo", seguida do nome do programa que 
será gerado. E é finalizado com a expressão literal "Fim Algoritmo".
Exemplo:
Algoritmo Soma
 Declare Lista de variáveis
 (Comandos de entrada)
 
 (Procesamento da entrada)
 (Saída da informação)
Fim Algoritmo
Declaração de variáveis 
Variáveis são declaradas no início de um algoritmo e sua sintáxe é a seguinte:
Declare Variavel : TipoDaVariavel
 Variavel : TipoDaVariavel...
 Variavel, Variavel, variavel... : TipoDaVariavel...
Exemplo:
Algoritmo Soma
 Declare A, B, Soma : INTEIRO
 (Comandos de entrada)
 
 (Procesamento da entrada)
 (Saída da informação)
Fim Algoritmo
Copyright (C) 1999-2000 Linux Solutions. 7
 Implementação de entrada de dados 
Quanto a este assunto, há algumas considerações: o que é uma entrada de dados? Quando fazer uma 
requisição de dados ao usuário?
Para responder estas perguntas faremos duas implementações do algoritmo Soma usado acima. Na 
primeira implementação não será requisitada nenhuma interação do usuário com o programa. Isto é, 
o programa fará a soma de dois números e mostrará na tela somente os números que foram somados 
e o resultado da soma. Sem que o usuário possa alterar os números.
Primeira implementação do algoritmo soma 
Algoritmo Soma
 Declare A, B, Soma : INTEIRO
//Comandos de entrada esta linha está aqui a titulo de
informação, não faz parte do algoritmoA 20
 B 50
//Procesamento da entrada esta linha está aqui a titulo de
informação, não faz parte do algoritmo
 Soma A + B
//Saída da informação esta linha está aqui a
titulo de informação, não faz parte do algoritmo
 Escreva ("Primeiro número: ", A)
 Escreva ("Segundo número: ", B)
 Escreva ("Soma= ", A)
Fim Algoritmo
Análise do algoritmo acima 
No algoritmo acima, temos a declaração de três variáveis do tipo inteiro: A, B e Soma.
As linhas:
 A 20
 B 50
 
Atribuem às variáveis A e B os respectivos valores.
A linha:
Soma A + B
Processa a operação matemática soma com os números atribuídos anteriormente às variáveis e 
atribui o resultado da soma à variável Soma.
As linhas:
 Escreva ("Primeiro número: ", A)
 Escreva ("Segundo número: ", B)
 Escreva ("Soma = ", A)
Respectivamente mostram ao usuário:
Primeiro número: 20
Segundo número: 50
Soma = 70
Esta é a saída do algoritmo Soma, descrito acima.
Copyright (C) 1999-2000 Linux Solutions. 8
 Conclusão 
Ufa! Você está meio tonto? É... Com estes novos conceitos na cabeça já dá para entender um pouco 
mais sobre o que estamos tratando.
Algoritmos são códigos escritos em uma linguagem acessível (português estruturado), que visa o 
aprendizado de estruturação e refinamentos sucessivos, bem como a utilização de SINTAXE de 
comandos, para uma posterior migração para uma linguagem de programação.
É importante frisar aqui o fato de que não existem interpretadores capazes de "ler" um algoritmo e 
executá-lo no computador. Sendo que o algoritmo é utilizado para dar uma noção de como criar um 
código executável para o computador.
Uma vez pronto o algoritmo, você deve transformá-lo em código, usando uma linguagem de 
programação de sua escolha. Como por exemplo: Pascal, C, C++ etc.
Obs: geralmente as linguagens de programação possuem algumas regras que devem ser observadas 
na hora da conversão do algoritmo para a linguagem, como por exemplo no Pascal, todas as linhas 
de comando devem terminar com um ";" (ponto e vírgula), entre outras regras próprias da 
linguagem.
Espero que estejam gostando do curso. Até a próxima aula!
Curso de Algoritmo - Aula IV 
Por: Jorge Luiz E. de Souza ( 03/07/2001 ) 
 
 Introdução 
Neste capítulo veremos a resolução de um problema através do uso de Algoritmo. Serão 
apresentadas novas ferramentas e técnicas para a resolução. Estará tudo bem detalhado para que a 
interpretação e aprendizado seja fácil. Vamos começar!
 Desenvolvendo Algoritmos 
Algoritmos são formas de pensamento estruturado, sendo assim, a primeira coisa a fazer, é analizar 
muito bem o problema para identificar todas as possibilidades de solução possíveis. Vejamos o 
seguinte problema:
Problema 1. O Instituto de Pesquisa Tal, deseja utilizar o computador para extrair informações com 
base nos dados obtidos com sua última pesquisa. Os dados são: Nome, idade, sexo, estado civil (e 
número de filhos caso seja casada) e origem de 3000 pessoas (toda população de uma pequina 
cidade).
Deseja-se saber:
1. Quantas mulheres existem na cidade; 
2. Quantas destas mulheres são casadas e tem mais de 3 filhos; 
3. Quantos homens da cidade torcem para o palmeiras. 
Análise do Problema 
• 1ª Observação: o algoritmo a ser feito deverá RECEBER dados digitado pelo usuário. 
Considerando isto, já é clara a necessidade de um comando de leitura para cada item. 
• 2ª Observação: há a necessidade da repetição da leitura para cada pessoa (ficha com dados 
de uma pessoa) entrevistada. Aqui, vemos a necessidade de uma ESTRUTURA DE 
REPETIÇÃO, conceito que será apresentado neste exemplo. 
• 3ª Observação: As palavras QUANTAS, QUANTAS, QUANTOS indicam a necessidade da 
utilização de uma técnica de obtenção de dados quantitativos chamada CONTADOR. Que 
Copyright (C) 1999-2000 Linux Solutions. 9
mailto:contato@olinux.com.br
também será apresentada neste exemplo. 
• 4ª Observação: Deve existir um contador para contar todas as mulheres da cidade. 
• 5ª Observação: Existe uma condição para uma mulher entrar na segunda CONTAGEM, esta 
condição é: ser casada e Ter mais de 3 filhos. Isto quer dizer que teremos dois 
CONTADORES para Mulheres, um para toda e qualquer mulher da cidade e um para as 
casadas com mais de três filhos. 
• 6ª Observação: Existe também uma condição para que um homem entre no TERCEIRO 
CONTADOR. Que é, torcer para o palmeiras. 
Todas as condições aqui expostas serão solucionadas utilizando-se de estruturas SE, ENTÃO e 
SENÃO.
Apresentarei com este exemplo duas estruturas de repetição: Para e Enquanto, para isto haverá duas 
implementações de solução para este mesmo problema.
 Primeira implementação do Algoritmo Pesquisa 
* Utilizando a estrutura de repetição PARA 
Uma breve introdução à estrutura de repetição PARA 
Sintaxe: 
PARA variavel Valor ATÉ ValorFinal FAÇA
{
 AQUI VÃO OS COMANDOS A SEREM EXECUTADOS
 Obs: as chaves utilizadas nesta sintaxe são mais uma
forma de se escrever
 Comentários (comentários em BLOCO), isto é,
tudo o que está 
 Entre as chaves não é interpretado como
código e sim como texto.
}
FIMPARA
Entendendo a sintaxe: O PARA é uma estrutura de repetição incondicional, isto é, uma vez iniciada 
será executada quantas vezes estiver estipulada no intervalo entre variável e valor final. Vejamos:
PARA i 1 até 100 faça
 Escreva("Este laço será executado 100 vezes")
FIMPARA
 
Note que, para a utilização desta estrutura devemos utilizar uma variável inteira, que deve ser 
declarada como tal, na área de declaração de variáveis do Algoritmo. Assim sendo:
Algoritmo Exemplo
 Declare i: inteiro
PARA i 1 até 100 faça
 Escreva(?Este laço será executado 100 vezes?)
FIMPARA
FimAlgoritmo
Veremos mais sobre a utilização desta estrutura em outros exemplos.
Resolução do problema proposto com a estrutura PARA 
Algoritmo Pesquisa
 Declare Nome, EstCiv, TimeQTorce, Origem: texto
Copyright (C) 1999-2000 Linux Solutions. 10
 Sexo: caracter
 i, Idade, contMulher, contMFilhos, ContTPalmeiras:
inteiro
//início do algoritmo
 ContMulher 0
 ContMFilhos 0
 ContTPalmeiras 0
 PARA i <-- 1 ATÉ 3000 FAÇA
 escreva('Digite um nome: ')
 leia (nome)
 Escreva('Digite a idade: ')
 leia(idade)
 Escreva('Digite o Sexo (F para Feminino, M para Masculino):')
 leia(Sexo)
 Escreva('Digite o Estado Civil (Solteiro(a), Casado(a): ')
 Leia(EstCiv)
 SE (sexo = 'F') or (sexo = 'f')
 ENTÃO
 ContMulher ContMulher + 1
 SE EstCiv = 'Casada'
 ENTÃO
 Escreva('Digite o Numero de filhos: ')
 Leia(NumFilhos)
 SE NumFilhos > 3
 ENTÃO
 ContMFilhos ContMFilhos + 1
 FIMSE
 FIMSE
 //fim do então
 SENÃO
 Escreva('Digite o Time para o qual Torce: ')
 Leia(TimeQTorce)
 SE TimeQTorce = 'Palmeiras'
 ENTÃO
 contTPalmeiras ContTPalmeiras +1
 FIMSE
 //fim do senão
 FIMSE
 Escreva('Digite a Origem (BR,US,UC...): ')
 leia(Origem)
 FIMPARA
//Escrevendo os resultados
Escreva("O número de Torcedores do Palmeiras é: ",
ContTPalmeiras)
Escreva("O número de Mulheres da Cidade é: ",ContMulher)
Escreva("O número de Mulheres Casadas com mais de três
filhos é: ", ContMFilhos)
FIMALGORITMO
 Conclusão 
Muito bem! Este primeiro contato com um problema e estas novas técnicas deve ser bem estudada. 
Pois na próxima aula teremos uma análise completa deste algoritmo. Até lá!
Copyright (C) 1999-2000 Linux Solutions. 11
Curso de Algoritmo - Aula V 
Por: Jorge Luiz E. de Souza ( 17/07/2001 ) 
 
 Introdução 
Como prometido aqui está a análise do algoritmo da aula anterior. Vamos entender o código!
 Análise da estrutura PARA 
Primeira análise: A seção de declaração de variáveis 
 Declare Nome, EstCiv, TimeQTorce, Origem: texto
 Sexo: caracter
 i, Idade, contMulher, contMFilhos, ContTPalmeiras:
inteiro
 
A primeira seção de um algoritmo é sempre a DECLARAÇÃO DE VARIÁVEIS. Variáveis estas, 
que serão utilizadas no decorrer do algoritmo. É necessária a declaração, pois se uma variável 
utilizada no corpo do algoritmo não estiver declarada, o algoritmo não será executado. 
Provavelmente ocorrerá o erro ? váriavel desconhecida ? e o programa será abortado.
Segunda análise: A inicialização de variáveis 
Quando declaramos uma variável, simplesmente estamos reservando um espaço de memória que 
poderá conter qualquer valor no decorrer do algoritmo. Mas o endereço ao qual a nossa variável 
está apontando provavelmente contém informações deixadas por outros programas ou se tivermos 
sorte estará vazia. A inicialização de variáveis se faz necessária quando devemos conhecer 
previamente o valor de uma variável.
É o caso dos contadores. Precisamos ter certeza de que o valor inicial de um contador é 0 (zero). 
Então iniciamos seu valor utilizando o comando de atribuição "".
 ContMulher 0
 ContMFilhos 0
 ContTPalmeiras 0
 
NOTA: Um detalhe muito importante que deve ser observado é o nome de uma variável. Devemos 
dar preferência para nomes SIGNIFICATIVOS, isto é, ao criar uma variável, escolha um nome que 
possibilite a vizualização de seu conteúdo simplesmente pela leitura do mesmo. Como no caso 
acima, onde:
• ContMulher é a variável que contará todas as mulheres da pesquisa; 
• ContMFilhos é a variável que contará todas as mulheres casadas e com mais de três filhos; 
• ContTPalmeiras é a variável que contará todos os torcedores do Palmeiras da pesquisa. 
Terceira análise: A implementação do Para e tudo que se irá repetir em seu escopo 
 PARA i <-- 1 ATÉ 3000 FAÇA
 escreva('Digite um nome: ')
 leia (nome)
 Escreva('Digite a idade: ')
 leia(idade)
 Escreva(Digite o Sexo (F para Feminino, M para Masculino):
')
Copyright (C) 1999-2000 Linux Solutions. 12
http://olinux.uol.com.br/artigos/345/1.html
mailto:contato@olinux.com.br
 leia(Sexo)
 Escreva('Digite o Estado Civil (Solteiro(a), Casado(a): ')
 Leia(EstCiv)
 SE (sexo = 'F') or (sexo = 'f')
 ENTÃO
 ContMulher ContMulher + 1
 SE EstCiv = 'Casada'
 ENTÃO
 Escreva('Digite o Numero de filhos: ')
 Leia(NumFilhos)
 SE NumFilhos > 3
 ENTÃO
 ContMFilhos ContMFilhos + 1
 FIMSE
 FIMSE
 //fim do então
 SENÃO
 Escreva('Digite o Time para o qual Torce: ')
 Leia(TimeQTorce)
 SE TimeQTorce = 'Palmeiras'
 ENTÃO
 contTPalmeiras ContTPalmeiras +1
 FIMSE
 //fim do senão
 FIMSE
 Escreva('Digite a Origem (BR,US,UC...): ')
 leia(Origem)
 FIMPARA
 
Muito bem, observando a estrutura acima, podemos notar: Todas as instruções entre o PARA e o 
FIMPARA serão executadas 3000 vezes. A estrutura de SE utilizada será tratada na Quarta análise. 
Todo o processamento do programa está dentro do para As primeiras oito linhas após o PARA são 
de leitura das variáveis (NOME, IDADE, SEXO e ESTCIV). Os comandos Escreva que antecedem 
cada comando Leia, são para informar o usuário quanto ao que o programa está esperando que ele 
digite.
A posição de implementação dos contadores dentro da estrutura é estratégica, e não poderia ser 
outra. De acordo com a lógica do algoritmo, as leituras que estão dentro dos SE, mais internos, 
somente ocorrerão se a condição de entrada do ENTÃO ou SENÃO correspondente forem 
satisfeitas. Isto é, para o nosso algoritmo, se uma mulher não estiver com estado civil "Casada", o 
algoritmo não lerá número de filhos para esta mulher.
Notamos que alguns valores recebidos não estão servindo para nenhum calculo especial, somente 
sendo necessários se, forem ser guardados em um banco de dados.
Quarta análise: Estrutura SE ENTÃO SENÃO encadeadas 
 SE (sexo = 'F') or (sexo = 'f')
 ENTÃO
 ContMulher ContMulher + 1
 SE EstCiv = 'Casada'
 ENTÃO
 Escreva('Digite o Numero de filhos: ')
 Leia(NumFilhos)
 SE NumFilhos > 3
 ENTÃO
Copyright (C) 1999-2000 Linux Solutions. 13
 ContMFilhos ContMFilhos + 1
 FIMSE
 FIMSE
 //fim do então
 SENÃO
 Escreva('Digite o Time para o qual Torce: ')
 Leia(TimeQTorce)
 SE TimeQTorce = 'Palmeiras'
 ENTÃO
 contTPalmeiras ContTPalmeiras +1
 FIMSE
 //fim do senão
 FIMSE
 
Observamos aqui, uma estrutura de SE's encadeados. NOTA: A indentação é muito importante na 
estruturação visual do código para uma melhor leitura e entendimento do mesmo. INDENTAÇÃO 
É: Tabulação de elementos semelhantes em um mesmo nível (COLUNA imaginária). Se você pegar 
uma régua e colocar no início de um ENTÃO, encontrará seu SENÃO correspondente, e assim por 
diante.
Relembrando 
Uma estrutura SE possui dois caminhos a serem seguidos, de acordo com o resultado da condição 
estabelecida para o mesmo.
Sintaxe:
SE CONDIÇÃO
 ENTÃO //comandos do então CASO A
CONDIÇÃO SEJA VERDADEIRA
 SENÃO //comandos do senão CASO A
CONDIÇÃO SEJA FALSA
 FIMSE
 
Então, se o resultado da condição: SE (sexo = 'F') or (sexo = 'f') , for VERDADEIRA, serão 
executados todos os comandos que estão dentro do ENTÃO deste SE.
 ContMulher ContMulher + 1
 SE EstCiv = 'Casada'
 ENTÃO
 Escreva('Digite o Numero de filhos: ')
 Leia(NumFilhos)
 SE NumFilhos > 3
 ENTÃO
 ContMFilhos ContMFilhos + 1
 FIMSE
 FIMSE
 //fim do então
 
Caso contrário, se o resultado da condição for FALSO, serão executados todos os comandos do 
SENÃO correspondente.
 Escreva('Digite o Time para o qual Torce: ')
 Leia(TimeQTorce)
 SE TimeQTorce = 'Palmeiras'
 ENTÃO
 contTPalmeiras ContTPalmeiras +1
 FIMSE
 //fim do senão
 
Copyright (C) 1999-2000 Linux Solutions. 14
E assim é para todos os SE's encadeados dentro deste último.
Quinta análise: Comandos de saída (resultado do processamento) 
Nosso exemplo é muito simples, e sua saída não poderia ser diferente. Como utilizamos comente 
estruturas de contagem (CONTADORES), após a leitura ser finalizadas, simplesmente escrevemos 
uma frase elucidativa antes de mostrar o CONTEÚDO (somatória) das variáveis de contagem.
Sexta análise: Comentário sobre as deficiencias e possíveis refinamentos 
Este código é um bom começo, mas apresenta algumas "falhas". Por exemplo: - Uma vez iniciada a 
execução, será necessário digitar contínuamente todos as 3000 fichas. Sem interrupção, isto é, sem 
fechar o programa. Agora, imagine se fossem 100.000 entradas!
Então, o PARA é uma estrutura falha?! De maneira alguma, é uma ótima estrutura de repetição, mas 
devemos pensar muito bem aonde a utilizaremos dentro de um algoritmo.
Em nossa próxima implementação de solução para este mesmo problema, utilizaremos uma 
estrutura de repetição mais flexível o ENQUANTOque nos traz mais um conceito importante em 
programação; as FLAGs.
 Conclusão 
O algoritmo está certo, mas a estrutura apresentada na resolução (PARA) não é adequada para esta 
situação (isto foi feito propositalmente, para apresentar a você a estrutura). Na próxima aula 
apresentaremos o mesmo algoritmo com a estrutura (ENQUANTO), mais adequada para este 
problema.
Entenda bem a leitura (interpretação) deste código, pois na próxima somente será analisada a nova 
estrutura, sendo que o restante do código será o mesmo. Até a próxima!
Curso de Algoritmo - Aula VI 
Por: Jorge Luiz E. de Souza ( 31/07/2001 ) 
 
 Introdução 
Como prometido aqui está a nova implementação do algoritmo da aula anterior. Espero que você 
tenha entendido a estrutura, pois somente será analisado aqui a nova estrutura (ENQUANTO). Se 
você ainda tem alguma dúvida, dê uma olhada na aula anterior que possui a análise completa da 
estrutura.
Vamos aprender mais!
 A estrutura ENQUANTO 
Algoritmo Pesquisa
 Declare Nome, EstCiv, TimeQTorce, Origem: texto
 Sexo: caracter
 i, Idade, contMulher, contMFilhos, ContTPalmeiras:
inteiro
//início do algoritmo
 ContMulher 0
 ContMFilhos 0
 ContTPalmeiras 0
 escreva('Digite um nome: ')
 leia (nome)
Copyright (C) 1999-2000 Linux Solutions. 15
mailto:contato@olinux.com.br
 ENQUANTO nome <> ?fim? FAÇA
 escreva('Digite um nome: ')
 leia (nome)
 Escreva('Digite a idade: ')
 leia(idade)
 Escreva(Digite o Sexo (F para Feminino, M para Masculino): ')
 leia(Sexo)
 Escreva('Digite o Estado Civil (Solteiro(a), Casado(a): ')
 Leia(EstCiv)
 SE (sexo = 'F') or (sexo = 'f')
 ENTÃO
 ContMulher ContMulher + 1
 SE EstCiv = 'Casada'
 ENTÃO
 Escreva('Digite o Numero de filhos: ')
 Leia(NumFilhos)
 SE NumFilhos > 3
 ENTÃO
 ContMFilhos ContMFilhos + 1
 FIMSE
 FIMSE
 //fim do então
 SENÃO
 Escreva('Digite o Time para o qual Torce: ')
 Leia(TimeQTorce)
 SE TimeQTorce = 'Palmeiras'
 ENTÃO
 contTPalmeiras ContTPalmeiras +1
 FIMSE
 //fim do senão
 FIMSE
 Escreva('Digite a Origem (BR,US,UC...): ')
 leia(Origem)
 escreva('Digite um nome: ')
 leia (nome)
 FIMENQUANTO
//Escrevendo os resultados
Escreva("O número de Torcedores do Palmeiras é: ",
ContTPalmeiras)
Escreva("O número de Mulheres da Cidade é: ",ContMulher)
Escreva("O número de Mulheres Casadas com mais de três
filhos é: ", ContMFilhos)
FIMALGORITMO
 Análise do algoritmo 
Todas as análises são idênticas à resolução anterior, com exceção dos novos conceitos: FLAG e a 
estrutura enquanto.
Vejamos a estrutura enquanto:
Sintaxe: 
 ENQUANTO [CONDIÇÃO] FAÇA
 FIMENQUANTO
 
Copyright (C) 1999-2000 Linux Solutions. 16
A estrutura básica do ENQUANTO é a dada acima, mas uma técnica para utilização desta estrutura 
é a FLAG.
Uma FLAG é uma condição pré-definida que determina o fim do laço ENQUANTO. Para se 
utilizar flags é necessário determinar qual a melhor variável deve determinar (com o seu valor no 
decorrer do algoritmo) a saída do laço. Isto pode variar de problema para problema, mas geralmente 
usamos a primeira informação, dentro de uma sequência de informações digitadas pelo usuário. 
Sendo assim, se esta primeira informação contiver o valor determinado como FLAG de saída, o 
laço é abortado e o programa continua na primeira linha do algoritmo após o final da estrutura do 
laço.
Assim temos (no nosso exemplo):
 escreva('Digite um nome: ')
 leia (nome)
 ENQUANTO nome <> "fim" FAÇA
 // comandos a serem executados para um nome diferente de fim
 escreva('Digite um nome: ')
 leia (nome)
 FIMENQUANTO
 
Notem que estamos "lendo" o nome duas vezes na estrutura. Por quê?
A primeira leitura é feita FORA do laço, e serve para que o usuário possa ignorar o laço, caso ele 
deseje isto. Isto é, se o usuário digitar "fim" antes de entrar no laço, o laço será ignorado. Isto 
garante a flexibilidade do ENQUANTO.
Já a segunda leitura, está dentro do laço e garante que a(s) próxima(s) interação(ções) do laço, 
saberá(ão) o valor da FLAG de saída. Isto é necessário, pois caso não leiamos a variável "nome" 
dentro do laço, ocorrerá um LOOP ETERNO, uma vez que a condição de saída NUNCA será 
satisfeita. Isto é, se não lemos a variável nome, não podemos atribuir a ela o valor "fim" que 
determina a parada do laço.
É importante notar também, que a variável que está nos servindo como FLAG, dentro do laço, deve 
ser a última instrução a ser lida. Pois após esta leitura, se a condição de saída for satisfeita os 
comandos de dentro do laço não devem mais ser executados.
 Conclusão 
Com isto terminamos o nosso curso básico de algoritmos. Espero que tenham aproveitado e 
gostado! Futuramente, em uma segunda parte, falaremos de comandos mais avançados e resolução 
de problemas matemáticos através dos algoritmos. Até lá!
Curso de Algoritmo - Aula VII 
Por: Jorge Luiz E. Souza ( 11/01/2002 ) 
 
 Introdução 
Muito bem, como ficou acertado, veremos a resolução de exercícios matemáticos, para a escrita de 
algoritmos estruturados.
 Exemplo 1 
Nosso primeiro exercício será a resolução de uma somatória de números.
S = 1 + 2 + 3 + 5 + ...
Copyright (C) 1999-2000 Linux Solutions. 17
mailto:contato@olinux.com.br
Até um total de 500 dígitos.
Já ficou estabelecido o número de repetições, então, a melhor estrutura a ser utilizada para a 
resolução do problema é o PARA.
Resolução 
Algoritmo Somatoria
Declare S, i : Inteiro
//Inicialização da variável acumuladora
S <- 1
 PARA i <- 2 ATÉ 500 FAÇA
 S <- S + i
 FIMPARA
FIM ALGORITMO
Pronto, a implementação para a solução deste problema é bem simples não?! E demonstra um 
pouco do poder de cálculo dos computadores. Para fazer esta soma, um computador levaria um 
milésimos de segundo.
Aproveitando esta implementação, vejamos uma técnica para atualização rápida de estruturas 
PARA, em algoritmos mais complexos. Esta técnica é muito importante, pois imagine um código 
com 1500 (mil e quinhentas) linhas, e algumas estruturas PARA espalhadas, utilizando o mesmo 
valor de repetições. Você teria que procurar pelo código para encontrar as estruturas PARA e 
atualizar uma por uma caso o valor de repetição mudasse.
A técnica é a seguinte:
Ao invés de utilizarmos:
PARA i <- 2 ATÉ 500 FAÇA
Utilizaremos:
PARA i <- 2 ATÉ VFim FAÇA
Onde Vfim é uma variável que deve ser inicializada no início do programa com o valor de 
finalização da estrutura de repetição.
Então teriamos:
Algoritmo Somatoria
 
Declare S, Vfim, i : Inteiro
//Inicialização da variável acumuladora
S <- 1
Vfim <- 500
 PARA i <- 2 ATÉ VFim FAÇA
 S <- S + i
 FIMPARA
FIM ALGORITMO
Agora, basta alterar o valor de Vfim, para que a estrutura passe a calcular mais ou menos de 500 
dígitos.
 Exemplo 2 
Copyright (C) 1999-2000 Linux Solutions. 18
Vejamos um algoritmo para resolver o seguinte problema:
S <- 2 + 4 + 6 + 8 +...
Para um total de 1000 dígitos.
Algoritmo SomatoriaII
 
Declare S, Vfim, i : Inteiro
 //Inicialização da variável acumuladora
S <- 0
Vfim <- 1000
 PARA i <- 1 ATÉ VFim FAÇA
 S <- S + (i*2)
 FIMPARA
FIM ALGORITMO
Note que a solução apresentada aqui, para este segundo exemplo, utiliza a própria variável da 
estrutura PARA, para obter os valores a serem somados. Assim, quando o valor de "i" for:
I = 1 ------- S receberá seu valor atual (zero) + o valor obtido pela multiplicação de "i" por 2, isto é 
(dois).
I = 2 ------- S receberá seu valor atual(dois) + o valor obtido pela multiplicação de "i" por 2, isto é 
(quatro).
E assim por diante.
Observe que foi utilizado parenteses para descrever a ordem de operações que deve ser seguida. 
Como na matemática, o computador, se não especificado, segue a seguinte ordem de operações 
matemáticas:
1. Raiz quadrada 
2. Equações 
3. Multiplicação e divisão 
4. Soma e subtração 
5. Operadores lógicos (AND,OR,XOR,NOT) 
Para determinar a ordem de uma expressão matemática utiliza-se os parenteses. Assim, dão 
resultados diferentes:
1. 5*5+15/20 é diferente de 5*(5+15)/20 que é diferente de (5*5+(15/20)).
 Conclusão 
Com esta aula, vimos que a implementação de uma somatória pode ser muito simples e rápida para 
o computador. E como uma técnica simples pode ajudar na manutenção de estruturas PARA em 
algoritmos mais complexos.
Para exercitar, faça um algoritmo que calcule:
S = 1+ 3+ 5 + 7+...
Para 20 dígitos
Curso de Algoritmo - Aula VIII 
Por: Jorge Luiz E. Souza ( 18/02/2001 ) 
 
Copyright (C) 1999-2000 Linux Solutions. 19
mailto:contato@olinux.com.br
 Intorudção 
Este capítulo está direcionado para a resolução de exercícios, então, vamos à luta!
OBS: O estudo detalhado e a resolução dos exercícios desta aula serão apresentados na aula 
seguinte. Pois o objetivo desta aula é uma avaliação de conhecimento adquirido, ou melhor, uma 
auto-avaliação, pois você deve tentar resolver sozinho, para poder comparar com a solução que eu 
darei. Boa Sorte!
 Exercícios 
Exercício 1 
Fazer um algoritmo que dadas as dimensões de um retângulo, calcule a sua área e escreva na tela.
Exercício 2 
Fazer um algoritmo que para cada número digitado pelo usuário, calcule seu fatorial e escreva na 
tela.
Exercício 3 
Fazer um algoritimo para calcular a potência N de um numero X. Ambos serão digitados pelo 
usuário. E escreva na tela.
Exercício 4 
Dada a expressão:
2*10*2*20*2*30*2*40
1+2+3+4+5+6+7+8
Fazer um algoritmo para mostrar seu resultado.
Exercício 5 
Fazer um algoritmo que dados dois números, calcule a razão existente entre eles e monte uma PA de 
10 termos e escreva na tela.
O calculo da razão é o segundo termo menos o primeiro.
Exercício 6 
Tendo-se a seguinte expressão matemática:
 Soma = X+Y
 Mult= X*Y
 SubTotal = Mult / Soma 
 Expressao = [(X*15)+(Y*25)+(X*35)+(Y*45)+(X*55)]/15
 Total= SubTotal + Expressao
Fazer um algoritmo que:
1. Leia os valores X e Y 
2. Calcule a soma e a multiplicacao destes valores e armazene em SubTotal 
3. Calcule expressao e armazene a última operação de soma na variável Total 
Ao final do programa, listar na tela os valores, da seguinte maneira:
Exercício 6
Valores digitados pelo usuário "VALOR DE X"; "VALOR DE Y"
Subtotal : "VALOR DO SUBTOTAL";
Expressão: "VALOR DA EXPRESSÃO";
Total:"Valor total";
Copyright (C) 1999-2000 Linux Solutions. 20
Curso de Algoritmo - Aula IX 
Por: Jorge Luiz E. Sousa ( 29/01/2002 ) 
 
 Introdução 
Como prometido aqui estão as soluções dos exercícios apresentados na aula anterior .
Solução dos exercícios. Confira!
 Exercício 1 
Fazer um algoritmo que dadas as dimensões de um retângulo, calcule a sua área e escreva na tela.
Algoritmo
Declare
//Inicio do algoritmo
 //Obtendo os dados do usuário
 Escreva('Digite o valor da base do retângulo: ')
 Leia(Base)
 Escreva('Digite o valor da altura do retângulo: ')
 Leia(Altura)
 
 //Calculando a área
 Area <- Base * altura
 
 Escreva('A área é: ',Area)
 
FimAlgoritmo
Análise do algorítmo acima:
Primeira análise:
Este algoritmo é muito simples, sendo necessário apenas uma fórmula para sua solução. não há o 
que comentar... qualquer dúvida contacte-me.
 Exercício 2 
Fazer um algoritmo que para cada número digitado pelo usuário, calcule seu fatorial e escreva na 
tela.
Algoritmo
Declare
//Inicio do algoritmo
 
 //Obtendo dados do usuário para entrar no laço ou
não
 Escreva ('Digite um número, ou 0 para sair(o fatorial de 0
é 1.)')')
 Leia
(Numero)
 //Inicializando variáveis
 i<- Numero
 Fatorial<- 1
 Enquanto Numero <> 0 faça
Para i<- 1 até Numero Faça
Copyright (C) 1999-2000 Linux Solutions. 21
http://olinux.uol.com.br/artigos/437/1.html
mailto:contato@olinux.com.br
Se i<>0 
 então Fatorial<- Fatorial * i
 i<- i-1
 FimPara
Escreva('O fatorial de ',Numero,' é ',Fatorial)
 
 //Obtendo dados do usuário para continuar ou sair do
laço
 Escreva('Digite um número, ou 0 para sair(o fatorial
de 0 é 1.)')')
 Leia(Numero)
 FimEnquanto
FimAlgoritmo
Análise do algorítmo acima:
Primeira análise.
Para se calcular o fatorial de um número, é necessário multiplicá-lo pelos seus predessessores até se 
chegar ao 1. Por tanto, o fatorial de 5 é 5*4*3*2*1.
Com base nisto, chega-se a conclusão de que uma estrutura PARA resolve o problema, visto que 
temos o valor inicial e o ponto de parada.
Segunda análise.
Como em algoritmo a estrutura PARA somente "anda para frente", devemos utilizar uma variável 
auxiliar para decrementar o número, assim poderemos chegar ao valor desejado, testando se o 
decremento chegou a zero por precaução.
 Exercício 3 
Fazer um algoritimo para calcular a potência N de um numero X. Ambos serão digitados pelo 
usuário. E escreva na tela.
Algoritmo
Declare
//Inicio do algoritmo
 //Obtendo os dados do usuário
 Escreva('Digite a base:')
 Leia(Base)
 Escreva('Digite o expoente:')
 Leia(Expoente)
 
 //Inicializando variável resultado
 Resultado<- Base
 
 //Calculando
 Se Expoente = 0
 então
Resultado<-1 
 senão
Se base = 0
 então Resultado <- 0
 senão PARA i<- 1 até (Expoente -1)
FAÇA
Resultado<- Resultado * Expoente
 FimPARA
FimSe
FimSe
Copyright (C) 1999-2000 Linux Solutions. 22
Escreva('O resultado é: ',Resultado)
FimAlgoritmo
Análise do algorítmo acima:
Primeira análise
O calculo da exponenciação se dá como XN de modo que para se obter o resultado final deve-se 
multiplicar X por ele mesmo N vezes. Então, conhecemos o valor inicial (1) e o valor final será 
dado pelo usuário.
A estrutura PARA é o mais indicado.
Segunda análise
Montar a expressão é facil, mas em algoritmo é necessário mostrar todos os passos para a máquina 
(computador), pois você o está ensinando a fazer algo. então, devemos prever todas as situações 
possíveis. Por isto, testamos a entrada do expoente 0, e base 0.
 Exercício 4 
Dada a expressão:
2*10*2*20*2*30*2*40 
1+2+3+4+5+6+7+8
fazer um algoritmo para mostrar seu resultado.
Algoritmo
Declare
//Inicio do algoritmo
j<-10
Somar
<- 0
 PARA i <- 1 até 8 Faça
Calcular<- Calcular + (2*j)
 Somar<- Somar + i
 j<- j + 10
 FimPARA
Resultado<- Calcular / Somar
 
 Escreva('O resultado é: ', Resultado) 
 
FimAlgoritmo
Análise do algorítmo acima:
Primeira análise
A expressão é fixa tendo somente oito elementos no numerador, oito no denominador. A estrutura 
para é a mais indicada para resolver.
Segunda análise
São necessárias variáveis auxiliares para o calculo, estas são Calcular, j e Somar que fazem 
respectivamente:
1. Calcular o valor final do numerador, utilizando-se do incremento do j; 
Copyright (C) 1999-2000 Linux Solutions. 23
2. Calcular o valor do denominador. 
 Exercício 5 
Note que somente os calculos são feitos dentro do laço. o calculo do resultado final foi feito após o 
calculo das partes. Fora do laço. Bem como a escrita.
 Exercício 5 
Fazer um algoritmo que dados dois números, calcule a razão existente entre eles e monte uma PA de 
10 termos e escreva na tela.
O calculo da razão é o segundo termo menos o primeiro.
Algoritmo
Declare
//Inicio do algoritmo
 //Obtendo os dados do usuário
 Escreva('Digite o primeiro número')
 Leia(PTermo)
 
 Escreva('Digite o segundo número')
 Leia(STermo) 
 
 //Calculando a razão
 Razao<- STermo - PTermo 
 
 Escreva('Osdez primeiros termos desta PA são:') 
 Escreva(PTermo)
 Escreva(STermo)
 TAux<-STermo
 Para i<-3 até 8 Faça
ProxTermo<- TAux + Razao
 Escreva(ProxTermo)
 TAux<- ProxTermo
 FimPara
FimAlgoritmo
Análise do algorítmo acima:
Primeira análise
Uma PA é uma seqüência de números com uma razão entre eles. Para se calcular os termos da PA é 
necessário conhecer pelo menos um e a razão. No nosso caso, temos os dois primeiros, isto significa 
que temos a razão também. Depois é só somar.
Segunda análise
Não existe somente esta forma para resolver o problema. observe isto. Use este algoritmo como 
base somente, não como a única solução.
 Exercício 6 
Tendo-se a seguinte expressão matemática:
Soma = X+Y
Mult= X*Y
SubTotal = Mult / Soma 
Expressao = [ (X*15)+(Y*25)+(X*35)+(Y*45)+(X*55) ] / 15
Copyright (C) 1999-2000 Linux Solutions. 24
Total= SubTotal + Expressao
Fazer um algoritmo que:
1. Leia os valores X e Y 
2. Calcule a soma e a multiplicação destes valores e armazene em SubTotal 
3. Calcule expressão e armazene a última operação de soma na variável Total 
Ao final do programa, listar na tela os valores, da seguinte maneira:
Exercício 6
Valores digitados pelo usuário "VALOR DE X"; "VALOR DE Y"
Subtotal : "VALOR DO SUBTOTAL";
Expressão: "VALOR DA EXPRESSÃO";
Total:"Valor total";
Algoritmo
Declare
//Inicio do algoritmo
 //Obtendo os números do usuário
 Escreva('Digite o primeiro número')
 leia(X)
 Escreva('Digite o Segundo número')
 Leia(Y)
 
 Soma <- X + Y
 Mult <- X * Y
 SubTotal <- Mult / Soma
 
 Expressao <- 0
 i<-15
 j<- 1 
 Enquanto i <= 55 faça
Par<- J mod 2
 Se (par = 0)
 Então Expressao <- Expressao + (X*i)
 Senão Expressao <- Expressao + (Y*i)
 FimSe
i<- i + 10
 Fim Enquanto
Expressao<-Expressao/15
 
 Total <- SubTotal + Expressao
 Escreva('Exercicio1')
 Escreva('') //isto escreve uma linha vazia
 Escreva('') //isto escreve uma linha vazia
 Escreva('Os valores digitados pelo usuário
são:X=',X,' Y= ',Y)
 Escreva('SubTotal= ',SubTotal)
 Escreva('Expressão= ',Expressao)
 Escreva('O valor total dos calculos é:', Total)
 
FimAlgoritmo
Análise do algoritmo acima:
Primeira análise
O problema apresentado neste exercício e no anterior, devem ser resolvidos em partes, assim, na 
sequência temos a solução da primeira expressão, da segunda, do subtotal e o calculo da expressão.
Segunda análise
Copyright (C) 1999-2000 Linux Solutions. 25
Sobre o calculo da expressão:
Expressao <- 0
 i<-15
 j<- 1 
 Enquanto i <= 55 faça
Par<- J mod 2
 Se (par = 0)
 Então Expressao <- Expressao + (X*i)
 Senão Expressao <- Expressao + (Y*i)
 FimSe
i<- i + 10
 Fim Enquanto
Expressao<-Expressao / 15
Vejamos:
1. a inicialização da variável "Expressao" com zero é para que ele esteja "limpa" quando 
receber o primeiro valor. 
2. a variável "i" recebendo 15 servirá para o incremento dos valores 15,25,35... 
3. a variável "Par" receberá o valor do resto da divisão de j por 2, e definirá se o número é par 
ou impar. Portanto, quando for inpar multiplicaremos "i" por "X" e quando for par, 
multiplicaremos por "Y". 
4. quando sairmos do laço, a expressão estará pronta para ser dividida por 15. 
 Conclusão 
Com estes exercícios, terminamos este módulo. No próximo, veremos mais estruturas, ainda não 
apresentadas, como vetores e matrizes.
Até mais!
Se você conseguiu fazer todos os exercícios, Parabéns!
Se não, não fique triste, você pode revisar as aulas e tentar de novo.
Curso de Algoritmo - Aula X 
Por: Jorge Luiz E. Sousa ( 15/02/2002 ) 
 
 Introdução 
Olá, comunidade!
Hoje começa uma nova faze do curso, onde veremos algumas estruturas novas e muito importantes 
para programação. São chamadas VETORES.
 Definição 
São estruturas unidimensionais e homogêneas capazes de armazenar um número determinado de 
variáveis e referenciálas utilizando uma estrutura de índice. De acordo com esta descrição, vejamos 
um exemplo:
Exemplo de um vetor de 8 (oito) posições
5 15 25 100 0 21 35 50
Exemplo de um vetor de 8 (oito) posições
'JLes' 'Exemplo' 'de' 'VETORES' '' '' '' ''
Observe nas estruturas acima, que:
Copyright (C) 1999-2000 Linux Solutions. 26
mailto:contato@olinux.com.br
• No primeiro exemplo temos um vetor numérico 
• No segundo temos um vetor literal 
• Os dois exemplos estão totalmente preenchidos 
• O primeiro vetor foi inicializado com zeros 
• O segundo vetor foi inicializado com '' (espaços/vazio) 
• Ambos são homogêneos, isto é, seu conteúdo é do mesmo tipo 
• Ambos são unidimencionais, um índice basta para referenciar as posições do vetor. 
Com a explicação acima, concluimos que vetores são variáveis com múltiplas posições.
 Sintaxe 
A sintaxe de declaração de variáveis para vetores é:
Declare <NomeDaVariável> : Vetor [INI .. FIM]
TipoDoVetor
Onde:
• Declare é a palavra reservada para declaração de variáveis (sempre no início do Algoritmo) 
• <NomeDaVariável> : é o nome dado pelo usuário para a variável 
• Vetor é a palavra reservada para definir que uma variável é do tipo VETOR 
• [INI .. FIM] define a quantidade de ítens de um vetor 
• TipoDoVetor define o tipo de variável que o vetor vai armazenar. 
Exemplo:
Declare vetNome : vetor [1..50] literal
Declare vetSalario : vetor [1..50] numérico inteiro
 Características 
• Unidimensionais, 
• Homogêneos, 
• Um mesmo indice pode acessar valores em vários vetores distintos, desde que haja uma 
relação entre eles e sejam "do mesmo tamanho". 
• Ao tentar acessar uma posição inexistente, ocorrerá um erro no programa. 
• Vetores só existem na memória do computador e durante a execução de um programa ou 
"PROCEDIMENTO", não sendo estruturas para armazenamento permanente. 
Obs.: PROCEDIMENTOS e FUNÇÕES serão matéria de aulas futuras
 Referência 
Para acessar uma determinada posição do vetor, será necessário informar o nome do vetor e a 
posição desejada.
Exemplo:
NomeAtual <- vetNome[40]
SalarioAtual <- vetSalario[40]
 Aplicação 
Copyright (C) 1999-2000 Linux Solutions. 27
Estas estruturas são utilizadas para armazenar temporáriamente vários valores relacionados.
Como mostrado no exemplo anterior, podemos ter vários vetores de "N" posições, armazenando 
dados diferentes e relacionados, "SIMULANDO EM MEMÓRIA", o armazenamento de 
informações, para referência futura.
 Exemplo 
Como exemplo, vamos criar uma agenda virtual, que durante sua execução, armazenará: Nome, 
Telefone, endereço e e-mail de 100 pessoas.
Algoritmo
 
Declare Nome,Ender,Telefone,EMail: vetor [1..100]literal
 Indice: numérico inteiro
//Início do algoritmo 
 
 //Inicializando indice
 Indice<-1
 
 //Inicializando vetores
 Parai<- 1 até 100 Faça
 Nome[i]<-''
 Ender[i]<-''
 Telefone[i]<-''
 EMail[i]<-'' 
 FimPara //Obtendo dados do usuário
 Para i<- 1 até 100 Faça 
 Escreva('Digite o nome:')
 Leia(Nome[i]) 
 Escreva('Digite o Endereco')
 Leia(Ender[i]) 
 Escreva('Digite o Telefone')
 Leia(Telefone[i]) 
 Escreva('Digite o e-mail')
 Leia(EMail[i])
 FimPara 
 //Listando todos os registros em sequência 
 Parai<- 1 até 100 Faça
 Escreva(Nome[i])
 Escreva(Ender[i])
 Escreva(Telefone[i])
 Escreva(EMail[i])
 FimPara
FimAlgoritmo
Análise do algoritmo exemplo 
Primeira Análise 
O algoritmo acima contém muitas falhas, mas para uma visão inicial, serve ao propósito.
Segunda Análise 
Note que a mesma estrutura "PARA" foi utilizada para todos os processos, a saber: Inicialização dos 
Copyright (C) 1999-2000 Linux Solutions. 28
vetores, obtenção dos dados e associação dos mesmos à uma mesma pessoa e impressão dos dados.
Terceira análise 
O algoritmo, por utilizar a estrutura para, quando estiver no segundo laço (obtenção dos dados), não 
vai parar antes de ler todos os 100 registros. Isto pode ser muitocansativo e é desagradável pensar 
que estes dados serão perdidos assim que se chegar ao fim do algoritmo.
Quarta análise 
Vetores são estruturas interessantes e úteis, mas não para uma agenda. sendo que a melhor 
utilização desta estrutura seria, como forma, por exemplo, de guardar os últimos 100 registros lidos 
de um banco de dados na memória para acesso imediato. Desta maneira, o acesso a disco (que é 
lento), seria feito "uma vez somente", e os dados seriam acessados a partir da memória, que é muito 
mais eficiente e rápido.
 Conclusão 
Com o decorrer do curso, utilizaremos este mesmo algoritmo, melhorando-o a cada novo recurso 
aprendido. Ao final, teremos um algoritmo de agenda completo, com arquivamento em disco e tudo 
o que mais for de direito de uma agenda, inclusive o Programa codificado em pascal para DOS, 
utilizando a interface do Delphi para implementação.
A próxima aula será sobre matrizes.
Espero que tenham apreciado, Críticas e Sugestões são bem vindas!
Curso de Algoritmo - Aula XI 
Por: Jorge Luiz E. Sousa ( 28/02/2002 ) 
 
 Introdução 
Olá Comunidade!
Muito bem, estamos aqui novamente para nosso curso, e hoje falaremos sobre matrizes, que são 
vetores bidimensionais, isto é, vetores que possuem dois índices para acesso a uma posição.
Um exemplo básico seria uma planílha, onde temos linhas e colunas, para referenciar uma célula. 
Mas note que isto é só um exemplo. Matrizes para os programas são estruturas que armazenam 
dados homogêneos (do mesmo tipo), em "células" que são acessadas através de coordenadas 
numéricas. Assim, uma matriz de 5x15, teria 5 linhas e 15 colunas, sendo que para acessar um 
elemento de coordenada 5, 5 (como nos vetores, visto aula passada), deveria ser informado o nome 
da matriz e entre colchetes a coordenada que se quer.
Ex.: MatrizExemplo[5,5]
 Definição 
São estruturas bidimensionais e homogêneas capazes de armazenar um número determinado de 
variáveis e referenciá-las utilizando uma estrutura de dois índices.
De acordo com esta descrição, vejamos um exemplo:
Exemplo de um vetor de 2 (duas) linhas x 8 (oito) colunas
5 15 25 100 0 21 35 50
5 15 25 100 0 21 35 50
Exemplo de um vetor de 2 (duas) linhas x 8 (oito) colunas
Copyright (C) 1999-2000 Linux Solutions. 29
mailto:contato@olinux.com.br
'JLes' 'Exemplo' 'de' 'MATRIZES' '' '' '' ''
'JLes' 'Exemplo' 'de' 'MATRIZES' '' '' '' ''
Observe nas estruturas acima, que:
• No primeiro exemplo temos uma matriz numérica 
• No segundo temos uma matriz literal 
• Os dois exemplos estão totalmente preenchidos 
• O primeiro vetor foi inicializado com zeros 
• O segundo vetor foi inicializado com '' (espaços/vazio) 
• Ambos são homogêneos, isto é, seu conteúdo é do mesmo tipo (numérico e literal 
respectivamente) 
• Ambos são bidimencionais, dois índice serão necessários para referenciar as posições da 
matriz. 
Com a explicação acima, concluimos que matrizes são "variáveis com multiplas posições e duas 
dimensões (plano carteziano x e y)".
 Sintáxe 
A sintáxe de declaração de variáveis para vetores é:
Declare <NomeDaVariável> : Vetor [INI .. FIM, INI ..
FIM] TipoDoVetor
Onde:
• Declare é a palavra reservada para declaração de variáveis (sempre no início do Algoritmo) 
• <NomeDaVariável> : é o nome dado pelo usuário para a variável 
• Vetor é a palavra reservada para definir que uma variável é do tipo VETOR 
• [INI .. FIM, INI .. FIM] define a quantidade de linhas e colunas de um vetor bidimensional 
(matriz) 
• TipoDoVetor define o tipo de variável que o vetor vai armazenar. 
Exemplo:
Declare vetPessoa : vetor [1..50, 1..2] literal (matriz quadarada
50x50)
 Características 
Bidimensionais, homogêneos, um mesmo indice pode acessar valores em vários vetores distintos, 
desde que haja uma relação entre eles e sejam "do mesmo tamanho".
Ao tentar acessar uma posição inexistente, ocorrerá um erro no programa. Vetores (uni, bi e multi*) 
só existem na memória do computador e durante a execução de um programa ou 
"PROCEDIMENTO", não sendo estruturas para armazenamento permanente.
multi* existem linguagens de programação que permitem a criação de vetores multidimensionais. 
Vetores com 3 indices que seriam referênciados como matrizes sobrepostas, mas não é usual.
Obs.: PROCEDIMENTOS e FUNÇÕES serão matéria de aulas futuras
 Referência 
Para acessar uma determinada posição do vetor, será necessário informar o nome do vetor e a 
posição desejada.
Exemplo:
Copyright (C) 1999-2000 Linux Solutions. 30
NomeAtual <- vetPessoa[40,1]T
TelefoneAtual <- vetPessoa[40,2]
 Aplicação 
Estas estruturas são utilizadas para armazenar temporáriamente vários valores relacionados.
Estamos utilizando o mesmo exemplo anterior, somente mostrando a diferença de acesso entre 
vetores e matrizes (vetores bidimensionais), "SIMULANDO EM MEMÓRIA", o armazenamento 
de informações, para referência futura.
 Exemplo 
Como exemplo, vamos criar uma agenda virtual, que durante sua execução, armazenará: Nome, 
Telefone, endereço e e-mail de 100 pessoas.
 
Algoritmo
 
 Declare Pessoa:vetor[1..100, 1..4]literal
 
 Indice1, 
 Indice2: numérico inteiro
 
//Início do algoritmo 
 
 //Inicializando indice
 Indice<-1
 
 //Inicializando vetores
 Para i <-1 até 100 Faça
 Para j <-1 até 4 Faça
 Pessoa[i,j]<-''
 FimPara //Obtendo dados do usuário
 FimPara //Obtendo dados do usuário
 
 
 j=1;
 
 
 
 Para i <-1 até 100 Faça
 Escreva('Digite o nome:')
 Leia(Pessoa[i,j]) 
 Escreva('Digite o Endereco')
 Leia(Pessoa[i,j+1]) 
 Escreva('Digite o Telefone')
 Leia(Pessoa[i,j+2]) 
 Escreva('Digite o e-mail')
 Leia(Pessoa[i,j+3])
 FimPara 
 //Listando todos os registros em sequência 
 
 
 
 Para i <-1 até 100 Faça
 Para j <-1 até 4 Faça
 Escreva(Pessoa[i,j])
Copyright (C) 1999-2000 Linux Solutions. 31
 Escreva(Pessoa[i,j])
 Escreva(Pessoa[i,j])
 Escreva(Pessoa[i,j])
 FimPara
 FimPara
FimAlgoritmo
Análise do algoritmo exemplo 
Primeira Análise 
Já está melhorando, observe que na aula anterior sobre vetores unidimensionais, precisamos criar 
uma estrutura para cada informação a respeito de uma pessoa, a saber: nome, endereço, e-mail e 
telefone. Com uma matriz, podemos simular um arquivo em memória. Sendo necessária somente 
uma matriz, para armazenar todos estes dados.
Análogamente à um arquivo, as linhas da matriz seriam os registros, e as células da matriz seriam 
os campos.
Observe que com este novo conceito a programação se torna mais abstrata, pois você como 
programador deve saber em sua mente, que coluna armazeana a informação de que você precisa.
Segunda Análise 
Note que a mesma estrutura "PARA" foi utilizada para todos os processos, com uma diferença 
quando da leitura dos "registros" (linhas da matriz). No "PARA " de leitura, a variável "j" foi 
inicializada antes de entrar no laço e utilizada para referenciar as colunas da linha que armazenarão 
cada informação.
NOTE QUE, o j não é incrementado em valor, dentro da estrutura, isto é seu valor não aumenta, é 
sempre 1. O que fizemos foi "incrementálo" como índice, sem que ele recebece seu próprio valor 
incrementado, assim, para cada linha ele continuará sendo "1", mas em cada leitura referenciará 
uma coluna diferente.
Este conceito foi implementado aqui, para lhe dar uma noção de como utilizar os indices, existem 
várias outras formas de se fazer isto.
Terceira análise 
O algoritmo, por utilizar a estrutura para, quando estiver no segundo laço (obtenção dos dados), não 
vai parar antes de ler todos os 100 registros, que agora equivalem a 100 x 4, isto é 400 leituras. Isto 
pode ser muito cansativo e é desagradável pensar que estes dados serão perdidos assim que se 
chegar ao fim do algoritmo.Quarta análise 
Vetores são estruturas interessantes e úteis, mas não para uma agenda. sendo que a melhor 
utilização desta estrutura seria, como forma, por exemplo, de guardar os últimos 100 registros lidos 
de um banco de dados na memória para acesso imediato. Desta maneira, o acesso a disco (que é 
lento), seria feito "uma vez somente", e os dados seriam acessados a partir da memória, que é muito 
mais eficiente e rápido.
 Conclusão 
Com o decorrer do curso, utilizaremos este mesmo algoritmo, melhorando-o a cada novo recurso 
aprendido. Ao final, teremos um algoritmo de agenda completo, com arquivamento em disco e tudo 
o que mais for de direito de uma agenda, inclusive o Programa codificado em pascal para DOS, 
utilizando a interface do Delphi para implementação.
Copyright (C) 1999-2000 Linux Solutions. 32
Espero que tenham apreciado, Críticas e Sugestões são bem vindas.
Copyright (C) 1999-2000 Linux Solutions. 33