Técnicas de desenvolvimento da Lógica de Programação.pdf

Prévia do material em texto

FLP (Fundamentos de Introdução a 
Informática)
Técnicas de
Desenvolvimento da Lógica
2
Sumário
Sumário.................................................................................................................................................................3
Introdução.............................................................................................................................................................3
As dificuldades de programar...............................................................................................................4
A metodologia de aprendizagem..........................................................................................................5
Variáveis x Dados.................................................................................................................................................6
Uso das Variáveis no Algoritmo............................................................................................................6
Escolhendo o TIPO do Identificador da Variável..................................................................................7
Tipo inteiro............................................................................................................................7
Tipo real................................................................................................................................7
Tipo Literal............................................................................................................................7
Tipo Lógico............................................................................................................................8
Tamanho das Variáveis........................................................................................................................8
Declaração de Variáveis.......................................................................................................................8
Comando DECLARE............................................................................................................8
Operadores...........................................................................................................................................9
Operadores Numéricos.........................................................................................................9
Operadores Relacionais ......................................................................................................9
Operadores Lógicos............................................................................................................10
Entendendo Representações de Sintaxes.........................................................................................................10
Atribuição de Valores a Variáveis.......................................................................................................11
Estruturação do Algoritmo...................................................................................................................................11
Entrada e Saída de Dados..................................................................................................................12
Comando LEIA....................................................................................................................12
Comando ESCREVA (lista informações no vídeo).............................................................12
Manipulaçao de valores......................................................................................................................................13
Conceitos Fundamentais....................................................................................................................................14
Contador x Acumulador......................................................................................................................14
Percentuais.........................................................................................................................................14
Maior Valor..........................................................................................................................................15
Menor Valor.........................................................................................................................................15
Estruturas Condicionais......................................................................................................................................16
Estrutura Condicional SE (Símples)...................................................................................................16
Estrutura Condicional SE (Composta)................................................................................................17
Estrutura Condicional SE (Encadeada)..............................................................................................17
Exercícios de Aprendizagem..............................................................................................................18
Estruturas de Repetição......................................................................................................................................21
Comando ENQUANTO.......................................................................................................................21
Comando PARA..................................................................................................................................22
Exercícios de Aprendizagem..............................................................................................23
Técnicas de Algoritmização................................................................................................................................24
Dicas sobre Resolução de Algoritmos................................................................................................24
Técnica para extrair os dados de um enunciado................................................................................24
Desafios Resolvidos............................................................................................................................................26
Introdução
3
rogramar um computador não é uma tarefa tão difícil. Difícil é programar as 
nossas cabeças.
O computador, na realidade, é uma réplica bastante simplificada de nossa 
mente, com apenas uma diferença essencial: a AUTO-PROGRAMAÇÃO.P
Ao longo de nossas vidas, aprendemos coisas a partir de alguns elementos fundamentais 
como cores, símbolos, sons, cheiros, e sentimentos. Esses elementos vão se 
combinando através de um processo conhecido como aprendizado. 
O processo de aprendizado nada mais é do que uma auto-programação de nossas 
mentes. “Alguém” diz para nosso cérebro o que ele tem que fazer ao se deparar com 
uma situação específica, tal como: dobrar uma esquina, parar ao perceber o sinal 
vermelho, escovar os dentes ao acordar, em fim - tudo o que fazemos é regido por 
programas que, um dia, nós mesmos desenvolvemos.
Ora, se somos capazes de desenvolver programas para um aparelho tão complexo e 
genial como o nosso cérebro, por que não um simples computador?
Este é o nosso desafio. Desenvolver as técnicas necessárias para conseguirmos codificar 
programas em um computador digital.
As dificuldades de programar
Programar um computador, assim como a nossa mente, requer duas exigências básicas:
• Conhecer a linguagem na qual se vai programar;
• Estruturar o raciocínio de forma a saber combinar os comandos desta linguagem, dentro 
de uma seqüência lógica, ou seja, de modo a atingirmos o objetivo perseguido.
A linguagem de programação utilizada pelas nossas mentes é composta de comandos 
(olhe, escute, memorize, decida, sinta, ame, odeie...), elementos (cores, tipos de cheiros, 
notas musicais, símbolos sonoros, símbolos visuais...) e écapaz de reconhecer e utilizar 
os recursos disponíveis no organismo (olho, ouvido, cérebro, nariz, boca...), sem os 
quais torna-se impossível a execução de um programa.
A linguagem de programação utilizada pelos computadores é composta também por 
comandos (receba, escreva, some, multiplique...) e elementos (números, palavras e 
símbolos), e também é capaz de reconhecer e utilizar os recursos disponíveis no 
computador e periféricos (impressora, monitor de vídeo, mouse, teclado, memória...).
Ao aprendermos uma receita de bolo, colocamos uma porção de comandos em nossa 
mente. Estes comandos são gravados de uma forma analógica e, logo em seguida, 
consolidamos o processo de aprendizagem através da execução daquele programa.
Claro, da primeira vez que fazemos algo podemos cometer erros, que são 
automaticamente ajustados pela nossa mente para que, da próxima vez, não voltem a 
acontecer. 
Da mesma maneira, sempre que um programador desenvolve a primeira versão de seu 
programa, há uma fase de testes, quando os erros aparecem e são ajustados à 
necessidade do usuário. A esta fase damos o nome de DEPURAÇÃO.
4
A metodologia de aprendizagem
Como vemos, a programação de computadores é bastante semelhante a programação de 
nossas mentes, o que torna suas dificuldades e características também 
similares.Aplicaremos as técnicas e recursos existentes aos elementos inerentes a 
computadores, interagindo com variáveis de memória, comandos de entrada e saída de 
dados, além de comandos que controlarão a repetição de blocos de comandos. 
Estruturas como vetores, matrizes, listas, filas, pilhas, árvores, entre outras, serão 
ministrados em outras disciplinas.
Para representar as ações (comandos), utilizaremos uma linguagem não comercial - o 
pseudocódigo, conhecido como Algoritmo. Uma linguagem que lhe poupe de comandos 
em inglês, e que não apresente grandes sofisticações. A linguagem de programação 
experimental que utilizaremos para exercitar a lógica de programação será na nossa 
própria linguagem: a língua portuguesa.
Para facilitar o processo de aprendizagem, os temas que abordaremos poderão ser 
convertidos para a linguagem Pascal, que tem em suas origens, o objetivo de ensinar os 
alunos a interagirem com o computador de forma prática. 
5
Variáveis x Dados
Variável é o local de memória onde serão armazenados os dados de forma 
temporária. Em nossos algoritmos não nos preocuparemos com o endereço real dessas 
variáveis, pois a maioria das linguagens de programação tornam estes endereços 
transparentes ao programador.
Para exemplificarmos a diferença entre dados 
(constantes) e variáveis, bem como entender 
melhor o endereçamento de variáveis, podemos 
citar o exemplo de uma estante de prateleiras, 
onde estão guardados livros ou quaisquer outros 
objetos (veja figura).
Os livros e objetos podem ser chamados de 
dados, conteúdo das variáveis. Para nos referenciarmos à variável é necessário darmos 
um nome à mesma, pois não trabalharemos com endereço de memória propriamente 
dito, e sim com identificadores.
É aconselhável que o nome da variável expresse o que vai ser armazenado dentro dela, 
p.e. nomeAluno, quantidade_alunos.
As variáveis podem ainda ser simples ou compostas. As variáveis simples são aquelas 
que recebem um único dado por vez, enquanto que as compostas podem armazenar 
vários dados de uma só vez, porém, esta última não é objeto de nossa apostila. 
Quando declaramos uma variável, temos que associar a ela algumas características:
• NOME ou IDENTIFICADOR
• TIPO do dado
Como dissemos anteriormente, o endereço físico da variável não precisa ser declarado, a 
menos que estejamos programando em alguma linguagem de baixo nível, como o 
ASSEMBLER. As linguagens de alto nível procuram espaços livres na memória do 
computador para associarem bytes à variável declarada. 
Uso das Variáveis no Algoritmo
O nome a ser associado à variável (ex.: X, Y, KTI34), não é importante para o 
computador, pois este servirá apenas como uma mera referência. Entretanto para outros 
programadores que possam vir a analisar os seus programas, ou até para você mesmo 
após algum tempo, é necessário que esses nomes sejam expressivos, simples e 
objetivos.
Vejamos agora alguns exemplos de identificadores:
SALARIO Um bom nome para variável que irá armazenar um valor salarial;
CONT Um bom nome para variável que irá registrar uma contagem;
TOTAL Um bom nome para variáveis acumuladoras de somas;
DATANASC Um bom nome para variáveis usadas para armazenar uma data de 
nascimento.
Devemos evitar nomes do tipo: X, K, C1, ABC, etc... a menos que eles expressem 
algo real.
Nomes de variável, na maioria das linguagens, NÃO devem:
6
Iniciar por números: 1C2, 9ANOS, 100, 4CANTOS, etc...
Ser descontínuos: DATA NASC, FONE COMERC, etc...
Outros requisitos podem aparecer dependendo de cada linguagem. O COBOL por 
exemplo permite nomes longos para variáveis, já o CLIPPER, com apenas 10 bytes. O 
COBOL permite separadores como hífens, barras, entre outros. Linguagens derivadas 
do DBASE permitem apenas o UnderLine (Nome_Aluno) como caracter separador. A 
maioria das linguagens apresenta certas restrições à livre escolha dos nomes das 
variáveis. A mais evidente é a impossibilidade da utilização de palavras reservadas da 
própria linguagem. Por exemplo, a palavra MOVE representa um comando para o 
COBOL. Não é possível utilizarmos este nome como identificador de qualquer variável 
nesta linguagem. Já para o CLIPPER, o MOVE pode ser um identificador. 
Outras vezes, a linguagem traz consigo algumas variáveis reservadas. Tratam-se de 
algumas variáveis que são automaticamente declaradas pela linguagem. Normalmente 
elas registram a data e a hora do sistema operacional, ou algumas informações internas 
como códigos de periféricos, endereços de memória para buffers, etc.
Escolhendo o TIPO do Identificador da Variável
O segundo argumento presente na declaração de uma variável é o seu tipo. O tipo de 
uma variável define que tipos de dados poderão ser armazenados nela. A declaração 
(definição das variáveis) será feita no início do algoritmo.
Tipo inteiro
Sinaliza que o conteúdo será de números e que não terá a parte decimal em sua 
composição.
Ex.: 1200; -12; 0; etc
Tipo real
Sinaliza que o conteúdo será de números e que é permitida a digitação da parte decimal.
Ex.: 1200,00; -12,88; 0; etc
Tipo Literal
Sinaliza que o conteúdo aqui armazenado será toda a rede de caracteres alfanuméricos e os 
ditos caracteres especiais. Os conteúdos destas variáveis SEMPRE serão demonstrados entre 
aspas (simples ou dupla, dependendo da linguagem);
“São variáveis que aceitam conteúdos de qualquer natureza, portanto: números, letras e 
símbolos em geral, não podendo estes números ser utilizados para operações 
aritméticas”.
Ex.: "MARIA JOSE"; "Recife"; "123"; "NOMES"
Observações: 
a) Não confundir os valores numéricos com os literais ou entre os literais. Vejamos 
os casos a seguir.
Caso 1. 
7
42 (inteiro) é diferente de “42” (literal) – Os tipos são diferentes, logo, seus 
valores em memórias são diferentes;
Caso 2. 
 “01”(literal) é diferente de “1” (literal) – Os tipos são iguais, mas a 
representação em memória é diferente.
Tipo Lógico
Este tipo de variável não permite o registro de dados numéricos ou literais. Uma 
variável lógica só armazena um entre dois valores: VERDADEIRO ou FALSO. 
Em nossa disciplina, não nos ateremos ao como exatamente, o computador registra esta 
informação na memória. Pode ser por bytes zerados e não zerados, pelas letras V ou F, 
ou por um outro mecanismo qualquer. O que nos interessa de fato é que este tipo de 
variável não registra outro tipo de informação exceto Verdadeiro ou Falso.
Para efeito de representação, diremos que o conteúdode uma variável lógica será 
representado pelas letras V e F, representando respectivamente, Verdadeiro e Falso:
Tamanho das Variáveis
Quando declaramos uma variável não precisamos delimitar o byte inicial e final que 
esta irá ocupar na memória do computador, entretanto é imprescindível entendermos 
que elas ocupam um espaço na memória e que os tipos de dados trazem definições sobre 
as variáveis, inclusive o que pode armazenar e os seus limites.
Outros tipos de variáveis também são tratados por novas linguagens, tais como: HORA, 
MEMORANDO, OBJETO. Entretanto aqui só trataremos os tipos mencionados 
anteriormente, ou seja: Literal, Inteiro, Real e Lógico..
Declaração de Variáveis
TODAS as variáveis que o programa vier a utilizar têm que existir antes de serem 
referenciadas. Por esse motivo, necessitamos declarar estas. Como fazer isso? Através 
do comando DECLARE.
Comando DECLARE
DECLARE <Nome da variável>[,<Nome da variável>]: <tipo>;
<Nome da variável> Nome ou identificador da variável
<Tipo> Tipo da variável definida: Literal, Inteiro, Real e Lógico.
Exemplos: DECLARE NOME : Literal;
 DECLARE IDADE : Inteiro;
 DECLARE ALTURA: Real;
 DECLARE DEPENDENTE: LOGICO;
Podemos declarar diversas variáveis utilizando apenas um comando DECLARE.
Exemplos: DECLARE NOME : Literal;
 IDADE : Inteiro;
 ALTURA: Real;
 DEPENDENTE, LOGICO;
Ou ainda, em uma mesma linha, desde que sejam do mesmo tipo de dados.
Exemplo:
8
 DECLARE IDADE, CONTADOR:inteiro; (obs.: tipo e tamanho iguais}
Observação: As vezes substituímos o comando Declare por Var ou Defina, dependendo da 
linguagem que estamos querendo nos aproximar. Outros comandos 
poderão sofrer variações. Cabendo ao professor da disciplina fazer os 
ajustes baseados no direcionamento que queira dar à disciplina.
Operadores
Podemos atribuir a uma variável o resultado de uma expressão numérica. Atribui é uma 
ação que as linguagens possuem e que representa o ato de preencher o espaço da 
variável com um conteúdo, conforme o tipo de dado (veremos mais detalhadamente em 
tópico específico). Entendemos por expressão numérica um conjunto de operações 
aritméticas combinadas entre operandos e operadores. Mas além das expressões 
numéricas, existem expressões que exigem tratamentos particulares, como veremos a 
seguir.
Operadores Numéricos
São elementos (símbolos) utilizados para representar uma operação de cunho aritmético.
+ indica SOMA
- indica SUBTRAÇÃO
* indica MULTIPLICAÇÃO
/ indica DIVISÃO
Relembrando um pouco a matemática elementar, a ordem de execução de uma 
expressão aritmética segundo as prioridades de operações é:
Parêntesis: ( )
Multiplicação e Divisão: * , /
Soma e Subtração: + , -
Obs.: Caso existam numa mesma sentença operadores de mesma ordem de prioridade, a 
execução será feita da esquerda para direita.
Operadores Relacionais 
São elementos (símbolos) utilizados para realizarmos operações de comparações, 
recebendo como resposta o valor verdadeiro ou falso.
 = igual a
Exemplos: 
Dados A = 3, B = 2, C = ‘Jose’ , D = ‘Jose’, NOME = ‘JOSE’
A > B Retorna V
C = D Retorna V
NOME = "JOSE" Retorna V (Está sendo comparado o conteúdo da variável NOME com a 
string “JOSE”.
NOME = D Retorna F (estão sendo comparados os conteúdos das variáveis NOME e 
D).
> maior que < menor que = igual a
>= maior ou igual a <= menor ou igual a <> diferente
9
A := 2 * 6 / 3
 12
 4
Os operadores relacionais incidem sobre dados e variáveis numéricas e caracteres. 
Assim sendo, podemos comparar não apenas números, mas também palavras. Neste 
sentido, a comparação respeitará a ordem alfabética das iniciais de cada uma. 
Exemplos:
"MARIA" > "ANA" Retorna V
"MARIA" < "MARIO" Retorna V
observação: as comparações só podem ser feitas com elementos dos mesmos tipos.
Operadores Lógicos
Estes elementos são necessários quando você deseja realizar comparações entre resultados 
lógicos obtendo como resposta outro valor lógico. Estranho, não? Mas é exatamente isso que 
ocorre. Por exemplo: se você ler um anuncio sobre emprego que tenham as seguintes 
solicitações:
Precisa-se de pessoas do sexo feminino e com idade máxima 40 anos. O que você 
consegue extrair deste anuncio? A resposta seria: duas exigências, a saber, o SEXO da 
pessoa deve ser igual a feminino (“F”) e a IDADE deve ser menor ou igual a 40 anos. Logo, 
estamos diante de duas sentenças, que, dependendo do que seja colocado como dados na 
comparação, poderemos ter a possibilidade do resultado ser falso ou verdadeiro. Se o SEXO 
for igual a “M” (masculino), a primeira sentença será falsa. Para você poder ocupar a vaga 
oferecida, necessário que sejas do sexo feminino e sua idade esteja na faixa etária solicitada. 
Para o programa, o raciocínio é exatamente igual. 
Para que gerenciarmos esta etapa da lógica, utilizaremos os operadores a seguir:
Operador Detalhamento Prioridade 
de execução
OU
(Opcionalidade)
A sentença que contiver este operador será verdadeira se pelo 
menos uma das expressões nela contida retornar valor verdadeiro.
3º
E
(Simultaneidade)
A sentença que contiver este operador será verdadeira se as 
expressões nela contida resultarem valores verdadeiros.
2º
NÃO
(Negação)
Quando queremos inverter (negar) o resultado de uma condição ou 
expressão lógica.
1º
Observação: caso sejam colocados os parênteses na sentença, a prioridade de execução será alterada 
iniciando-se pelos elementos contidos dentro destes. Caso exista mais de uma sentença 
nesta condição, observar-se-á, além do exposto acima, a execução dos comandos da 
esquerda para a direita da expressão.
Vejamos a “TABELA VERDADE” a seguir para entendermos melhor.
 E OU
V V V V V V
F V F F V V
V F F V F V
F F F F F F
Exemplos: 
X = 90 E Z = 100 
A >= 67 OU A <= 200
NOME <> "ANA" E NAO (NOME = "MARIA")
(NOME <> "ANA") E (NAO (NOME="MARIA") OU (NOME="PEDRO"))
Entendendo Representações de Sintaxes
Agora que você já aprendeu o primeiro comando de nossa linguagem algorítmica, é 
importante aprender a forma sintética de se representar um comando. Note que, ao 
enunciarmos o comando DECLARE, nós utilizamos algumas nomenclaturas e 
10
simbologias que você, certamente, encontrará em qualquer livro sobre quaisquer 
linguagens. 
Assim, vamos elucidar algumas delas:
Repetindo o comando,
DECLARE <Nome da variável>[,<Nome da variável>]: <tipo>;
< > Delimita o espaço reservado para inserirmos um parâmetro do comando. A 
maioria dos comandos das linguagens possui parâmetros.
[ ] Delimita o espaço reservado para inserirmos um parâmetro opcional do 
comando, ou seja, tudo o que vier entre colchetes nem sempre precisará 
ser especificado no comando.
Ex: DECLARE SOMA : Inteiro;
DECLARE SOMA, QUANTIDADE_ALUNOS:inteiro;
Observe ainda que os colchetes [ ] e os delimitadores maior/menor < > podem 
acumular-se entre si, ou seja, dentro de um grupo de parâmetros opcionais [ ], 
poderemos ter outros [ [..] ], dependendo apenas da característica do comando.
Atribuição de Valores a Variáveis
Até agora, vimos conceitos e exemplos de variáveis. Agora vamos aprender a utilizá-las 
em algoritmos.
Representaremos o comando de atribuição pela combinação de dois símbolos do 
teclado, que são dois pontos e o sinal de igual, sem espaços entre eles(:=). Este símbolo 
representará a atribuição de um dado a uma variável. 
<variável> := <dado a ser armazenado>
Exemplos: 
NOME := "JOÃO"; Dados Literal têm que vir entreaspas
IDADE := 25; Dados Inteiros não precisam de aspas
ALTURA := 1,67; Dados tipo Real, possuem uma vírgula como delimitador entre a parte 
decimal e a parte inteira (linguagens comerciais adotam o ponto).
DEPENDE := F; Dados LOGICO devem vir entre pontos
Também podemos atribuir, a uma variável, o valor de outra:
Exemplo: ALTURA := IDADE; a variável ALTURA recebe o valor de IDADE
Também podemos atribuir o resultado de uma expressão numérica, ou de outro tipo, a 
uma variável:
SOMA := QUOEF * (VALOR + 10) / DIVISOR;
Estruturação do Algoritmo
Existem alguns formatos para organizar um algoritmo, porém adotaremos o mais global, 
facilitando assim o aprendizado. Vejamos a seguir:
Algoritmo <nome do programa>;
Declare {Local para declaração das variáveis}
Início
{Local para inicialização das variáveis / mensagens montando a 
tela}
{Local para receber dados, processar dados e dar saída nos dados 
/ mensagens}
Fim
11
Entrada e Saída de Dados
Até aqui nós vimos como atribuir um valor a uma variável dentro de um programa. 
Mas este valor foi atribuído pelo próprio programa, não é?
Mas como fazer com que um programa, em um dado momento, receba um valor 
digitado pelo usuário? 
Como receber este dado através do teclado?
Como exibir o resultado de uma operação qualquer no monitor?
Existem nas linguagens de programação, comandos de entrada e saída de dados. No 
caso do algoritmo, estes comandos são os seguintes: Leia (entrada), Escreva (saída - 
tela).
Comando LEIA
Leia <variável>;
 Ou
Leia (<variável>);
<variável> - Variável que receberá os dados digitados pelo usuário.
Algoritmo
 Declare wnome:literal;
 Widade:Inteiro;
Inicio
 Leia wnome;
 Leia widade;
 <seqüência de comandos>;
Fim
A execução do comando LEIA provoca uma pausa na execução do programa. O 
programa fica em estado de espera, aguardando a digitação de algo que deva ser 
atribuído às variáveis especificadas na sintaxe do comando. É bom deixar claro que o 
LEIA, permite um preenchimento por vez. Se você desejar digitar várias 
informações referente a mesma variável, terá que utilizar uma estrutura de 
repetição (veremos mais adiante) e fazer com que o fluxo do programa passe pelo 
mesmo local onde o LEIA está posicionado
No exemplo acima, veja que o computador aguarda que o usuário digite dois valores 
distintos através do teclado. Estes dois valores irão ocupar, respectivamente, as 
variáveis NOME e IDADE.
Comando ESCREVA (lista informações no vídeo)
Escreva <string>[, <variável>][, <operação>]; 
 Ou
Escreva (<string>[, <variável>][, <operação>] ); 
Importante! Pelo menos um dos parâmetros deve ser informado quando da utilização deste 
comando.
<string> - Texto que está sendo encaminhado para tela.
<variável> - Qualquer variável utilizada no programa.
<operação> - Algum cálculo executado durante a exibição. Neste caso o processador 
realiza a operação de cálculo e depois libera o resultado para a exibição na 
tela.
Por dentro dos termos: string = conjunto de caracteres dentro de uma mesma variável.
Exemplo:
Algoritmo exemplo;
12
 Declare wnome:Literal;
INICIO
 ESCREVA “ NOME ..:”;
 LEIA wnome;
 ESCREVA "Seu nome é ", NOME;
FIM;
Quando estudamos lógica algorítmica não nos preocupamos em que coordenada ou 
posição a informação será exibida, mas sim com o fato de que deve ser dado o comando 
de saída dos dados.
No exemplo acima, teremos o conteúdo da variável NOME exibido no vídeo logo após 
a mensagem “Seu nome é ”, como mostra a ilustração abaixo.
NOME ..: Karla Silva
Seu nome é Karla Silva
Manipulaçao de valores
1) Dados 2 números digitados via teclado, faça um algoritmo capaz de exibir a soma deles no vídeo.
Algoritmo soma;
 Declare X:Inteiro;
Y:Inteiro;
SOMA:Inteiro;
Inicio
 Leia X;
 Leia y;
 SOMA := X + Y;
 Escreva SOMA;
Fim
Comentário Na solução acima, declaramos 3 variáveis de memória. X e Y foram criadas para 
armazenar os dois números que seriam digitados pelo usuário, e SOMA serviu para 
armazenar o resultado final da operação com essas duas variáveis. 
Mas quase sempre existe mais de uma maneira de solucionarmos um problema, não é? 
Com algoritmos não é diferente. Tente repensar o algoritmo acima utilizando apenas 2 
variáveis, em vez de 3 ! Como você pode observar, existem no mínimo duas soluções 
para este problema:
Algoritmo soma;
 Declare X:Inteiro;
Y:Inteiro;
SOMA:Inteiro;
Inicio
 Leia X;
 Leia y;
 X := X + Y;
 Escreva X;
Fim
Ou ainda:
Algoritmo soma;
 Declare X:Inteiro;
Y:Inteiro;
SOMA:Inteiro;
Inicio
 Leia X;
 Leia y;
 Y := X + Y;
 Escreva Y;
Fim
Qual a solução mais eficiente das duas?
Somente o fato de economizar uma variável torna qualquer uma dessas soluções bem 
mais eficiente que a primeira. O mesmo caso, sem precisar utilizar as variáveis para 
13
guardar o resultado, agiliza ainda mais o processamento. Mas este caso deve ser 
utilizado só quando você não precisar do valor resultante da operação.
Algoritmo soma;
 Declare X:Inteiro;
Y:Inteiro;
SOMA:Inteiro;
Inicio
 Leia X;
 Leia y;
 Escreva (X+Y);
Fim 
Conceitos Fundamentais
Contador x Acumulador
Estes nomes são dados a expressões que realizam adição de dados, porém, no primeiro 
caso, CONTADOR, é a expressão de adição que contabiliza valores fixos e 
predeterminados. No segundo caso, ACUMULADOR, é a expressão de adição que 
contabiliza valores variáveis.
Exemplo de Contador:
QtdFem := QtdFem + 1 (note que o valor adicionado a quantidade de femininos será 
sempre 1)
Exemplo de Acumulador:
SomaIdade := SomaIdade + Idade (note que o valor adicionado a soma das idades 
será variável)
Observação: na maioria das vezes, estes elementos são iniciados com o 0 (zero).
Percentuais
Encontramos algumas dificuldades quando tratamos estes temas. Aqui daremos algumas 
regras básica para que você se sinta a vontade no momento do cálculo.
Encontrando um valor percentual:
Veja esta continha simples
50 bolas 100 % (50 = Todo)
25 bolas x % (25 = Parte do Todo) 
Chegaremos a conclusão:
 X % = 25 x 100 / 50 
Estas informações nos levam a fórmula:
<perc> := < Parte do Todo> * 100 / < Todo>
Encontrando um valor final após aplicação do percentual:
<Novo valor> := <valor anterior> * 1,<valor do percentual>;
Ex.: adicionar 5 % sobre o salário e informar o valor do novo salário.
14
Nsal := Salario * 1,05;
Encontrando um valor adicionado percentualmente a uma variável:
<Novo valor> := <valor anterior> * 0,<valor do percentual>;
Ex.: adicionar 5 % sobre o salário e informar o valor acrescido ao salário.
Reajuste := Salario * 0,05;
Observação: quando você não sabe o valor a ser aplicado pois vem dentro de uma 
variável, não podemos fazer a aplicação literal do que explicamos neste tópico, mas 
precisamos traduzir em termos de programa este processo. Vamos fazer os 
mesmos exemplos anteriores, mas imaginando que o percentual virá em variáveis.
a) Nsal := Salario * (1 + perc / 100);
b) Nsal := Salario * (perc / 100);
Maior Valor
Existirão momentos em que você sentirá necessidade de identificar o maior elemento 
dentro de um conjunto de dados processados. Só existe uma forma de sabermos qual o 
maior valor: comparando as grandezas do conjunto. Para descobrirmos qual será o 
maior elemento, inicializaremos uma variável, que armazenará o maior valor do 
conjunto, com um valor bem pequeno para a situação, e, cada dado existente no 
conjunto iremos comparar com esta dita variável. Caso o valor encontrado seja superior, 
este será colocado como conteúdo da variável maior, já que este novo dado representa a 
maior grandeza neste momento do processamento.
Encontrandoo maior valor dentro de um conjunto:
Obs.: para entender melhor esse exemplo, é bom estar familiarizado com a estrutura de 
repetição comentada mais adiante.
Algoritmo maior; 
 Declare MAIOR_ID:Inteiro;
 Idade:Inteiro;
 Cont:Inteiro;
Inicio
 MAIOR_ID := 0;
 Para cont := 1 até 10 Faça
 Inicio
 Leia Idade;
 Se Idade > MAIOR_ID então
 Inicio
 MAIOR_ID := Idade;
 Fim
 Fim
 Escreva “A maior idade é “, MAIOR_ID;
Fim
Menor Valor
De igual forma iremos trabalhar para encontrar o elemento que possui o menor valor. 
Para tanto, iremos inicializar uma variável, que armazenará o menor valor do conjunto, 
com um valor bem alto adequado para a situação, e, cada dado existente no conjunto 
iremos comparar com esta dita variável. Caso o valor encontrado seja inferior, este será 
colocado como conteúdo da variável menor, já que este novo dado representa a menor 
grandeza neste momento do processamento.
Encontrando o menor valor dentro de um conjunto:
15
Algoritmo Menor; 
 Declare menor_ID:Inteiro;
 Idade:Inteiro;
 Cont:Inteiro;
Inicio
 menor_ID := 999;
 Para cont := 1 até 10 Faça
 Inicio
 Leia Idade;
 Se Idade < Menor_ID então
 Inicio
 menor_ID := Idade;
 Fim
 Fim
 Escreva “A menor idade é “, Menor_ID;
Fim
Estruturas Condicionais
Sabemos que as linhas de um programa estruturado são executadas de cima para baixo 
de forma seqüencial (na orientação ao objeto, apenas os métodos seguem este conceito). 
Mas freqüentemente precisamos mudar este curso natural de acordo com decisões a 
serem tomadas. 
Por exemplo, imagine se dentro de um conjunto de alunos você desejasse verificar a 
quantidade de homens. Só existiria uma forma para sabermos o resultado: fazendo uma 
pergunta sobre se os dados processados continham na variável SEXO o conteúdo igual a 
“M”. 
O comando que realiza esta “pergunta” é o SE, que possui três situações bem definidas 
dentro da programação: Estrutura Condicional Simples, Composta ou 
Encadeadas(Ninhos de SE’s).
Estrutura Condicional SE (Símples)
Se <condição> então
 inicio
<sequência de comandos>;
 Fim
<condição> - Expressão lógica qualquer. 
<sequência de comandos> São comandos que serão executados caso o resultado da 
expressão lógica seja verdadeira. Esses comandos devem ser escritos 
entre as delimitações da gerência do comando, ou seja, entre as palavras 
Início e fim.
Em tempo de execução, se a expressão lógica retornar verdadeiro então a seqüência de 
comandos será executada.
Para fixar esta idéia, tente depurar o seguinte algoritmo:
Algoritmo exemploSE1;
 DECLARE Idade, Numérico, 3
Nome, Caracter , 35
Sexo, Caracter , 1
Inicio
 Leia Nome;
 Leia Sexo;
 Leia Idade;
 Se Sexo = “M” então
 Inicio
 Escreva "A idade de ", Nome, “ é “, Idade;
 Fim
 Escreva "Fim da transacao";
Fim
16
Estrutura Condicional SE (Composta)
Se <condição> então
 Inicio 
 <sequência de comandos 1>;
 Fim
senão
 inicio 
 <sequência de comandos 2>;
 Fim
Onde:
<condição> - Expressão lógica qualquer. 
<sequência de comandos 1> São comandos quaisquer que serão executados caso o 
resultado da expressão lógica seja verdadeira (V). 
<sequência de comandos 2> São comandos quaisquer que serão executados caso o 
resultado da expressão lógica seja falsa (F)
Senão - Variação do comando, para atender o tratamento de informação que não foi 
contemplada na <condição>, por ser falso o resultado. Só deve ser 
utilizado para otimizar ou se precisar tratar a negativa da <condição>.
Para fixar esta idéia, tente depurar o seguinte algoritmo:
Algoritmo exemploSE2;
 DECLARE Idade: Inteiro;
Nome : Literal;
Sexo : Literal;
Inicio
 Leia Nome;
 Leia Sexo;
 Leia Idade;
 Se Sexo = “M” então
 Inicio
 ESCREVA "A idade de ", Nome, “ é “, Idade, “Sexo Masculino”;
 Fim
 senão
 Inicio
 SE Sexo = “F” ENTAO
 Inicio
 ESCREVA "A idade de ", Nome, “ é “, Idade, “Sexo Feminino”;
 Fim
 Fim
 Escreva "Fim da transacao";
Fim
Estrutura Condicional SE (Encadeada)
Aqui vale comentar que esta estrutura não é algo preestabelecido, mas sim, uma 
estrutura formada de várias condições, separando informações e dando os tratamentos 
de acordo com a necessidade da questão. Abaixo segue um modelo hipotético de uma 
estrutura SE (Encadeada).
Se <condição 1> então
 Inicio
 <sequência de comandos 1>;
 Se <condição 2> então
 Inicio
 <sequência de comandos 2> ;
 Fim
 Fim
Senão
 Inicio
 Se <condição 3> então
 Inicio
 <sequência de comandos 3> ;
 Fim
 Senão
17
 Inicio
 <sequência de comandos 4> ;
 Fim
 <sequência de comandos 5>;
 Fim
Fim
Para exemplificarmos melhor, vejamos o exemplo: 
1) Receber dois números (Num1 e Num2). 
2) Realize a soma dos dois valores.
2.1) Caso a soma seja maior que zero, mostrar na tela o valor da soma e a mensagem: 
“valor positivo”;
2.2) Caso contrário, verifique:
2.2.1) se o valor calculado é igual a zero. Se for, informar "valor igual a zero", senão;
2.2.2) informar, "valor negativo". (De qualquer maneira, em 2.2, exibir os dois números 
envolvidos na soma).
Algoritmo PositivoNegativo;
 Declare Num1:Inteiro;
Num2:Inteiro;
SOMA:Inteiro;
Inicio
 Leia Num1, Num2;
 SOMA:= Num1 + Num2;
 Se SOMA > 0 ENTAO
 Inicio
 Escreva SOMA, “Valor Positivo”;
 Fim
 Senão
 Inicio
 Escreva num1, num2;
 SE SOMA = 0 então
 Inicio
 Escreva "Valor Igual a Zero";
 Fim
 Senão
 Inicio
 Escreva "Valor Negativo";
 Fim
 Fim
Fim
Sobre esta solução, é importante salientar o seguinte:
• Note que a estética, apesar de não influenciar no resultado da execução do programa, é 
de extrema importância para o bom entendimento do mesmo. Perceba que todos os comandos 
subordinados ao primeiro SE ficam descolados na mesma margem. Apenas a cláusula 
SENAO fica na mesma margem do SE. O mesmo ocorre com o segundo SE e com todos os 
que vierem. A isto damos o nome de EDENTAÇÃO.
• Veja que o comando Escreva num1, num2 é executado independente da condição do 
segundo SE. É por isto que eles foram escritos após o SENÃO do primeiro SE.
Exercícios de Aprendizagem
1) Dados 2 números digitados via teclado, faça um algoritmo capaz de exibir no vídeo o maior deles.
Algoritmo maior;
 Declare X:Inteiro;
Y:Inteiro;
Inicio
 Leia X; 
 Leia Y; 
 Se X > Y Então
18
 Inicio
 Escreva X;
 Fim
 Senão
 Inicio
 Escreva Y;
 Fim
Fim
2) Dados 3 números distintos, digitados via teclado, faça um algoritmo capaz de exibir no vídeo o maior 
deles.
Algoritmo maior;
 Declare X:Inteiro;
Y:Inteiro;
Z:Inteiro;
Inicio
 Leia X; 
 Leia Y; 
 Leia Z; 
 Se (X > Y) E (X > Z) Então
 Inicio
 Escreva X;
 Fim
 Senão
 Inicio
 Se (Y > Z) E (Y > X) Então
 Inicio
 Escreva Y;
 Fim
 Senão
 Inicio
Escreva Z;
 Fim
 Fim
Fim
Comentário: Note que, para descobrirmos qual o maior entre três números, precisamos codificar 2 
comandos SE encadeados. Se fossem 4 variáveis, seriam 3 SE´s. 
3) Dados 2 números distintos digitados via teclado, faça um algoritmo capaz de exibi-los em ordem 
crescente.
Algoritmo Ordenacao;
 Declare A:Inteiro;
B:Inteiro;
Inicio
 Leia A; 
 Leia B; 
 SE A > B Então
 Inicio
 Escreva B, A;
 Fim 
 Senão
 Inicio
 Escreva A, B;
 Fim
Fim
Como você solucionaria este problema se tivéssemos de utilizar apenas um comando 
ESCREVA ?
A primeiraimagem que nos vem à mente é que seria impossível, tendo em vista que 
uma informação ao ser colocada em uma variável simples irá “ocupar” o lugar da 
informação já existente na outra variável. Mas em informática podemos utilizar todas as 
técnicas disponíveis para solucionarmos um problema, evitando soluções extensas ou 
complicadas. 
19
O recurso que vamos dispor nesse momento é a utilização de uma variável auxiliar. 
Variável auxiliar é aquela que nós utilizamos como apoio. Veja que para realizar a troca 
de dados exposta a seguir, só com esse recurso.
Algoritmo troca;
 Declare A:Inteiro;
B:Inteiro;
X:Inteiro;
Inicio
 Leia A; 
 Leia B; 
 Se A > B Então
 Inicio
 X := A;
 A := B;
 B := X;
 Fim
 Escreva A , B;
Fim
Comentário: Para economizarmos comandos ESCREVA, observe que invertemos os valores de A e B 
toda vez que a variável A fosse maior que B. Assim, independente dos valores de A e 
B, sempre exibiremos A e B nesta ordem. Para propiciar esta inversão utilizamos uma 
variável auxiliar X.
Se você não entendeu muito bem o porque da variável X ter sido utilizada no algoritmo 
acima, preste bastante atenção agora: 
Deseja-se trocar os valores de duas variáveis: A e B, por exemplo.
A B
10 15
Se fizermos simplesmente A := B, apagaremos o valor original de A colocando o 
conteúdo de B em seu lugar. Assim, as variáveis ficariam com o valor 15. Para 
viabilizar o processo da troca, temos que recorrer a uma variável auxiliar que conterá 
provisoriamente o valor de uma das variáveis a fim de devolvê-lo para a outra.
 
X 
 
10 15
10
20
1º passo
2º passo
3º passo
X:=A
A:=B
B:=X
Estruturas de Repetição
Algumas vezes, sentimos necessidade de escrevermos repetidamente o mesmo 
comando. Em alguns casos, a quantidade de vezes que temos de escrever é 
indeterminada ou depende de uma condição.
Existem algumas formas de definir as estruturas de repetições. Algumas lembram até 
esta ou aquela linguagem. Em nosso curso iremos no ater a duas estruturas, as quais 
podemos representar tranqüilamente em qualquer ambiente de programação.
As estruturas são: Enquanto e Para. Cada uma delas possui uma característica que lhe é 
peculiar. É normal ouvir a pergunta: “quando iremos utilizar esta ou aquela estrutura?”. 
A resposta é simples, pois depende da habilidade de cada um. Existem momentos que 
podemos resolver a mesma questão com todas as duas formas, mas existem momentos 
que não é possível. Por isso o segredo encontra-se no exercitar. 
Bem, vamos desmistificar estas estruturas.
Comando ENQUANTO
O comando ENQUANTO prende um trecho do programa a um laço (looping), ou seja, 
podemos determinar que um certo bloco de comandos seja executado repetidamente 
enquanto uma condição for verdadeira.
.
Enquanto <condição> Faça { se<condição> for verdadeira}
Inicio { serão executados os comando deste bloco}
 < comandos >;
Fim
Esta estrutura possui duas formas de aplicação dentro de uma lógica: 
a) Testando sempre uma condição de saída no próprio comando, ou;
b) Deixando este controle de saída da estrutura por conta de uma condição executada 
internamente.
1o. Caso
Só entra no laço de repetição, se e somente se, a condição for verdadeira. Para sair da 
repetição, a condição tem que ser satisfeita.
Enquanto <condição> Faça
 início
 < comandos > ;
 Fim
2o. Caso
Entra no laço independente da condição, mas para sair, a condição 2 tem que ser verdadeira. 
Caso a condição não seja satisfeita, dizemos que o programa “entrou em loop”.
Enquanto <condição> Faça
início
 Se < condição 2 > Então
 Início
 sair
 Fim
 < comandos > ;
Fim;
21
Comando PARA
O comando PARA executa um bloco de comandos, gerenciando esta execução em cima 
de uma contagem. Enquanto ela não for satisfeita, ou seja, o valor final não for 
ultrapassado, os comandos do bloco serão repetidos a cada nova verificação da 
condição e obtenção de resultado falso;
Para <var> := <valor_inicial> até <Valor_final> incr[+/- <valor>] 
Faça
Inicio
 < comandos > ;
Fim
Se você utilizar este comando, irá poupar a inicialização da variável, pois esta 
assumirá como valor inicial o declarado como <valor_inicial>; não precisará contar a 
quantidade de vezes que o laço foi executado, pois esta estrutura tem como uma de 
suas características, o adicionar um determinado valor a variável <var> baseado no 
valor utilizado como incremento (+) ou decremento (-) utilizado no parâmetro incr[...] 
estabelecendo uma contagem até que o valor declarado como <valor_final> seja 
alcançado e realizando a última execução dos comandos existentes entre o Inicio e o 
Fim. Se o parâmetro Incr [ +/- valor] for omitido, o programa assumirá por Default 
sempre o incremento de + 1.
Vamos utilizar um exemplo para esclarecer cada uma dessas instruções dentro de suas 
respectivas estruturas de repetições. Digamos que temos de fazer o computador escrever 
o somatório de 5 idades informadas na tela. Usaremos os comandos aprendidos até 
agora.
♦ Com a estrutura ENQUANTO
Algoritmo
 Declare widade:Inteiro;
 Wcont:Inteiro;
 Wsomaid:Inteiro;
Inicio
 Wcont := 0;
 Wsomaid := 0;
 Leia widade; 
 Enquanto wcont < 5 Faça
 Inicio 
 Wcont := wcont + 1;
 Wsomaid := wsomaid + widade;
 Leia widade;
 Fim
 Escreva “O total das idades é “, wsomaid;
Fim
♦ Com a estrutura PARA
Algoritmo
 Declare widade:Inteiro;
 Wcont:Inteiro;
 Wsomaid:Inteiro;
Inicio
 Wsomaid := 0;
 Para wcont := 1 até 5 Faça
 Inicio 
 Leia widade;
 Wsomaid := wsomaid + widade;
 Fim
 Escreva “O total das idades é “, wsomaid;
22
Fim
Exercícios de Aprendizagem
1) Elabore um algoritmo capaz de exibir todos os números inteiros, desde o 1 até o 10.
Algoritmo exemplo1;
 Declare NUMERO:Inteiro;
Inicio
 NUMERO := 1;
 Enquanto NUMERO <= 10 Faça
 Inicio
 Escreva NUMERO;
 NUMERO := NUMERO + 1;
 Fim
Fim
Comentário: Note que, utilizamos uma variável numérica chamada NUMERO que recebeu, 
inicialmente, o valor 1, e daí em diante foi ciclicamente incrementada de 1 
(NUMERO:=NUMERO+1) até que a condição imposta pelo ENQUANTO tornasse 
falsa. 
2) Elabore um algoritmo capaz de receber um número e, em seguida, listar todos os números de 1 até 
ele.
Algoritmo exemplo2;
 Declare NUMERO:Inteiro;
LIMITE:Inteiro;
Inicio
 Leia LIMITE;
 NUMERO:=1
 ENQUANTO NUMERO <= LIMITE FAÇA
 Inicio
 Escreva NUMERO;
 NUMERO := NUMERO + 1;
 Fim
Fim
Comentário: Este programa é similar ao anterior. A única sofisticação implementada foi a 
flexibilização do limite. Isto tornou o algoritmo mais genérico, servindo para listar a 
seqüência de qualquer número, e não apenas a do 10. Para alcançar esta sofisticação, 
foi necessário o uso da variável LIMITE que de fato limitou o laço do Enquanto ao seu 
conteúdo, conteúdo este que fora recebido logo no início da execução do programa, 
com o comando Leia LIMITE.
3) Sofisticando ainda mais o programa da 3ª questão, vamos fazer com que, além de listar todos os 
números de 1 até um determinado número digitado via teclado, ele mostre a soma de todos esses 
números no final da listagem.
Algoritmo exemplo2;
 Declare NUMERO :Inteiro;
LIMITE :Inteiro;
 SOMA :Inteiro; 
Inicio
 Leia LIMITE;
 NUMERO := 1;
 SOMA := 0;
 Enquanto NUMERO <= LIMITE Faça
 Inicio
 Escreva NUMERO; 
 SOMA := SOMA + NUMERO;
 NUMERO := NUMERO + 1;
 Fim
 Escreva SOMA;
Fim
Comentário: Perceba que, para acumular os valores parciais assumidos pela variável NUMERO, 
precisamos lançar mão de uma outravariável, a qual chamamos de SOMA. Assim, a 
cada ciclo do Enquanto acrescentamos ao valor de SOMA o novo valor de NUMERO 
(SOMA :=SOMA+NUMERO). 
Observe também que ao declaramos SOMA, na prática das linguagens, temos que tomar 
o cuidado dela ter capacidade de absorver o resultado da expressão. É fácil entender por 
que! Como SOMA será um “Acumulador” dos valores de NUMERO, ela sempre terá 
23
valores maiores que NUMERO, podendo seu montante, exceder a capacidade definida 
em NUMERO.
Técnicas de Algoritmização
Como dissemos anteriormente, não há qualquer receita de bolo para resolvermos um 
determinado problema através da algoritmização. Cada caso é um caso bem particular. 
Entretanto, alguns procedimentos sistemáticos podem auxiliar a elucidação de alguns 
problemas.
Dicas sobre Resolução de Algoritmos
Nunca dê um algoritmo por encerrado antes de testar todas as possibilidades 
condicionais. Só o teste garante a eficácia do programa. Teste sempre as situações 
extremas. Em algoritmos utilize diversas condições; teste ao menos uma situação que 
se enquadre em cada condição prevista pelo algoritmo.
Não tente decorar algoritmos. Cada caso é um caso, por mais que se assemelhem.
Há sempre uma forma melhor de fazer a mesma coisa. Após o ZERO ERRO, examine 
se o seu algoritmo é eficiente, isto é, se ele não usa variáveis demais, se ele é facilmente 
compreendido por uma terceira pessoa, se os nomes de variáveis são auto-expressivos, 
se o usuário não terá dificuldade em utilizá-lo, e se o computador não passará muito 
tempo para processá-lo (performance).
Não tente arquitetar, ainda que mentalmente, a solução de um problema sem antes 
entender perfeitamente o que pede no enunciado.
Não inicie a algoritmização sem ter claramente a solução arquitetada na sua cabeça.
Não deixe a curiosidade afetar a sua criatividade. Durante o desenvolvimento do seu 
algoritmo, não pesas orientação sobre o como fazer, sem antes ter chegado a algum 
resultado, ainda que errado.
Nunca desista de uma solução. Concluí-a. Chegue até o fim. Teste-a, e somente quando 
os testes sinalizarem a sua ineficácia, tente modificá-la ou refazê-la.
Técnica para extrair os dados de um enunciado
Quando nos deparamos com um enunciado pequeno, nos sentimos a vontade para 
resolve-lo pois os dados existentes neste são poucos. Porém, quando nos deparamos 
com um enunciado mais complexo, existe a tendência natural de pensarmos que é algo 
muito difícil de resolver. Mas, por incrível que pareça, o maior problema encontra-se 
em nosso lidar com o desafio e o encarar “friamente”. Justamente para melhor lhe 
capacitar a interpretar um texto é que estamos te dando esta dica. 
Todos os programas possuem 3 fases bem definidas e nestas, os seus dados necessários. 
Quando você tiver domínio sobre estas três fases, o algoritmo fluirá naturalmente.
24
Procure identificar a 1ª fase que é a da identificação dos dados de entrada; a 2ª fase e a 
que verifica os dados relativos ao processamento (condições de encerramento, cálculos, 
mensagens, etc; a 3ª fase é aquela aonde você descobre quais os dados de saída, ou seja, 
após o processamento, aonde irão ser colocado estes dados?
Vamos exemplificar. 
Elaborar um algoritmo que receba a matrícula, o nome e o salário de 50 
funcionários, imprimindo ao final, o somatório dos salários e a média salarial.
Vamos por em prática nosso aprendizado.
1ª fase (Dados de Entrada)
Será lido na tela a MATRICULA, NOME E SALÁRIO;
Leia Matricula;
Leia Nome;
Leia Salário;
2ª fase (Processamentos)
Serão processados dados de 50 funcionários. (isto implica dizer que 
precisaremos de uma variável para contabilizar e gerenciar este 
processo); O melhor comando para gerenciar um valor predefinido é 
o PARA.
Cada elemento que for processado, será acumulado o valor do salário 
(somatório dos salários).
AcumSal := AcumSal + Salário;
Observe que para cálculo da média salarial é necessário sabermos o 
somatório dos salários e dividir o mesmo pela quantidade de pessoas 
que os possuem. Como sabemos que existirão 50 pessoas, para 
encontrar a média é super simples.
Calcular a média dos salários.
Media := AcumSal / 50;
3ª fase (Dados de Saída)
Dar saída no valor da média calculada.
Escreva “A média salarial é “, Media;
Montando o Algoritmo
Algoritmo exemplo;
 Declare AcumSal:Real;
 Cont :Inteiro;
 Salário: Real;
 Media :Real;
 Nome :Literal;
Inicio
 AcumSal := 0 
 Para cont := 1 até 50 faça
 Inicio
Leia Matricula;
Leia Nome;
25
Leia Salário;
 AcumSal := AcumSal + Salário;
 Fim
 Media := AcumSal / 50;
 Escreva “A média Salarial é “, Media;
Fim
Facílimo, não!
Com estas competências adquiridas nesse módulo, você deve exercitar e chegar num 
estágio de habilidade que lhe permitirá obter sucesso nas demais competências que 
serão ministradas a você em sala de aula.
Lembre-se: Os exercícios que estão na apostila dedicada só para este fim, devem ser 
praticados e esgotados, pois isto o fará crescer em situações as mais adversas dentro do 
mundo da programação.
Sucesso a todos!
Desafios Resolvidos
 Como fazer para descobrir a quantidade de elementos iguais ao 
maior do conjunto?
 Simples. Primeiro, você deverá encontrar o maior;
 Em segundo lugar, verificar quais os elementos são iguais a 
este maior encontrado.
 Aqui damos uma dica. Ao encontrar um elemento cujo valor 
seja superior àquele que representa o maior, temos duas tarefas 
a fazer. Uma é atribuir o valor do elemento para ser o maior e 
em seguida inicializar a quantidade com o numeral 1 (um). 
Mas porque 1 (um)? Pelo fato de que acabamos de encontrar 
um número maior e com certeza, nesse momento ele é único. 
Como fazer para contabilizar todos os iguais? A própria 
pergunta já é a resposta: cada vez que você encontrar algum 
valor igual ao maior, contabilizaremos mais um. 
 Vamos ao Exemplo? 
“Elaborar um algoritmo que receba idade de 50 pessoas e 
informe ao final, a maior delas e quantas pessoas a possuem.”
Algoritmo resolvidos1;
 Declare Ma_idade:Inteiro;
 Qt_maid :Inteiro;
 Cont :Inteiro;
 Widade :Inteiro;
Inicio
 Ma_idade := 0;
 Qt_maid := 0;
 Para cont := 1 até 50 faça
 Inicio
 Leia widade;
26
 Se widade > Ma_idade então
 Inicio
 Ma_idade := widade;
 Qt_maid := 1;
 Fim
 Senão
 Inicio
 Se widade = Ma_idade então
 Inicio
 Qt_maid := Qt_maid + 1;
 Fim
 Fim
 Fim
 Escreva “A maior idade é ..........................: “, Ma_idade;
 Escreva “Quantidade de pessoas com a maior idade...: “, Qt_maid;
Fim
 Como fazer para descobrir a quantidade de elementos iguais aos 
dois maiores elementos do conjunto?
 Agora ficou mais fácil. Precisamos atentar para um pequeno 
detalhe: quando encontrarmos um elemento que é superior ao 
primeiro, este último passa a ser o segundo maior. Para não 
perdermos o conteúdo original do maior, passaremos seus 
conteúdos para as respectivas variáveis e depois procederemos 
naturalmente colocando o elemento maior no seu referido 
lugar. Vejamos parte do código a seguir.
 Ma_idade2 := Ma_idade1;
 Qt_maid2 := Qt_maid1;
 Ma_idade1 := widade;
 Qt_maid1 := 1;
 Percebeu como é simples? Isso fazemos em todos os 
momentos em que queremos verificar o maior e o segundo 
maior. No demais é tomar cuidado com o segundo maior, pois 
apesar do valor as vezes, ser inferior ao primeiro, nada garante 
que ele o seja em relação ao segundo. Desta forma, precisamos 
fazer a comparação para termos certeza.
 Vamos ao Exemplo? 
“Elaborarum algoritmo que receba idade de 50 pessoas e 
informe ao final, as duas maiores idades e quantas pessoas as 
possuem.”
Algoritmo
 Declare Ma_idade1:Inteiro;
 Ma_idade2:Inteiro;
 Qt_maid1 :Inteiro;
 Qt_maid2 :Inteiro;
 Cont :Inteiro;
 Widade :Inteiro;
Inicio
 Ma_idade1 := 0;
 Ma_idade2 := 0;
 Qt_maid1 := 0;
 Qt_maid2 := 0;
 Para cont := 1 até 50 faça
 Inicio
 Leia widade;
 Se widade > Ma_idade1 então
 Inicio
 Ma_idade2 := Ma_idade1;
 Qt_maid2 := Qt_maid1;
 Ma_idade := widade;
27
 Qt_maid := 1;
 Fim
 Senão
 Inicio
 Se widade = Ma_idade1 então
 Inicio
 Qt_maid1 := Qt_maid1 + 1;
 Fim
 Senão 
 Inicio
 Se widade > Ma_idade2 então
 Inicio
 Ma_idade2 := widade;
 Qt_maid2 := 1;
 Fim
 Senão
 Inicio
 Se widade = Ma_idade2 então
 Inicio
 Qt_maid2 := Qt_maid2 + 1;
 Fim
 Fim
 Fim
 Fim
 Fim
 Escreva “A maior idade é ..........................: “, Ma_idade1;
 Escreva “Quant. de pessoas com a maior idade.......: “, Qt_maid1;
 Escreva “A segunda maior idade é ..................: “, Ma_idade2;
 Escreva “Quant. de pessoas com Seg. maior idade....: “, Qt_maid2;
Fim
28
29
	Sumário
	Introdução
	As dificuldades de programar
	A metodologia de aprendizagem
	Variáveis x Dados
	Uso das Variáveis no Algoritmo
	Escolhendo o TIPO do Identificador da Variável
	Tipo inteiro
	Tipo real
	Tipo Literal
	Tipo Lógico
	Tamanho das Variáveis
	Declaração de Variáveis
	Comando DECLARE
	Operadores
	Operadores Numéricos
	Operadores Relacionais
	Operadores Lógicos
	Entendendo Representações de Sintaxes
	Atribuição de Valores a Variáveis
	Estruturação do Algoritmo
	Entrada e Saída de Dados
	Comando LEIA
	Comando ESCREVA (lista informações no vídeo)
	Manipulaçao de valores
	Conceitos Fundamentais
	Contador x Acumulador
	Percentuais
	Maior Valor
	Menor Valor
	Estruturas Condicionais
	Estrutura Condicional SE (Símples)
	Estrutura Condicional SE (Composta)
	Estrutura Condicional SE (Encadeada)
	Exercícios de Aprendizagem
	Estruturas de Repetição
	Comando ENQUANTO
	Comando PARA
	Exercícios de Aprendizagem
	Técnicas de Algoritmização
	Dicas sobre Resolução de Algoritmos
	Técnica para extrair os dados de um enunciado
	Desafios Resolvidos