Algoritmos PC

2020
Programação de
Computadores
Usando Algoritmos como
preparação para a Linguagem C
Professor Erlon Pinheiro

Programação de Computadores I Prof. Erlon Pinheiro
UNIDADE I – Introdução à Lógica de Programação
O que vamos ver:
 Noções de Lógica
 Algoritmizando a Lógica
 Conceitos e Exemplos de Algoritmos
 Noções de Fluxos de Controle
 Algoritmos
 Exercícios de Fixação
1. Noções de Lógica
O uso corriqueiro da palavra lógica está normalmente relacionado à

coerência e racionalidade. Freqüentemente associa-se lógica apenas à
matemática, deixando-se de perceber sua aplicabilidade e relação com as
demais ciências.
Lógica é a “arte de bem pensar”, que é a “ciência das formas do

pensamento”. Visto que a forma mais complexa do pensamento é o
raciocínio, a lógica estuda a “correção do pensamento”.
Podemos também dizer que a lógica tem em vista a “ordem da razão”. Isto
dá entender que a nossa razão pode funcionar desordenadamente. Por isso a
lógica estuda e ensina a colocar “ordem no pensamento”. Exemplos:
Todo mamífero é um animal.

Todo cavalo é um mamífero.
Portanto, todo cavalo é um animal.
Espírito Santo é um estado do Brasil.

Capixabas são as pessoas nascidas no Espírito Santo
Logo, todos os capixabas são Brasileiros.
1/80
2. EXISTE LÓGICA NO DIA-A-DIA ?
Sempre que pensamos, a lógica ou a ilógica necessariamente nos

acompanha. Quando falamos ou escrevemos estamos expressando nosso
pensamento, logo, precisamos usar de lógica nessas atividades.
Exemplos:
A gaveta está fechada.
A caneta está dentro da gaveta.
Precisamos primeiro abrir a gaveta para depois pegar a caneta.
Anacleto é mais velho que Felisberto.

Felisberto é mais velho que Marivaldo.
Portanto, Anacleto é mais velho que Marivaldo.
3. MAS E A LÓGICA DE PROGRAMAÇÃO?
Significa o uso correto das leis de pensamento, da “ordem da razão” e de

processos de raciocínio e simbolização formais na programação de
computadores, objetivando racionalidade e o desenvolvimento de técnicas
que cooperam para a produção de soluções logicamente válidas e coerentes,
que resolvam com qualidade os problemas que se deseja programar.
O raciocínio é algo abstrato, intangível. Os seres humanos têm a capacidade

de expressá-los através da palavra falada ou escrita (idioma). Um mesmo
raciocínio pode ser expresso em qualquer um dos inúmeros idiomas
existentes, mas continuará representando o mesmo raciocínio, usando
apenas uma outra convenção.
Algo similar ocorre com a Lógica de Programação, que pode ser concebida
pela mente treinada e pode ser representada em qualquer uma das
inúmeras linguagens de programação existentes. Para escapar dessa torre
de Babel (detalhes das diversas linguagens de programação), e ao mesmo
tempo, representar mais fielmente o raciocínio da Lógica de Programação,
utilizamos os Algoritmos.
2/80
4. O QUE É UM ALGORITMO?
Um algoritmo pode ser definido como uma seqüência de passos que visam
atingir um objetivo bem definido.
Na medida em que precisamos especificar uma seqüência de passos,

precisamos utilizar ordem, ou seja, “pensar com ordem”, portanto
precisamos utilizar lógica.
Exemplo de Algoritmo: receita de bolo.
5. ALGORITMIZANDO A LÓGICA
Por que é Importante Construir um Algoritmo?
Um algoritmo tem por objetivo representar mais fielmente o raciocínio

envolvido na Lógica de Programação e, dessa forma, permite-nos abstrair de
uma série de detalhes computacionais, que podem ser acrescentados mais
tarde.
Outra importância da construção dos algoritmos é que, uma vez concebida

uma solução algorítmica para um problema, esta pode ser traduzida para
qualquer linguagem de programação. Costumamos denominar esse processo
de codificação.
Vamos a um Exemplo?
A troca de uma lâmpada.
Algoritmo 1.1
 pegar uma escada;
 posicionar a escada embaixo da lâmpada;
 buscar uma lâmpada nova;
 subir na escada;
 retirar a lâmpada velha;
 colocar a lâmpada nova.
Involuntariamente, já seguimos uma determinada seqüência de ações que

representadas nesse algoritmo, fazem com que ela seja seguida
naturalmente por qualquer pessoa, estabelecendo um padrão de
comportamento, pois qualquer pessoa agiria da mesma maneira.
A sequenciação é uma convenção com o objetivo de reger o fluxo de execução

do algoritmo, determinando qual a primeira ação a ser executada e qual
ação vem a seguir. Nesse caso, a seqüência é linear, de cima para baixo.
3/80
O algoritmo tem um objetivo bem definido: trocar uma lâmpada. Porém, e se

a lâmpada não estivesse queimada?
A execução das ações conduziria a uma troca, independentemente de a

lâmpada estar ou não queimada, porque não foi prevista essa possibilidade
em sua construção. A solução seria acrescentar um teste, a fim de verificar
se a lâmpada está ou não queimada.
Algoritmo 1.2
 acionar o interruptor;
 se a lâmpada não acender, então
Agora estamos ligando algumas ações à condição lâmpada não acender, ou

seja, se esta condição for verdadeira (lâmpada queimada) efetuaremos a
troca da lâmpada, seguindo as próximas ações:
Se a condição lâmpada não acender for falsa (a lâmpada está funcionando),
as ações relativas à troca da lâmpada não serão executadas, e a lâmpada
(que está em bom estado) não será trocada.
O algoritmo está correto, visto que atinge seu objetivo, porém, pode ser
melhorado, uma vez que buscamos uma escada e uma lâmpada sem saber se
serão necessárias.
Algoritmo 1.3
4/80
A solução apresentada está aparentemente adequada, porém, não prevê a

possibilidade de a lâmpada nova não funcionar e, portanto, não atingir o
objetivo nesta situação específica. Podemos fazer um refinamento, uma
melhoria no algoritmo, de tal modo que se troque a lâmpada diversas vezes,
se necessário, até que funcione.
Algoritmo 1.4
 retirar a lâmpada queimada;
 colocar outra lâmpada nova;
.
.
.
 Até quando ???
Notamos que o Algoritmo 1.4 não está terminado, faltou especificar até
quando será feito o teste da lâmpada. As ações cessarão quando
conseguirmos colocar uma lâmpada que acenda; caso contrário, ficaremos
testando indefinidamente.
5/80
Podemos, então, expressar uma repetição de ação sem repetir o texto que
representa a ação, assim como determinar um limite para tal repetição, com
o objetivo de garantir uma condição de parada, ou seja, que seja cessada a
atividade de testar a lâmpada nova quando esta já estiver acesa. Uma
solução seria:
Algoritmo 1.5
 enquanto a lâmpada não acender, faça
A condição lâmpada não acender permaneceu, e estabelecemos um fluxo

repetitivo que será finalizado assim que a condição de parada for falsa, ou
seja, assim que a lâmpada acender. Percebemos que o número de repetições
é indefinido, porém, é finito até alcançar o objetivo: trocar a lâmpada
queimada por uma que funcione.
6/80
Até agora estamos efetuando a troca de uma única lâmpada, na verdade,

estamos testando um soquete (acionado por um interruptor), trocando
tantas lâmpadas quantas forem necessárias para assegurar que o conjunto
funcione. O que faríamos se tivéssemos mais soquetes a testar, por exemplo,
10 soquetes ?
Algoritmo 1.6
 acionar o interruptor do primeiro soquete;
 acionar o interruptor do segundo soquete;
.
.
 acionar o interruptor do terceiro soquete;
.
.
 acionar o interruptor do décimo soquete;
.
.
7/80
Observamos que o Algoritmo 1.6 é apenas um conjunto de 10 repetições do

Algoritmo 1.5, uma vez para cada soquete, havendo a repetição de um
mesmo conjunto de ações por um número definido de vezes: 10. Como o
conjunto de ações tem uma forma repetida, poderíamos alterar o fluxo
seqüencial de execução de modo a fazer com que este voltasse a executar o
conjunto de ações relativas a um único soquete (Algoritmo 1.5) tantas vezes
quantas fossem desejadas. Uma solução para 10 soquetes seria:
Algoritmo 1.7
 ir até o interruptor do primeiro soquete.
 enquanto a quantidade de soquetes testados for menor ou
igual que dez, faça
 acionar o interruptor do soquete;
 ir até o interruptor do próximo soquete;
Quando a condição ( quantidade de soquetes testados for menor ou igual a

dez ) for verdadeira, as ações responsáveis pela troca ou não de um único
soquete serão executadas. caso a condição de parada seja falsa, ou seja,
todos os dez soquetes já tiverem sido trocados, nada mais será executado.
8/80
6. DE QUE MANEIRA REPRESENTAMOS O ALGORITMO?
Convém enfatizar mais uma vez que um algoritmo é uma linha de

raciocínio, que pode ser descrito de diversas maneiras, de forma gráfica ou
textual.
Os algoritmos representados até o momento estavam em forma textual,

usando português coloquial.
As formas gráficas são mais puras por serem mais fiéis ao raciocínio
original, substituindo um grande número de palavras por convenções de
desenhos. Para fins de ilustração mostraremos como ficaria o Algoritmo 1.7
representado graficamente em um fluxograma tradicional (algoritmo 1.8) e
em um Chapin (Algoritmo 1.9).
Algoritmo 1.8
9/80
Algoritmo 1.9
10/80
7. EXERCÍCIOS DE FIXAÇÃO
1 - Um homem precisa atravessar um rio com um barco que possui

capacidade de transportar apenas ele mesmo e mais uma de suas três
cargas, que são: um lobo, um bode e um maço de alfafas. O que o homem
deve fazer para conseguir atravessar o rio sem perder suas cargas?
informações:
um barco
um homem
um lobo
um bode
um maço de alfafa
ação:
atravessar o rio sem perder as cargas
resultado:
todas as cargas na outra margem do rio.
2 - Elabore um algoritmo que mova três discos de uma Torre de Hanói, que
consiste em três hastes (a-b-c), uma das quais serve de suporte para três
discos de tamanhos diferentes (1-2-3), os menores sobre os maiores. Pode-se
mover um disco de cada vez para qualquer haste, contanto que nunca seja
colocado um disco maior sobre um menor. O objetivo é transferir os três
discos para outra haste.
informações:
3 discos
3 hastes
ações:
movimentar um disco de cada vez de forma que fiquem ordenado
resultado:
discos transferidos e ordenados para outra haste
3. Três jesuítas e três canibais precisam atravessar um rio; para tal,

dispõem de um barco com capacidade para duas pessoas. Por medidas de
11/80
segurança não se permite que em alguma margem a quantidade de jesuítas

seja inferior à de canibais. Qual a seqüência de passos que permitiria a
travessia com segurança?
informações:
3 jesuítas
3 canibais
1 barco com capacidade para 2 pessoas
ações:
atravessar o rio com segurança
resultado:
3 jesuítas e 3 canibais na outra margem do rio (B)
12/80
UNIDADE II - Tópicos Preliminares
O que vamos ver:
 Tipos de Dados Básicos

 Constantes e Variáveis
1. TIPOS DE DADOS BÁSICOS
Informação é a matéria-prima que faz com que seja necessária a existência

dos computadores, pois eles são capazes de manipular e armazenar um
grande volume de dados com alto desempenho, liberando o homem para
outras tarefas onde o seu conhecimento é indispensável.
Aproximando-se da maneira pela qual o computador manipula as

informações, vamos dividi-las em três tipos primitivos, que serão os tipos
básicos que usaremos na construção de algoritmos.
 Numérico
Os dados numéricos dividem-se em dois grupos: inteiros e reais.
Os números inteiros podem ser positivos ou negativos e NÃO possuem parte

decimal.
Exemplos:
Vejamos algumas proposições declarativas comuns, em que é usado o tipo
inteiro:
a) Ele tem 15 irmãos.

b) A escada possui 8 degraus.
c) Meu vizinho comprou 2 carros novos
Enfatizando o conceito de dado, vale observar, por exemplo, o item: 8 é um

dado do tipo inteiro e a informação é associar que 8 é o número de degraus
da escada.
 Real
Os números reais podem ser positivos ou negativos e possuem parte
decimal.
Exemplos:
a) Ela tem 1.73 metro de altura.
b) Meu saldo bancário é de 215.20.
c) No momento estou pesando 82.5 kg.
13/80
Observação: Nas linguagens de programação a separação entre a parte

inteira e a parte decimal de um número é feita pelo ponto (.), e a simples
presença do ponto já significa que é um número real.
 Literal ou Caractere
São dados formados por caracteres (um ou mais). Esses caracteres podem
ser as letras maiúsculas, as letras minúsculas, os números e os caracteres
especiais (&, #, @, ?, +).
Exemplos:
a) Escolha o sexo: ‘M’ ou ‘F’.
b) Constava na prova: “Use somente a caneta!”;
c) Parque municipal estava repleto de placas: “Não pise na grama”.
d) Nome do vencedor é “Felisberto Laranjeira”.
Observação: Os dados do tipo literal na linguagem C são sempre

representados entre aspas simples quando temos um único caractere ou
aspas duplas quando temos mais de um caractere.
2. CONSTANTES
Entendemos que um dado é constante quando não sofre variação no decorrer

do tempo, ou seja, seu valor é constante desde o início até o fim da execução
do algoritmo, assim como é constante para execuções diferentes no tempo. O
uso de constantes é igual na matemática, por exemplo: o uso da constante pi
no cálculo da área de um círculo (área =  * r2 , onde  = 3.14159).
3. VARIÁVEL
Um dado é classificado como variável quando tem a possibilidade de ser

alterado em algum instante no decorrer do tempo, ou seja, durante a
execução do programa em que é utilizado, o valor do dado sofre alteração ou
o dado é dependente da execução em certo momento ou circunstância.
Exemplos:
A cotação do dólar, o peso de uma pessoa, o índice da inflação.
Quando fazemos um programa, este normalmente recebe dados, os quais

precisam ser armazenados no computador para que possam ser utilizados no
processamento; esse armazenamento é feito na memória.
Um exemplo para ilustrar a diferença entre valores constantes e variáveis

seria a construção de um programa para calcular o valor da área de uma
circunferência.
14/80
Area = r2
Area  3.14159 * (raio*raio)
4. DECLARAÇÃO DE VARIÁVEIS
No ambiente computacional, as informações variáveis são guardadas em

dispositivos eletrônicos chamados de “memória”. Podemos imaginar essa
“memória” como sendo um armário repleto de gavetas, no qual as gavetas
seriam os locais físicos responsáveis por armazenar objetos; os objetos (que
podem ser substituídos) seriam os dados e as gavetas, as variáveis.
Visto que na memória (armário) existem inúmeras variáveis (gavetas),

precisamos diferenciá-las, o que é feito por meio de identificadores (etiquetas
ou rótulos). Cada variável (gaveta), no entanto, pode guardar apenas um
dado (objeto) de cada vez, sendo sempre de mesmo tipo primitivo (material).
Portanto, precisamos definir nomes para determinadas gavetas

especificando qual o material dos objetos que lá podem ser armazenados; em
outras palavras, declarar as variáveis que serão usadas para identificar os
dados.
5. FORMAÇÃO DE IDENTIFICADORES
Os identificadores são os nomes das variáveis utilizadas nos algoritmos.
As regras básicas para a formação dos identificadores são:
 Podem possuir qualquer tamanho. Entretanto, apenas os 32 primeiros
caracteres são utilizados pelo compilador C.
 Os caracteres que você pode utilizar na formação dos identificadores são:
os números, as letras maiúsculas, as letras minúsculas e o caractere
sublinhado (_);
 Compilador C faz diferença entre letras maiúsculas e minúsculas;
portanto, o identificador NUM é exatamente diferente dos identificadores
num, Num (aliás, em C todos esses identificadores seriam diferentes);
 O primeiro caractere deve ser sempre uma letra;
 Não são permitidos espaços em branco e caracteres especiais (@, $, +, -,
%, !);
 Não podemos usar as palavras reservadas nos identificadores.
Obs.: Palavras reservadas da linguagem C não podem ser identificadores de

variáveis:
auto, break, case, char, const, continue, default, do, double, else, enum,
extern, float, for, goto, if, int, long, register, return, short, signed, sizeof,
static, struct, switch, typedef, union, unsigned, void, volatile, while.
15/80
Exemplos de identificadores válidos:

A
a
nota
NOTA
X5
A32
NOTA1
MATRICULA
nota_1
dia
IDADE
Exemplos de identificadores inválidos:

5b
e@12
x-y
prova 2n
nota(2)
else
int
6. DECLARAÇÃO DE VARIÁVEIS
As declarações de variáveis são obrigatórias para validar os identificadores.
Todas as variáveis devem ser incluídas em uma única declaração da forma:
tipo lista de variáveis;
tipo lista de variáveis;
Onde tipo representa o conjunto de valores que podemos atribuir a essas
variáveis e as listas de variáveis são os identificadores das variáveis do
mesmo tipo separados por vírgulas.
Obs.: Duas ou mais variáveis NÃO PODEM ter o mesmo nome

(identificador).
7. TIPOS DE VARIÁVEIS
Exemplos das declarações de variáveis:
real salario, nota_1;
inteiro matricula, contador;
caractere nome;
16/80
8. COMENTÁRIOS
Os comentários não são interpretados pelo compilador, servem apenas para
esclarecer o programador, são excelentes instrumentos de documentação e
devem sempre estar entre /* ......... */. Ou ainda pode-se usar // para
comentar o resto da linha.
Exemplos de comentários:
inteiro num; // variável inteira para guardar o nº de alunos
real nota_1, nota_2; /* Variáveis reais que serão utilizadas para armazenar
as duas notas do aluno. */
17/80
9. Operações aritméticas:
Os operadores aritméticos a serem utilizados:
+ Adição
- Subtração
* Multiplicação
/ Divisão inteira e divisão real
% Resto da divisão
Exemplo: Considere X e Y variáveis do tipo inteiro e com valores 7 e 3

respectivamente.
Expressão Valor Expressão Valor
X+Y 10 X/ Y 2
X- Y 4 Y/ X 0
Y- X -4 Y%X 3
X* Y 21 X%Y 1
X / 2.0 3.5 Y / 3.0 1.0
Exemplo:
X + Y – Z => (X + Y) – Z
X * Y % Z => (X * Y) % Z
 A ordem da precedência dentro de uma expressão aritmética pode ser

alterada fazendo-se uso de parênteses. Caso tenha dúvidas quanto à
ordem de precedência de uma expressão, utilize sempre parênteses para
especificar claramente a ordem da avaliação desejada.
Exemplo:
A + B * C => A + (B * C)
Para forçar a precedência usamos os parênteses => (A + B) * C
10. Potenciação e Radiciação

Usaremos inicialmente duas funções matemáticas predefinidas para
calcular a potenciação e a radiciação.
Operador Função Significado Exemplo

pot(x,y) Potenciação x elevado a y pot(2,3)==23== 8.0
rad(x) Radiciação Raiz quadrada de x rad(9)==3.0
18/80
Prioridades
Na resolução das expressões aritméticas, as operações guardam uma

hierarquia entre si.
Prioridade Operadores
1ª parênteses mais internos
2ª pot rad
3ª * / % (mod em portugol)
4ª + -
Em caso de empate (operadores de mesma prioridade), devemos resolver
da esquerda para a direita, conforme a seqüência existente na expressão
aritmética. Para alterar a prioridade da tabela, utilizamos parênteses
mais internos.
Exercício: Supondo que A, B e C são variáveis de tipo inteiro, com valores

iguais a 5, 10 e – 8, respectivamente, uma variável real D, com valor de
1.5, resolva passo a passo (obedecendo a ordem de prioridade) as
expressões aritméticas abaixo e determine quais são os resultados.
a) 2 * A % 3 – C
b) rad( - 2 * C) / 4
c) ((20 / 3) / 3) + pot(2, 8) / 2
d) (30 % 4 * pot(3,3) ) * -1
e) pot( - C, 2 ) + ( D * 10 )/A
f) rad ( pot ( A, B/A) ) + C * D
Respostas: (a) 9 (b) 1.0 (c) 130.0 (d) – 54.0 (e)
67.0 (f) - 7.0
11. Sinal de atribuição

O conteúdo de uma variável pode ser alterado a qualquer momento.
Portanto para atribuir valores a variáveis devemos usar o sinal de  (“=”
em C) .
Exemplos:
Portugol C
A  2; A = 2;
B  3; B = 3;
C  A + B; C = A + B;
19/80
Exercício: Encontre os erros dos seguintes comandos de atribuição:
inteiro A,D;
real B, C;
A  0;
A  A + 1;
D  B;
C + 1  B + C;
C  3.5;
D  2*C +6*6*2 - 3 * 4;
12. Operações relacionais (Seguem a ordem de precedência

posicional):
== Igual
> Maior
< Menor
>= Maior ou igual
<= Menor ou igual
!= Diferente
Exemplo: Considere I1 e I2 variáveis do tipo inteiro, R do tipo real com

valores 10, 20, 4.5 respectivamente;
I1 > I2 é FALSO I1 > R é VERDADEIRO

I1 == 10 é VERDADEIRO I1 < I2 é VERDADEIRO
I2 != 20 é FALSO I2 == 20 é VERDADEIRO
13. Operadores Lógicos:

não (!) Negação lógica
e (&&) Interseção lógica
ou (||) União lógica
Exemplo: Considere as variáveis: inteiro a = 3; real: x = 1.5:
Expressão Valor Lógico

((a/2 = = x) && (a>2)) Falso
((a != x) || (a/x < 2)) Verdadeiro
! (a/3 <= x) Falso
((a < 2*x) || ( x < a/2)) Falso
 Note que o valo r lógico de uma expressão lógica e (&&) é verdadeira

somente se ambas as partes forem verdadeiras. Caso contrário, o valor
lógico será falso. Por outro lado, o valor lógico de uma expressão lógica
20/80
ou (||) é falso somente se ambas as partes forem falsas. Caso

contrário, o valor lógico será verdadeiro.
Exercício: Determine os resultados obtidos na avaliação das
expressões lógicas seguintes, sabendo que A, B, C contêm,
respectivamente, 2, 7 e 3.5:
a) (B == (A * C) ) && (C == 2)
b) (B > A) || (B == 4)
c) ((B % A) >= C) || ( ! ( A <= C))
d) ( ! (2 == A)) || ( 3 >= C)
e) ((B / A ) == C ) || ((B / A ) != C)
21/80
Construção de tabela-verdade
Os operadores lógicos são usados para dar suporte às operações lógicas

básicas de E (&&), OU (||) e NÃO (!), de acordo com a tabela-verdade. A
tabela usa V para verdadeiro e F para falso. E1 e E2 são expressões lógicas
quaisquer.
E1 E2 !E1 E1 && E2 E1 || E2
V V F V V
V F F F V
F V V F V
F F V F F
O número de linhas de uma tabela verdade é sempre 2 n onde n é o
número de expressões lógicas presente na sentença. A forma de
preenchimento sempre se dará por colunas e começa preenchendo a
primeira coluna com metade V e a outra metade F, a segunda coluna será
preenchida com a metade da metade e assim por diante. (como no
exemplo anterior)
Exercício Proposto: Para cada uma das sentenças lógicas construa a
respectiva tabela-verdade:
a) E1 && !(E2 || E2)
b) !( !E1 || !(E2 && ! E3))
c) (E1 && E2) || !E3
d) !(!(!(E1 || !E2))) && !(E3||!E1)
e) !(!(!E1 || !E2)) && !(E3||!E1)
f) !(!(E1 && E2)) && !(!E3 && !E1)
g) (E1 || !E3) && (!E2 && !(E1 || E3))
22/80
14. Comandos de entrada e saída

Comando de Saída de dados:
É através deste comando (escreva) que o algoritmo apresentará
informações na tela do computador.
escreva  Comando de saída que exibe uma informação no monitor
de vídeo.
EXEMPLO:
inteiro idade;
real peso;
...
escreva( “Ola você tem %i anos de idade“, idade);
escreva( “ e pesa %r KG “, peso);
Supondo que a pessoa tenha 35 anos e pese 70.0 KG a tela ficará

assim:
Ola você tem 35 anos de idade

e pesa 70.0 KG
Usamos o seguintes códigos para representar variáveis, constantes e

expressões aritméticas ( de acordo com o seu tipo):
%i é o código para o tipo inteiro
%r é o código para o tipo real
%c é o código para o tipo caractere
O comando escreva sempre vai exigir o uso destes símbolos na posição

onde queremos imprimir o conteúdo da variável.
23/80
Comando de entrada de dados

É através deste comando (leia) que o usuário digita um dado que será
armazenado em uma variável na memória do computador.
leia  Comando de entrada que permite a leitura de variáveis de
entrada.
EXEMPLO:
inteiro MATRICULA;
real NOTA_1, NOTA_2;
escreva(“Digite sua matricula: “);
leia(“ %i“, &MATRICULA);
escreva(“Digite suas duas notas: “);
leia( “%r%r”, &NOTA_1, &NOTA_2);
Onde o & significa o endereço de memória da variável. O comando leia

exige que seja colocado o & antes do nome da variável.
15. Bloco do programa principal

O bloco do programa principal geralmente começa com a declaração
das constantes e variáveis que o algoritmo utilizará. Em seguida,
especifica as ações a serem executadas sobre os objetos definidos
(variáveis e/ou constantes). Ele é iniciado pela palavra início seguida
pela seqüência de comandos e finalizada pela palavra fim.
início
<Bloco de comandos>
fim
Exercício: Utilizando o seguinte trecho de algoritmo, explique o que
está acontecendo em cada linha e qual é o resultado de cada ação
executada.
início
inteiro contador, num1, num2 ;
real expressao;
contador  0;
escreva(“Digite um valor inteiro: “);
leia(“%i”, &num1);
escreva(“ %i ELEVADO AO CUBO = %i “,num1, num1*num1*num1);
escreva(“Digite outro valor inteiro: “);
leia(“%i”, &num2);
escreva(“A soma e: %i “, num1+num2);
contador  contador + 1;
expressao  (num2 + num1) % 2;
escreva(“O valor final da expressao e: %r “, expressao);
....
fim
24/80
Exercícios de Fixação II
1 - Determine qual é o tipo básico de dados da informação destacado nas

sentenças a seguir:
a) A placa “Pare !” tinha 2 furos de bala.

b) Josefina subiu 5 degraus para pegar uma maçã “boa”.
c) Alberta levou 3.5 horas para chegar ao hospital onde concebeu uma
"garota” .
d) Astrogilda pintou em sua camisa: “Preserve o meio ambiente”, e ficou
devendo 100.59 ao vendedor de tintas.
e) Felisberto recebeu sua 18a. medalha por ter alcançado a marca de 57.3
segundos nos 100 metros rasos.
2 – Assinale os identificadores válidos:

a) if b) U2 c) AH! d) ‘ALUNO’ e) #55
f) KM/L g) UYT h) ASBRUBAL i) AB*C j) O&O
k) P{O} l) B52 m) Rua n) CEP o) dia_mês
3 – Supondo que as variáveis Nota_A, Nome_A, NMat sejam utilizadas para

armazenar a nota do aluno, o nome do aluno e o número da matrícula,
declare-as corretamente, associando o tipo básico adequado ao dado que será
armazenado.
4 – Encontre os erros da seguinte declaração de variáveis:
inteiro endereco n_filhos;

caractere idade, X, C;
real XPTO, C, peso, R$;
5 - Identifique o tipo dos dados:

(a) inteiro;
(b) real;
(c) caractere;
( ) “MARIA” ( ) 45.0 ( ) 1234 ( ) 0.0

( ) ‘a’ ( ) ‘*’ ( ) -234 ( ) ‘1’
( ) -0.342 ( ) 35.23 ( ) ‘3’ ( ) -18.589
( )” “ ( ) -354.0 ( ) -15.2 ( ) ”José”
( )0 ( ) 897 ( ) -23
6 - Faça a declaração de 2 variáveis do tipo inteiro para armazenar os

códigos de dois produtos, 2 variáveis do tipo real para armazenar os
preços destes produtos e 2 variáveis do tipo caractere para armazenar
o tipo do produto (‘p’: para perecível e ‘n’ para não perecível, por
exemplo).
25/80
7 - Indique qual o resultado das expressões aritméticas abaixo:

Sendo: x = 6.0 y=2 z = 4.0 a=8
b = 7.5
c = 7.7 d = 12 p=4 q=3 r = 10
s=3.5
a) x + y – z * a
b) d / y % r * c – b – rad( d – q )
c) d % y – pot( p, q) * z
d) y / d + rad(b+s + pot(q,3) – y )
e) (z * r / (a + d) * a) – d
f) 100 * (q / p) + r
8 - De acordo com as informações abaixo, informe qual o valor das

relações ( V - Verdadeira ou F - falsa):
a) a  2.0, b  9.0, nome  “ana” , profissao  “advogado”
a + 1 >= b*a ( )
nome != “ana” ( )
profissao == “médico” ( )
b) a  6.0 , b  121.0 , nome  “pedro”, profissao  “médico”
a + 1 >= b – 5 ( )
nome != “ana” ( )
profissao == “médico” ( )
c) x  3 , y  4 , z  16 , nome  “maria” :
(( x +y > z ) && (nome == “maria”)) ( )
(( x *y > z ) || ( y > = x )) ( )
(!( x - y > z ) && ( z / y + 1 == x )) ( )
((nome == “josé”) && ( x + y + z < ( y*y ))) ( )
9 - Dadas as declarações:
inteiro NUM;
real SOMA, X;
caractere SIMBOLO;
Assinale os comandos de atribuição inválidos:
( ) SIMBOLO  5; ( ) SOMA  NUM+2*X;
( ) X*X  SOMA; ( ) TUDO  SOMA;
( ) X  X+1; ( ) NUM  5*SOMA+2;
( ) NUM ”*ABC*”;
10 - Marque os identificadores como válidos ou inválidos (explicando a

resposta quando o identificador for inválido):
(a) identificador válido;
(b) identificador inválido;
( ) ano
( ) media_salario
( ) ai!
( ) A15B34
( ) “aula”
( ) 3/1
26/80
11 – Faça o rastreamento (tela e memória) do seguinte bloco de

comandos:
Início
real nota1, nota2, media;
escreva(“Digite as duas notas: “);
leia(“%r%r”, &nota1, &nota2);
media  (nota1 + nota2 ) / 2;
escreva(“ Media = %r “, media);
fim
12 – Encontre os ERROS no bloco de comandos abaixo e explique o

que está errado:
início
inteiro X, Y ;
real Z;
Z  1.5;
leia(X;
escreva(X, “ ELEVADO AO CUBO = “, X*X*X);
escreva(“Digite outro valor inteiro: “)
leia(Y);
escreva(“A soma e: , X+Y);
Z + 3  Z + 1;
X  (Y + X) / 5.0;
escreva(“O valor final da expressao e: “ X);
fim
27/80
Unidade III - ESTRUTURA DE ALGORITMOS EM

PORTUGOL
1. Introdução
Usaremos um exemplo simples para compreendermos como a
formalização em uma linguagem artificial é importante.
Exemplo Inicial
Suponha que o algoritmo leia dois números que o usuário do computador

digitará no teclado, some-os e mostre o resultado na tela do computador.
1a solução: (Narrativa informal)
1. Leia do teclado dois valores
2. Some os dois valores
3. Mostre o resultado da soma na tela
2a solução: (Narrativa um pouco mais formal seria)

1. Leia o valor do teclado e armazene na memória A;
2. Leia o valor do teclado e armazene na memória B;
3. Some os valores da memória A e B e coloque o resultado na
memória SOMA;
4. Mostre na tela o valor da memória SOMA.
Nesta solução vemos o uso de 3 memórias: A, B e SOMA. Aqui o conceito de

memória é semelhante ao das memórias existentes nas calculadoras. Elas
servem para acumular o resultado de cálculos intermediários.
Uma solução ainda mais formal seria:

3a solução: (Portugol que será utilizado na disciplina)
principal( )
início
inteiro num1, num2, soma;
escreva(“Digite o primeiro número: “);

leia (“%i”, &num1);
escreva(“Digite o segundo número: “);
leia (“%i”, &num2);
soma  num1 + num2;
escreva(“ A soma é %i “, soma);
fim
{ Observe a identação , ou seja, o alinhamento de cada linha do algoritmo}
Aqui as palavras início e fim foram usadas para delimitar o bloco de
comandos.
28/80
2. Estrutura de um algoritmo em Portugol
principal( )
ínicio
const <tipo> <identificador>  <dado>;
<tipo> <identificador>;
<comando1>;
...
<comandon>;
fim
Segue um Algoritmo que lê as 4 notas bimestrais de um aluno. Em seguida o

Algoritmo calcula e escreve a média obtida.
Resolução:
principal( )
início
real nota1, nota2, nota3, nota4, media;
escreva (“DIGITE SUAS QUATRO NOTAS: “);

leia (“%r%r%r%r”, &nota1, &nota2, &nota3, &nota4);
media  (nota1 + nota2 + nota3 + nota4) / 4;
escreva (“ SUA MÉDIA É: %r “, media);
fim
//Segunda Versão:
principal( )
início
real nota1, nota2, nota3, nota4, soma, media;
escreva (“DIGITE SUAS QUATRO NOTAS: “);

leia (“%r%r%r%r”, &nota1, &nota2, &nota3, &nota4);
soma  nota1 + nota2 + nota3 + nota4;
media  soma / 4;
escreva (“ SUA MÉDIA É: %r “, media);
fim
29/80
Exercícios Resolvidos:
1) Faça um algoritmo em Portugol que leia os valores reais para largura,

comprimento e altura de um paralelepípedo retângulo e calcule o seu
volume.
RESOLUÇÃO:
principal( )
início
real largura, comprimento, altura;
escreva(“Digite os valores para largura, comprimento e altura: “);
leia(“%r%r%r%r”, &largura, &comprimento, &altura);
escreva(“ Volume = %r cm3“, largura*comprimento*altura);
fim
Se o usuário digitar os seguintes valores para as variáveis: largura ==

10; comprimento = = 3; altura = = 2; o resultado do rastreamento do
algoritmo acima ficaria assim:
Tela
Memória
Digite os valores para largura, comprimento e altura: 10 3 2 <Enter>
largura: 10.0 Volume = 60.0 cm3
comprimento: 3.0
altura: 2.0
Versão 2 do algoritmo anterior:

principal( )
início
real largura, comprimento, altura, volume_p;
escreva(“Digite os valores para largura, comprimento e altura: “);
leia(“%r%r%r%r”, &largura, &comprimento, &altura);
volume_p  largura*comprimento*altura;
escreva(“Volume = %r cm3”, volume_p);
fim
30/80
2) Faça um Algoritmo que lê o raio de uma circunferência e calcula sua área.

Resolução:
principal( )
início
const real pi = 3.1416;
real raio, area;
//Entrada de dados
escreva(“Digite o valor do raio: “);
leia (“%r”, &raio);
//Processamento de dados
area  pi * (raio*raio); // ou area  pi * (pot(raio,2));
// Saída de dados
escreva (“Area = %r “, area) ;
fim
3) Faça um algoritmo em Portugol que leia dois valores inteiros para as
variáveis num1 e num2, em seguida efetue as operações de adição,
subtração, multiplicação e divisão de num1 por num2, apresentando ao
final os resultados obtidos.
Resolução:
principal( )
inicio
inteiro num1, num2, soma, sub, mult, divi;
//Entrada de dados
escreva(“Digite dois valores inteiros: “);
leia(“%i%i”, &num1, &num2);
soma  num1+num2;
sub  num1 - num2;
mult  num1 * num2;
divi  num1/num2;
//Saída de dados
escreva(“%i + %i = %i “, num1, num2, soma);
escreva(“%i - %i = %i “,num1, num2, sub);
escreva(“%i * %i = %i “,num1, num2, mult);
escreva(“%i / %i = %i “,num1, num2, divi);
fim
31/80
4)Efetuar a leitura de um número inteiro e apresentar o resultado do

quadrado deste número.
Resolução:
principal( )
inicio
inteiro num;
//Entrada de dados
leia(“%i”, &num);
//Processamento e saída de dados

escreva( “ %i ao quadrado e %i “, num, num*num);
fim
//Segunda versão:
principal( )
inicio
inteiro num, quad;
//Entrada de dados
quad  num*num;
//Saída de dados
escreva(“ %i ao quadrado e %i “, num, quad);
fim
//Terceira Versão:
principal( )
inicio
inteiro num;
real quad;
//Entrada de dados
quad  pot(num, 2);
//Saída de dados
escreva(“ %i ao quadrado e %r “, num, quad);
fim
32/80
5) Ler uma temperatura em graus Fahrenheit e apresentá-la convertida

em graus Célsius. A fórmula de conversão é: C  (F – 32) * (5 / 9.0), onde F
é a temperatura em Fahrenheit e C é a temperatura em Célsius.
Resolução:
principal( )
inicio
real celsius, f;
//Entrada de dados
escreva(“Digite a temperatura em Fahrenheit: “);
leia(“%r”, &f);
celsius  (f – 32)*(5/9.0);
//Saída de dados
escreva(“ A temperatura em Celsius e %r “, celsius);
fim
6) Calcular e apresentar o volume de uma lata de óleo, utilizando a fórmula:

VOLUME  3.14159 * R * R * ALTURA.
Resolução:
principal( )
inicio
const real PI  3.14159;
real volume, raio, altura;
//Entrada de dados
escreva(“Digite o valor do raio e da altura em cm: “);
leia(“%r%r”, &raio, &altura);
volume  PI * pot(raio,2) * altura;
//saída de dados
escreva(“ O volume da lata de óleo é %r cm3 ”, volume);
fim
33/80
Exercícios de Fixação III
1 - Faça um algoritmo em Portugol que leia dois valores inteiros para as

variáveis num1 e num2, em seguida efetue as operações de adição,
subtração, multiplicação e divisão de num1 por num2, apresentando ao final
os resultados obtidos.
2 - Faça um algoritmo em Portugol que faça a leitura de um número inteiro

e apresente o resultado do quadrado deste número na tela.
3 - Faça um algoritmo em Portugol que Leia uma temperatura em graus

Fahrenheit e apresente-a convertida em graus Célsius. A fórmula de
conversão é: C  (F – 32) * (5 / 9.0), onde F é a temperatura em Fahrenheit
e C é a temperatura em Célsius.
4 - Faça um algoritmo em Portugol que calcule e apresente o volume de uma

lata de óleo, utilizando a fórmula: VOLUME  3.14159 * R * R * ALTURA.
5 - Faça um algoritmo que receba dois números inteiros, calcule e imprima:

soma dos dois números;
subtração do primeiro pelo segundo;
subtração do segundo pelo primeiro;
multiplicação dos dois números;
divisão real do primeiro pelo segundo;
divisão real do segundo pelo primeiro;
divisão inteira do primeiro pelo segundo;
divisão inteira do segundo pelo primeiro;
resto da divisão do primeiro pelo segundo;
resto da divisão do segundo pelo primeiro.
6 - Faça um algoritmo em Portugol que leia dois valores para as variáveis

num1 e num2, efetuar a troca de valores de forma que a variável num1
passe a possuir o valor da variável num2 e que a variável num2 passe a
possuir o valor da variável num1. Imprimir na tela os valores de num1 e
num2 antes e depois da troca.
34/80
7 – Faça um algoritmo que efetue o cálculo do valor de uma prestação em

atraso, utilizando a fórmula: PRESTACAO  VALOR + (VALOR *
(TAXA/100) * TEMPO), onde a TAXA é um valor constante de 2 e o TEMPO
é dado em dias.
Resolução:
principal( )
inicio
const real taxa  2.0;
inteiro tempo;
real prestação, valor;
//Entrada de dados
escreva(“Digite o valor da prestação: “);
leia(“%r”, &valor);
escreva(“Digite o tempo de atraso em dias: “);
leia(“%i”,&tempo);
prestação  (valor * (taxa/100)*tempo)+valor;
//saída de dados
escreva(“O valor final da prestação é: %r “, prestação);
fim
8 - Uma loja de animais precisa de um programa para calcular os custos de

criação de coelhos. O custo é calculado com a fórmula CUSTO 
(NR_COELHOS * 0.70) / 18 + 10. Faça um algoritmo em Portugol que leia
um valor para a variável NR_COELHOS e apresente na tela o valor da
variável CUSTO.
9 - Faça um algoritmo que receba duas notas de um aluno e seus respectivos

pesos, calcule e imprima a média ponderada dessas notas.
Resolução:
principal( )
inicio
real nota1, nota2, media_p;
inteiro peso1, peso2;
//Entrada de dados
escreva(“Digite os pesos: “);
leia(“%i%i”, &peso1, &peso2);
media_p  (nota1*peso1 + nota2*peso2)/(peso1+peso2);
//Saída de dados
escreva(“ A media ponderada e %r “, media_p);
fim
35/80
Rastreamento
Memória Tela
Digite as duas notas: 7 8 <Enter>
nota1: 7.0 Digite os pesos: 1 2 <Enter>
nota2: 8.0 A media ponderada e 7.6
media_p: 7.6
peso1: 1
peso2: 2
10 - Faça um algoritmo que receba o valor de um depósito e o valor da taxa

de juros. Calcule e imprima o valor do rendimento e o valor total depois do
rendimento.
Resolução:
principal( )
inicio
real deposito, taxa, rend, valor_final;
//Entrada de dados
escreva(“Digite o valor do deposito: “);
leia(“%r”, &deposito);
escreva(“Digite o valor da taxa de juros: “);
leia(“%r”, &taxa);
rend  deposito * (taxa/100);
valor_final  deposito + rend;
//Saída de dados
escreva(“ O valor do rendimento e: %r “, rend);
escreva(“ O valor final com o rendimento e: %r “, valor_final);
fim
Faça o rastreamento
11 - Faça um algoritmo que receba um número inteiro, calcule e imprima a

tabuada desse número.
Resolução:
principal( )
inicio
inteiro num;
//Entrada de dados
escreva(“Digite um numero para a tabuada: “);
leia(“%i”,&num);
36/80
escreva(“A tabuada de multiplicação do numero “, num);

escreva(“ %i * 1 = %i “, num, num);
escreva(“ %i * 2 = %i “, num, 2*num);
fim
Rastreamento
Memória Tela
Digite um numero para a tabuada: 2 <Enter>
num: 2 2* 1=2
2* 2=4
2* 3=6
2* 4=8
2 * 5 = 10
2 * 6 = 12
2 * 7 = 14
2 * 8 = 16
2 * 9 = 18
2 * 10 = 20
12 - Faça um algoritmo que receba um número real, calcule e imprima o
valor referente ao volume do cubo que tenha este número real como lado.
13 - Faça um algoritmo que receba um número inteiro, calcule e imprima:

a raiz quadrada desse número;
esse número elevado à quinta potência.
14 - Faça um algoritmo que receba o valor do salário de um funcionário e o

valor do salário mínimo. Calcule e imprima quantos salários mínimos ganha
esse funcionário.
15 - Faça um algoritmo que calcule e imprima a área de um retângulo.
16 - Faça um algoritmo que receba o salário de um funcionário, calcule e

imprima o valor do imposto de renda a ser pago, sabendo que o imposto
equivale a 5% do salário.
37/80
17 - Faça um algoritmo que receba o salário de um funcionário, calcule e

imprima o novo salário sabendo-se que este sofreu um aumento de 25%.
Resolução:
principal( )
inicio
const real reaj = 25;
real salario, novo_sal;
//Entrada de dados
escreva(“Digite o valor do salario: “);
leia(“%r”, &salario);
novo_sal  salario * (reaj/100) + salario;
//Saída de dados
escreva(“ O valor do salario reajustado e: %r “, novo_sal);
fim
18 - Faça um algoritmo que receba o peso de uma pessoa, calcule e imprima:

o peso dessa pessoa em gramas;
se essa pessoa engordar 5%, qual será seu novo peso em gramas?
19 - Imprima o cálculo da seguinte equação sendo lidos os parâmetros reais

a, b e c:
X = ((a + (2* b + c) * c) / a *a)
20 - Faça um algoritmo que leia as medidas de um retângulo (base, altura),

calcule e imprima sua área e seu perímetro.
38/80
UNIDADE IV – Comandos de Seleção

O que vamos ver:
 Seleção Simples
 Seleção Composta
 Seleção Encadeada
 Seleção Múltipla Escolha
Uma estrutura de seleção permite a escolha de um grupo de ações (bloco) a

ser executado quando determinadas condições, representadas por expressões
lógicas ou relacionais, são ou não satisfeitas.
1. Seleção Simples
Quando precisamos testar certa condição antes de executar uma ação,
usamos uma seleção simples, que segue o seguinte modelo:
se (<condição>) então
Comando; // comando único
<condição> é uma expressão lógica que, quando inspecionada, pode gerar
um resultado falso ou verdadeiro.
Se <condição> for verdadeira, o comando sob a cláusula se/então (Comando)
será executada; caso contrário (<condição>) for falsa), encerra-se a seleção
(fim), neste caso sem executar nenhum comando. Obs.: A palavra então está
sublinhada pois será opcional escrevê-la.
Através do exemplo anterior, observamos que, quando existir apenas uma
ação após a cláusula, então basta escrevê-la; já quando precisamos colocar
diversas ações é necessário usar um bloco, delimitado por início e fim
conforme o seguinte modelo:
início
Comando-1;
Comando-2;
...
Comando-n;
fim
Exemplo:
principal ( )
inicio
real n1, n2, n3, m;
escreva(“DIGITE TRES NOTAS: “);
leia(“%r%r%r”, &n1, &n2, &n3);
m  (n1 + n2 + n3) / 3;
se ( m >= 7 ) então
inicio
escreva(“APROVADO”);
escreva(“MÉDIA = %r “,m);
fim
fim
39/80
2. Seleção Composta
Quando tivermos situações em que duas alternativas dependem de uma
mesma condição, uma da condição ser verdadeira e outra da condição ser
falsa, usamos a estrutura de seleção composta. Supondo que um conjunto de
ações dependa da avaliação verdadeira uma única ação primitiva dependa
da avaliação falsa, usaremos uma estrutura de seleção semelhante ao
seguinte modelo:
início
Comando-1;
Comando-2;
....
Comando-n;
fim
senão
inicio
Comando-z1;
Comando-z2;
fim
principal ( )
inicio
inteiro num1, num2;
escreva(“Digite dois valores inteiros: “);
leia(“%i%i”, &num1, &num2);
se (num1 == num2) então
escreva(“NÚMEROS IGUAIS”);
senão
escreva(“NÚMEROS DIFERENTES”);
fim
Outro exemplo de estrutura condicional composta:
40/80
principal ( )
inicio
real n1, n2, n3, m;
escreva(“DIGITE TRÊS NOTAS: “);
leia(“%r%r%r”, &n1, &n2, &n3);
m  (n1 + n2 + n3) / 3;
se (m >= 7) então
inicio
escreva(“APROVADO”);
fim
senão
inicio
escreva(“ REPROVADO”);
fim
escreva(“MÉDIA = %r “,m);
fim
41/80
3. Seleção Encadeada
Quando precisarmos agrupar várias seleções, formaremos uma seleção

encadeada. Normalmente, tal formação ocorre quando uma determinada
ação (ou bloco de ações) deve ser executada de acordo com um conjunto de
possibilidades.
se (<condição 1>) então

início
Comando-1;
Comando-2;
....
Comando-n;
fim
senão
início
Comando-1;
Comando-2;
....
Comando-n;
fim
senão
Comando –v;
senão
Comando-f;
42/80
Exemplo de estruturas condicionais encadeadas:

principal ( )
inicio
real nota_1, nota_2, nota_3, media, nota_recup;
escreva(“Digite as três notas: ”);
leia(“%r%r%r”, & nota_1, &nota_2, &nota_3);
media  (nota_1+ nota_2+nota_3) / 3;
se ( media >= 7) então
inicio
escreva(“Aluno Aprovado!”);
fim
senão
se ((media<7)&&( media >= 3)) então
inicio
escreva(“Aluno com direito a Prova de Recuperacao!”);
nota_recup 10 – media;
escreva(“Nota para tirar na prova de recuperação: %r “,
nota_recup);
fim
senão
inicio
escreva(“ Aluno Reprovado”);
fim
escreva(“Media do Aluno: %r “, media);
fim
43/80
Exercícios de Fixação IV
1. Faça um algoritmo para ler três valores numéricos inteiros distintos e

determinar o menor deles.
2. Faça um algoritmo que leia o sexo (m ou M para masculino – f ou F para

feminino) e a idade de uma pessoa e determine se a pessoa já atingiu a
maioridade, sabendo-se que: as pessoas do sexo masculino atingem a
maioridade aos 18 anos e as pessoas do sexo feminino atingem a maioridade
aos 21 anos. O algoritmo deve escrever o resultado esperado.
Rastreamento
Memória Tela
sexo: ‘F’ Digite seu sexo (M ou F ): F <Enter>
idade: 27 Digite sua idade: 27 <Enter>
Atingiu a maioridade!
sexo: ‘f’ Digite seu sexo (M ou F ): f <Enter>
Nao atingiu a maioridade.
sexo: ‘M’ Digite seu sexo (M ou F ): M <Enter>
Atingiu a maioridade!
sexo: ‘m’ Digite seu sexo (M ou F ): m <Enter>
Nao atingiu a maioridade.
sexo: ‘$’ Digite seu sexo (M ou F ): $ <Enter>
Sexo invalido.
44/80
3. Suponha que os termos b1, b2 e b3 abaixo sejam expressões Verdadeiras ou Falsas e

que c1, c2, c3, c4 e c5 sejam comandos quaisquer.
principal ( )
início
se (b1) então
início
c1;
fim
senão
início
se (b2) então
início
se (b3) então
início
c2;
fim
senão
início
c3;
c4;
fim
fim
c5;
fim
fim
Dado o algoritmo acima, responda:

a) Se b1 for verdadeiro, b2 for verdadeiro e b3 for falso, quais os comandos
que serão executados ?
b) Se b1 for falso, b2 for verdadeiro e b3 for falso, quais os comandos que
serão executados ?
c) Quais os valores de b1, b2, b3 para que somente o comando C5 seja
executado ?
d) Se b1 for verdadeiro, b2 for verdadeiro e b3 for verdadeiro, quais os
comandos que serão executados ?
e) Quais os valores de b1, b2 e b3 para que sejam executados os comandos c2
e c5?
4. Faça um algoritmo que leia dois números, some-os e imprima o resultado caso a
soma seja maior que 10.
5. Faça um algoritmo que leia um número inteiro e imprima a mensagem ‘Número par!’
caso ele seja divisível por 2.
6. Faça um algoritmo que leia 2 números inteiros para as variáveis A e B. Caso A seja
maior que B e B seja par, efetue a troca dos valores de forma que a variável A passe a
conter o valor da variável B e, a variável B passe a conter o valor da variável A.
45/80
7. Faça um algoritmo que leia um número inteiro positivo e imprima uma mensagem
dizendo se ele é par ou impar.
8. Faça um algoritmo que leia dois valores numéricos inteiros e distintos. Apresente a
diferença do maior pelo menor na tela.
9. O que está errado no algoritmo abaixo?

principal ( )
inicio
inteiro num1, num2, par;
printf(Digite um valor inteiro: ”)
leia (“ %r “, num1);
num2  num1 % 2.0; // resto da divisão de num1 por 2.0;
se ( num2 == 0 ) então
inicio
par  ‘v’;
fim
senão
inicio
par  ‘f’;
fim
se ( par == ‘v’) então
escreva(“ O numero %i é par! “);
escreva(“ O numero %i NÃO é par! “);
fim
10. Dado o algoritmo abaixo responda qual o valor de Result após a sua execução?
principal ( )
início
real num1;
inteiro num2, result;
num1  1.5;
num2  3;
num1  num1 + 1;
se ( (num1+2<= num2) ou ((num1 + num2 > 5) ou (não (num1+pot(num2,2) / num1 + num2>=4 ))) então
inicio
result 0;
fim
senão
inicio
result  1;
fim
fim
11. Faça um algoritmo que leia dois valores numéricos e imprima o maior. Caso os
números sejam iguais imprima a mensagem ‘Números iguais!’.
46/80
12. Faça um algoritmo que leia três números distintos e imprima o maior.
13. Faça um algoritmo que calcule e imprima o desconto do salário de um

funcionário, sabendo que:
a. se salário < R$ 1000, 00, desconto de 5% sobre o salário;
b. se salário >= R$ 1000, 00 e <= R$2000,00, desconto de 10% sobre o
salário;
c. se salário > R$ 2000, 00, desconto de 15% sobre o salário;
14. Faça um algoritmo que efetue a leitura de três valores numéricos reais distintos e
apresente os valores lidos em ordem crescente.
15. Faça um algoritmo que leia 2 notas e o número de faltas semestrais de um

determinado aluno e calcule a média aritmética entre elas. Imprima a média e uma
mensagem informando a situação final do aluno. O aluno estará aprovado caso sua
média seja maior ou igual a 7. O aluno terá direito a uma recuperação caso sua média
seja maior ou igual a 3, caso contrário estará reprovado. Mesmo que possua média para
aprovação ou recuperação, o aluno estará reprovado caso possua mais de 20 faltas.
Resolução:
principal ( )
inicio
real nota1, nota2, media;
inteiro faltas;

escreva(“Digite o numero de faltas: “);
leia(“%i”, &faltas);
media  (nota1 + nota2) / 2;
se ( faltas > 20 )
escreva(“Aluno Reprovado por faltas “);
senão
inicio
escreva(“ALUNO APROVADO”);
fim
senão
inicio
escreva(“Aluno de Recuperação”);
fim
senão
inicio
escreva(“ Aluno Reprovado por nota”);
fim
escreva(“ Sua Media foi: %r “, media);
fim
47/80
16. Dado o algoritmo abaixo responda:

a) Se b1 = VERDADEIRO e b2 = VERDADEIRO, o que será impresso?
b) Se b1 = FALSO e b2 = VERDADEIRO, o que será impresso?
c) Se b1 = FALSO e b2 = FALSO, o que será impresso?
Onde c1, c2 e c3 são mensagens, isto é, cadeias de caracteres.
principal ( )
início
se ( b1 ) então
início
escreva (c1);
fim
senão
início
se ( b2) então
início
escreva (c2);
fim
senão
início
escreva (c3);
fim
fim
fim
48/80
17. O que será impresso após a execução do algoritmo abaixo se:

a) num = 10 b) num = 0 c) num = - 4
principal ( )
início
/* declaração de variáveis */
inteiro num;
leia ( “%i”, &num);
se (num > 0) então
escreva (“numero positivo”)
senão
se (num < 0) então
escreva (“numero negativo”)
senão
escreva (“zero”);
fim
18. Uma empresa decide dar um aumento de 4% aos funcionários cujo salário é
inferior a 500 reais. Escreva um algoritmo que receba o salário de um funcionário e
imprima o valor do salário reajustado ou uma mensagem caso o funcionário não tenha
direito ao aumento.
19. Faça um algoritmo que verifique a validade de uma senha fornecida pelo
usuário. A senha correta é o número: 12345. O algoritmo deve imprimir mensagem de
permissão ou negação de acesso.
20. Faça um algoritmo que receba a idade de uma pessoa e imprima mensagem de
maioridade ou não. Assuma que a maioridade ocorre somente aos 21 anos.
21. Faça um algoritmo que receba a altura e o sexo de uma pessoa, calcule e
imprima o seu peso ideal, utilizando as fórmulas abaixo. Assuma M ou F como sendo os
valores válidos para o sexo de uma pessoa.
 para homens: (72.7 * ALTURA) – 58
 para mulheres: (62.1 * ALTURA) – 44.7
49/80
4. Seleção de Múltipla Escolha
Quando um conjunto de valores discretos precisa ser testado e ações

diferentes são associadas a esses valores, estamos diante de uma seleção
encadeada homogênea do tipo se – senão – se. Como esta situação é bastante
freqüente na construção de algoritmos que dependem de alternativas,
utilizaremos uma estrutura específica para estes casos, a seleção de
múltipla escolha.
O modelo que expressa as possibilidades é o seguinte:
escolha(X)
inicio
caso V1 : C1; pare;
caso V2 : C2; pare;
caso V3 : C3; pare;
caso V4 : C4;
fim
Caso o contéudo da variável seletora X seja igual ao valor Vn, então, o

comando Cn será executado; caso contrário, serão inspecionados os outros
casos até ser encontrada uma igualdade ou terminarem os caso.
Para executramos um comando que possui mais de um valor em que se

verifica sua necessidade, agrupamos todos esses valores em único caso. E,
para executarmos um comando que se verifica com todos os outros valores,
exceto os discriminados caso a caso, incluímos outra situação: caso contrário.
escolha(X)
inicio
caso V1 : C1; pare;
caso V2: caso V3 : C2; pare;
caso V4 : C3; pare;
caso V5 : C4; pare;
caso contrário: C5;
fim
50/80
Exemplos
1 – Construa um programa que leia um valor numérico inteiro e uma opção
de operação ( 1 – Raiz Quadrada, e 2 – Valor ao Quadrado) a qual o número
deve ser submetido.
principal ( )
inicio
inteiro num, op;
real resultado;
escreva(“Digite o valor inteiro: “);
escreva(“Escolha uma opção: “);
escreva(“1: Raiz ou 2: Quadrado: “);
leia(“ %i”, &op);
escolha(op)
inicio
caso 1: resultado  rad(num); pare;
caso 2: resultado  pot(num, 2);
fim
escreva(“O resultado é %r ”, resultado);
fim
Outra versão:
principal ( )
inicio
inteiro num, op;
escreva(“Digite o valor inteiro: “);
escreva(“Escolha uma opção: “);
escreva(“1: Raiz ou 2: Quadrado: “);
leia(“ %i”, &op);
escolha(op)
inicio
caso 1: escreva(“ O resultado é %r “,rad(num));
pare;
caso 2: escreva(“O resultado é %r “,pot(num, 2));
pare;
caso contrário: escreva(“Opção Inválida!!!!”);
fim
fim
Importante! A restrição da estrutura escolha é que o seletor só pode ser

variável do tipo inteiro ou um único caractere.
51/80
2 – Construa um algoritmo que leia um caractere, e determine se este é uma

vogal maiúscula, ou um digito numérico (caractere numérico), ou um
operador aritmetico, ou senão um outro caractere.
principal ( )
inicio
caractere car;
escreva(“Digite um caractere: “);
leia(“ %c”, &car);
escolha (car)
inicio
caso ‘A’: caso ’E’: caso ‘I’: caso ‘O’: caso‘U’: escreva(“Vogal maiúscula”);
pare;
caso ‘0’: caso ‘1’: caso ‘2’: caso ‘3’: caso ‘4’: caso ‘5’: caso ‘6’:
caso ‘7’: caso ‘8’: caso ’9’: escreva(”Valor numérico”);
pare;
caso ‘+’: caso ‘-’: caso ‘*’: caso ‘/’: escreva(“Operador aritmético”);
pare;
caso contrário : escreva(“Você digitou outro caractere”);
fim
fim
Exercícios de Fixação V
0000000
Comando de seleção múltipla

1. Faça um algoritmo que leia uma vogal maiúscula e imprima a vogal subseqüente.
Resolução:
principal ( )
inicio
caractere car;
escreva(“Digite uma vogal maiúscula: “);
leia(“ %c”, &car);
escolha (car)
inicio
caso ‘A’: escreva(“Vogal subsequente: E”);
pare;
caso ’E’: escreva(“Vogal subsequente: I”);
pare;
caso ‘I’: escreva(“Vogal subsequente: O”);
pare;
caso ‘O’: escreva(“Vogal subsequente: U”);
pare;
caso‘U’: escreva(“Vogal subsequente: A”);
pare;
caso contrário : escreva(“Você digitou outro caractere”);
fim
fim
52/80
2. Faça um algoritmo que leia um caractere e imprima a mensagem ‘É uma vogal!’,

caso o caractere lido seja uma vogal. Caso contrário imprima ‘O caractere lido não é
uma vogal!’.
Resolução:
principal ( )
inicio
caractere car;
//Entrada de dados
escreva(“Digite um caractere: “);
leia(“ %c”, &car );
//Processamento e saida de dados
escolha( car )
inicio
caso ‘A’: caso ‘a’: caso ‘E’: caso ‘e’: caso ‘O’: caso ‘o’: caso ‘U’: caso ‘u’:
caso ‘ I’: caso ‘i’: escreva(“ O caracter e uma vogal!”);
pare;
caso contrario: escreva(“O caractere lido não e uma vogal!”);
fim
fim
3. Faça um algoritmo que leia o mês e o ano (em números) e exiba o número de dias
do mês digitado.
Obs.: meses com 30 dias: 4, 6, 9, 11
meses com 31 dias: 1, 3, 5, 7, 8, 10, 12
fevereiro possui 28 dias em ano não bissexto e 29 dias em ano bissexto.
Um ano é identificado como bissexto quando for divisível somente por 4, ou
seja, ANO % 4 == 0. Se Ano também for divisível por 100 ele deve ser
divisível por 400. Exemplos de anos bissextos: 1996, 2000, 2004, 2012, 800,
1200, etc.
Anos que não são bissexto: 100, 700, 1000, 1999, 2014, etc.
Resolução:
principal( )
inicio
inteiro mês, ano;
//Entrada de dados
escreva(“Digite o mês e o ano em números: “);
leia(“%i%i”, &mês, &ano);

escolha( mês )
inicio
caso 4: caso 6: caso 9: caso 11: escreva(“ Mês com 30 dias!”); pare;
caso 1: caso 3: caso 5: caso 7:
caso 8: caso 10: caso 12: escreva(“ Mês com 31 dias!”); pare;
caso 2: se ( ano % 4 == 0 )
inicio
53/80
se (ano % 100 == 0 )
inicio
se(ano % 400==0)
escreva(“Ano Bissexto, mês com 29 dias”);
senão
escreva(“Mês com 28 dias”);
fim
senão
escreva(“Ano Bissexto, mês com 29 dias”);
fim
senão
escreva(“Mês com 28 dias”); pare;
caso contrário: escreva(“Mês Invalido!”);
fim
fim
4. Faça um algoritmo que leia o número de um mês e imprima o nome do mês por
extenso.
5. Faça um algoritmo que leia uma data (dia, mês e ano) em valores numéricos e a
imprima por extenso como mostrado no exemplo abaixo:
Lido: 21 04 1970
Escrito: 21 de abril de 1970
6. No curso de Introdução a Computação, a nota final do estudante é calculada a partir

de 3 notas atribuídas respectivamente a um trabalho de laboratório, a uma avaliação
semestral e a um exame final. As notas variam de 0 a 10 e a nota final é a média
ponderada das 3 notas mencionadas. A tabela abaixo fornece os pesos das notas:
trabalho de laboratório - peso 2
avaliação semestral - peso 3
exame final - peso 5
Faça um algoritmo que receba as 3 notas, calcule e imprima a média final e o
conceito desse estudante. O conceito segue a tabela abaixo:
Média Final Conceito
8.0 |___| 10.0 A
7.0 |___ 8.0 B
6.0 |___ 7.0 C
5.0 |___ 6.0 D
< 5.0 E
54/80
7. Faça um algoritmo que receba um código de origem (número inteiro) e imprima a sua
procedência. A procedência obedece à tabela abaixo. Caso um código inválido seja
digitado imprima uma mensagem de erro.
Código de Origem Procedência

1 Sul
2 Norte
3 Leste
4 Oeste
5 ou 6 Nordeste
7,8 ou 9 Sudeste
10 até 20 Centro-Oeste
21 até 30 Nordeste
Resolução:
principal ( )
inicio
inteiro codigo;
//Entrada de dados
escreva(“ Digite o codigo da região: “);
leia(“%i”, &codigo);
escolha( codigo )
inicio
caso 1: escreva(“Procedencia: Regiao Sul”);
pare;
caso 2: escreva(“Procedencia: Regiao Norte”);
pare;
caso 3: escreva(“Procedencia: Regiao Leste”);
pare;
caso 4: escreva(“Procedencia: Regiao Oeste”);
pare;
caso 5: caso 6: escreva(“Procedencia: Regiao Nordeste”);
pare;
caso 7: caso 8: caso 9: escreva(“Procedencia: Regiao Sudeste”);
pare;
caso contrário: se ( (codigo>=10)&&(codigo<=20)) então
escreva(“Procedencia: Regiao Centro-Oeste”);
senão
se (( codigo>=21)&&(codigo<=30))
escreva(“Procedencia: Regiao Nordeste”);
senão
escreva(“Codigo invalido”);
fim //escolha
fim//do algoritmo
8. Faça um algoritmo que receba o código correspondente ao cargo de um funcionário e

imprima seu cargo e o percentual de aumento ao qual este funcionário tem direito
seguindo a tabela abaixo:
55/80
Código Cargo Percentual

1 Escriturário 50%
2 Secretário 35%
3 Caixa 20%
4 Gerente 10%
5 Diretor não tem aumento
9. Faça um algoritmo que mostre um menu com as seguintes opções:
1. soma
2. multiplicação
3. finalizar
O algoritmo deve receber a opção desejada, receber os dados necessários para a
operação de cada opção, realizar a operação e imprimir o resultado. Na opção finalizar
nada deve acontecer.
10. Uma companhia de seguros tem três categorias de seguros baseadas na idade e
ocupação do segurado. Somente pessoas com pelo menos 18 anos e não mais de 70 anos
podem adquirir apólices de seguros. As classes de ocupações foram definidas em três
grupos de risco. A tabela a seguir fornece as categorias em função da faixa de idade e do
grupo de risco:
Código do Grupo de Risco

Idade Baixo Médio Alto
18 a 24 7 8 9
25 a 40 4 5 6
41 a 70 1 2 3
Faça um algoritmo que receba a idade (um número inteiro) e o grupo de

risco (representados pelos caracteres: ‘b’: baixo; ‘m’: médio ou ‘a’: alto) e
determine e imprima o código do seguro.
56/80
UNIDADE V – Comandos de Repetição
O que vamos ver:
 Comandos de Repetição com teste no início

 Comandos de Repetição com teste no final
 Comandos de Repetição com variável de controle
Definição: Comandos de Repetição

São comandos caracterizados por permitir que uma seqüência de
comandos seja executada um número repetido de vezes. (Lembrem-se do
exemplo inicial do algoritmo da troca da lâmpada )
1. Repetição com teste no início
Consiste de uma estrutura de controle do fluxo de execução que permite

repetir diversas vezes um mesmo trecho do algoritmo, porém, verificando
ANTES de cada execução se é permitido executar o mesmo trecho.
Forma geral do comando enquanto:

enquanto (<Condição>) faça
inicio
<comando1>;
<comando2>;
...
<comandon>;
fim
Obs.: O faça está sublinhado pois ele é opcional.
Antes da seqüência de comandos ser executada, a condição é avaliada.

Caso seja verdadeira, a seqüência será repetidamente executada
enquanto a condição permanecer verdadeira.
Note que se a condição for falsa já na primeira avaliação, a seqüência de

comandos não será executada.
A condição deverá se tornar falsa em algum momento, caso contrário a

seqüência será executada indefinidamente (Loop infinito).
57/80
Exemplo 1: Mostrar os números inteiros de 1 a 10.

principal ( )
inicio
const inteiro maior = 10;
inteiro i;
i  1;
escreva(“ Números inteiros de 1 até %i: “, maior);
enquanto ( i <= maior) faça
início
escreva ( “%i “, i);
i  i + 1;
fim
fim
A aplicação do comando enquanto se dá em problemas onde o número de
repetições não é conhecido. O exemplo anterior tem apenas exemplo
didático, pois existe outro comando mais apropriado para este caso.
Exemplo 2: Ler uma seqüência de salários terminada por um salário
menor que zero. Para cada salário, mostrar o novo salário reajustado e, ao
final, a média dos salários reajustados. O valor do reajuste deve ser lido
no início do algoritmo.
principal ( )
início
real salario, reajuste, novo_sal, tot_reaj, media;
inteiro num_sal;
tot_reaj  0;
num_sal  0;
escreva (“Entre com o reajuste : “);
leia (“%r”, &reajuste);
escreva (“Entre com o salário ou salário negativo para parar: “);
leia (“%r”, &salario);
enquanto ( salario > 0) faça
início
novo_sal  salario + (salario * reajuste) / 100;
tot_reaj  tot_reaj + novo_sal;
num_sal  num_sal + 1;
escreva (“Salário reajustado: %r “, novo_sal);
escreva (“Entre com o salário ou salário negativo para parar: “);
leia (“%r”, &salario);
fim
se (num_sal > 0) então
início
media  tot_reaj / num_sal;
escreva (“Média dos salários = %r “, media);
fim
senão
escreva (“Não existem dados a serem processados”);
fim
58/80
Exemplo 3: Ler uma seqüência de vogais terminada por ponto e exibir os

totais de vogais e não vogais encontradas.
Resolução:
principal ( )
início
const caractere fim = `.`;
caractere car;
inteiro cont_a, cont_e, cont_i, cont_o, cont_u, outros;
cont_a  0; cont_e  0; cont_i  0;

cont_o  0; cont_u  0; outros  0;
escreva (“Entre com o primeiro caractere ou . para parar: “);
leia (“ %c”, &car);
enquanto ( car != fim) faça
início
escolha (car)
inicio
caso ‘a’: caso ‘A’ : cont_a  cont_a + 1; pare;
caso ‘e’: caso ‘E’ : cont_e  cont_e + 1; pare;
caso ‘i’ : caso ‘I’ : cont_i  cont_i + 1; pare;
caso ‘o’: caso ‘O’ : cont_o  cont_o + 1; pare;
caso ‘u’: caso ‘U’ : cont_u  cont_u + 1; pare;
caso contrário: outros  outros +1;
fim
escreva (“Entre com o próximo caractere ou . para parar: “);
leia (“ %c”, &car);
fim
escreva (“O total de a’s é: %i “, cont_a);
escreva (“O total de e’s é: %i “, cont_e);
escreva (“O total de i’s é: %i “, cont_i);
escreva (“O total de o’s é: %i “, cont_o);
escreva (“O total de u’s é: %i “, cont_u);
escreva (“O total de outros é: %i “, outros);
fim
59/80
2. Repetição com teste no final
Para realizar uma repetição com teste no final, utilizamos a estrutura

faça enquanto, que permite que o bloco ou ação primitiva seja repetido
enquanto uma determinada condição seja verdadeira. O modelo genérico
desse tipo de repetição é o seguinte:
faça
início
<comando1>;
<comando2>;
...
<comandon>;
fim
enquanto(<Condição>);
Este comando, assim como o comando ENQUANTO, é usado quando não

é conhecido o número de vezes que uma seqüência de comandos deverá
ser executada. Porém a seqüência será executada pelo menos uma vez,
visto que a avaliação da condição é feita ao final de cada interação.
A seqüência será executada repetidamente até que a condição seja falsa.

Esta condição deve ser uma expressão que retorne um valor lógico.
A condição deverá se tornar falsa em algum momento, caso contrário a

seqüência será executada indefinidamente (Loop infinito).
Exemplo 4: Mostrar os números inteiros de 1 a 10.

principal ( )
início
inteiro i;
i  1;
faça
inicio
escreva (” %i “, i);
i  i + 1;
fim
enquanto (i <= maior);
fim
A aplicação do comando faça enquanto se dá em problemas onde o

número de repetições não é conhecido, mas se deseja que a seqüência de
comandos seja executada pelo menos uma vez. O exemplo anterior tem
apenas exemplo didático, pois existe um outro comando mais apropriado
para este caso.
60/80
Exemplo 5: Mostrar os números inteiros de 1 a 10, sendo que para cada

número mostrado o algoritmo deve aguardar que sejam pressionadas a
tecla C e ENTER para continuar.
principal ( )
início
inteiro i ;
caractere tecla ;
i  1;
faça
inicio
escreva (“%i “, i);
i  i+ 1;
faça
inicio
escreva (“tecle [C] para continuar…”);
leia (“ %c”, &tecla);
fim
enquanto ((tecla != ‘c’ ) e (tecla != ‘C’));
fim
enquanto (i <= maior);
fim
3. Repetição com variável de controle
Nas estruturas de repetição vistas até agora, ocorrem casos em que se

torna difícil determinar o número de vezes em que o bloco de comandos
será executado. Sabemos que ele será executado enquanto uma condição
for satisfeita. A estrutura para é diferente, já que sempre repete a
execução do bloco de comandos um número determinado de vezes, pois ela
não prevê uma condição e possui limites fixos.
Modelo genérico:
para (< inicialização da var> ; <condição de repetição> ; <incremento da var>)
início
<comando1>;
<comando2>;
...
<comandon>;
fim
O comando para é utilizado quando se deseja executar uma seqüência de
comando repetidamente, um número conhecido e fixo de vezes.
O número de vezes é controlado pela variável de controle <var>. Na

primeira parte < inicialização da var> inicializa a variável de controle
quando o comando é executado pela primeira vez. A segunda parte
<condição de repetição> testa se a repetição deve continuar e a terceira
61/80
parte incrementa a variável de controle <var> (que geralmente é de uma

unidade).
Nos exemplos abaixo a seqüência será executada 10 vezes.
Exemplo 5: Mostrar os números inteiros de 1 a 10 e de 10 a 1.

principal ( )
início
inteiro i;
para( i  1 ; i<= maior ; i  i + 1)
início
escreva (“ %i “, i);
fim
escreva(“ Números inteiros de %i até 1: “, maior);
para (i  10 ; i>= 1 ; i  i -1)
início
escreva (“ %i “, i); //neste caso, o início/fim são dispensáveis (Apenas um comando)
fim
fim
O incremento/decremento da variável de controle é na maioria das vezes

igual a 1 ou -1.
Geralmente o tipo da variável de controle é inteiro.
O que aconteceria se maior = 0 ?
Exercícios de Complementares: Comando Enquanto

01. Escreva um algoritmo que receba a idade de um grupo de pessoas,
calcule e imprima a quantidade de pessoas maiores de idade (idade >= 18
anos). Para encerrar a entrada de dados, deve ser digitado um valor < 0.
Resolução:
principal ( )
inicio
inteiro idade, cont  0;
escreva(“Digite a primeira idade ou idade < 0 para parar: “);

leia(“%i”, &idade);
enquanto ( idade >= 0 ) faça

inicio
se ( idade >= 18 ) então
cont  cont + 1;
escreva(“Digite a proxima idade ou idade < 0 para parar: “);
62/80
fim
se ( cont > 0 ) então

escreva ( “ Total que atingiu a maioridade: %i “, cont);
senão
escreva(“ Ninguém atingiu a maioridade!”);
fim
02. Escreva um algoritmo que receba a idade de um grupo de pessoas,

calcule e imprima a porcentagem de cada faixa etária em relação ao total de
pessoas.
As faixas etárias são:

01 - 15 anos - A
16 - 30 anos - B
31 - 45 anos - C
46 - 60 anos - D
>= 61 anos - E
Para encerrar a entrada de dados, digite uma idade <= 0.
03. Escreva um algoritmo que receba um conjunto de valores inteiros e

positivos,calcule e imprima o maior e o menor valor do conjunto.
 Para encerrar a entrada de dados, deve ser digitado o valor zero.
 Para valores negativos, deve ser enviada uma mensagem.
 Esses valores (zero e negativo) não entrarão nos cálculos.
04. Faça um algoritmo que apresente um menu de opções (apresentado

abaixo) para o cálculo das operações entre dois números reais lidos
previamente:
Programa Calculadora
[1] – adição
[2] – subtração
[3] – multiplicacao
[4] – divisão
[5] – sair do programa
Escolha uma opcao:
Possibilitar ao usuário escolher a operação desejada, mostrar o resultado e
voltar ao menu de opções. O programa só deve permitir a saída se o usuário
teclar 5.
05. Faça um algoritmo receba o valor e o código de várias mercadorias

vendidas em um determinado dia. Os códigos obedecem a tabela abaixo:
“L” ou “l” - limpeza

“A” ou “a” - alimentação
“H” ou “h” - higiene
63/80
Calcule e imprima:
 total vendido naquele dia, com todos os códigos juntos;
 total vendido naquele dia em cada um dos códigos.
Para encerrar a entrada de dados, digite o valor da mercadoria zero.
Exercícios Complementares: Comando faça/enquanto:
01. Faça um algoritmo que receba como entrada, uma lista de números
positivos ou negativos finalizada com o número zero e forneça, como
saída, a soma dos números positivos, a soma dos números negativos
e a soma das duas parciais.
Resolução:
principal ( )
inicio
inteiro num, soma_pos  0, soma_neg  0, soma_total;
//Entrada e processamento de dados
faça
inicio
escreva(“Digite um numero inteiro ou 0 para parar: “);
se ( num != 0 ) entao
inicio
se ( num > 0 ) entao
soma_ pos  soma_pos + num;
senao
soma_neg  soma_neg + num;
fim // fim se/entao
fim // fim do bloco faça/enquanto
enquanto ( num != 0 );
soma_total  soma_pos + soma_neg;
//Saída de dados
escreva(“Soma dos positivos: %i “, soma_pos);
escreva(“Soma dos negativos: %i “, soma_neg);
escreva(“Soma Total: %i “, soma_total);
fim
02. Faça um algoritmo que receba a idade e a altura de várias pessoas,

calcule e imprima a média das alturas das pessoas com mais de 50 anos.
Para encerrar a entrada de dados, digite idade <= zero.
03. Construa um algoritmo que leia um conjunto de valores inteiros e

positivos, e determine qual o menor e o maior valor do conjunto. Para valor
final de entrada considerar o valor -1 que não deve ser considerado.
Exercícios Complementares: Comando para:

01. Escreva um algoritmo para calcular N! (fatorial de N), sendo que o valor
inteiro de N é fornecido pelo usuário.
Sabe-se que: N! = 1 * 2 * 3 * ... * (N-1) * N;
0! = 1
64/80
Resolução:
principal ( )
inicio
inteiro num, fat  1, i;
//Entrada de Dados com tratamento de erro
faça
inicio
escreva(“Digite um numero inteiro >=0: “);
se ( num < 0 ) então
escreva(“Numero Invalido!”);
fim
enquanto( num < 0 );
para( i  2; i < = num; i  i + 1 )
fat  fat * i ;
//Saída de dados
escreva ( “%i ! = %i “, num, fat);
fim
02. A conversão de graus Farenheit para Centígrados é obtida por C = (5/9.0)

* (F - 32). Faça um algoritmo que calcule e escreva uma tabela de graus
Centígrados e os graus Farenheit, que variam de 50 a 65 de 1 em 1.
03. Faça um algoritmo que receba a idade e o estado civil : C - casado, S -

solteiro, V - viúvo e D - desquitado, de 10 pessoas. Calcule e imprima:
 a quantidade de pessoas casadas;

 a média das idades das pessoas viúvas.
Lembre-se do exercício 11 de algoritmos em Portugol:
11 - Faça um algoritmo que receba um número inteiro, calcule e

imprima a tabuada desse número.
Resolução:
principal ( )
inicio
inteiro i, num;
//Entrada de dados
escreva(“Digite um numero para a tabuada: “);
escreva(“A tabuada de multiplicação do numero %i: “, num);
para ( i  1; i <= 10; i  i + 1 )
escreva(“ %i * %i = %i “, num, i, i * num);
fim
65/80
Rastreamento
Memória Tela
i: 1, 2, 3, 4, 5, Digite um numero para a tabuada: 2 <Enter>
6, 7, 8, 9, 10, 11 2* 1=2
num: 2 2* 2=4
2* 3=6
2* 4=8
2 * 5 = 10
2 * 6 = 12
2 * 7 = 14
2 * 8 = 16
2 * 9 = 18
2 * 10 = 20
Exercícios de Fixação VI
1. Faça um algoritmo que imprima todos os números inteiros no intervalo

[0, 100].
2. Faça um algoritmo que leia uma seqüência de N números positivos e

calcule e imprima a média aritmética entre eles. A leitura é encerrada
quando um número negativo ou nulo for digitado.
3. Faça um algoritmo que leia o peso, em quilogramas, de N bois e calcule e

imprima:
 o peso médio do rebanho;
 o peso do boi mais gordo; e
 o peso do boi mais magro.
Encerre a leitura quando um peso nulo for digitado.
4. Faça um algoritmo que leia 50 dados contendo as medidas de diferentes

retângulos (base, altura), e emita um relatório contendo o perímetro e a
área de cada retângulo.
5. Escreva um algoritmo que encontre o maior e o segundo maior número

de uma série de números lidos do teclado.
Obs: - Use uma marca (um flag) para a saída do comando de repetição, uma
vez que o número de repetições não é conhecido.
6. Faça um algoritmo que leia uma seqüência de números inteiros positivos

(um por vez), e verifique se eles são pares ou impares.
Obs: - Use uma marca (um flag) para a saída do comando de repetição, uma
vez que o número de repetições não é conhecido.
66/80
7. Seja S = 2, 3, 5, 8, 13, 21, 34, 55, ... um exemplo de uma série de

Fibonacci. Perceba que o padrão de comportamento desta série é tal que
cada número a partir do terceiro é a soma dos dois anteriores. Escreva
um algoritmo que gere uma série de Fibonacci até o n-ésimo termo, onde
n será um valor lido.
Dica: - leia os dois primeiros termos.
Resolução:
principal ( )
inicio
inteiro n, t1 2, t2  3, t3, cont  2;
//Entrada de dados com trat. de erro
faça
inicio
escreva(“Entre com o numero de termos ( >=3): “);
leia(“%i”, &n );
se ( n < 3 ) então
escreva(“Numero de termos invalido!”);
fim
enquanto( n < 3 );
escreva(“Serie de Fibonacci: %i %i “, t1, t2);
enquanto( cont < n )
inicio
t3  t1 + t2;
escreva( “ %i “, t3);
t1  t2;
t2  t3;
cont  cont + 1;
fim
fim
8. Dada a série: 2 3 4 9 16 29 54 99... onde cada elemento a partir do

quarto é a soma dos três termos que lhe antecedem. Faça um algoritmo
que leia apenas os três termos iniciais, que podem ser quaisquer, e, a
partir daí, obtenha e imprima mais 20 termos da referida série.
9. Faça um algoritmo que calcule e imprima o valor da soma:

S = 1 + 3 + 5 + 7 + ... + 99
1 2 3 4 50 Obs.: Note que o resultado da soma S
deve ser real para este somatório fazer sentido.
10. Faça um algoritmo para calcular o valor da equação abaixo. Onde o valor
de n será lido pelo teclado e deve ser maior ou igual a 5.
n
 6
2
S k = 6/12 + 6/22 + … + 6/n2 (Obs.: O valor do somatório
k 1
deve ser real para fazer sentido estes quocientes)
67/80
11. Faça um algoritmo que leia um conjunto de 30 matrículas dos

vendedores de uma firma comercial, juntamente com os respectivos
totais de vendas diárias e verifique quantos deles estão na faixa
compreendida entre R$500.00 e R$1500.00. Imprima uma listagem
contendo todas as matrículas das pessoas situadas no intervalo
especificado, bem como o total delas.
12. Faça um algoritmo que leia uma seqüência de N (o valor de N é lido

durante a execução do algoritmo) conjuntos de dados, cada conjunto
contendo a conta do correntista de uma caderneta de poupança e seu
respectivo saldo médio. Imprima:
a) o total de clientes bons, clientes que possuem o saldo médio entre 500
e 1000 reais;
b) o total de clientes razoáveis, clientes que possuem o saldo médio
menor 500 reais;
c) o número da conta com maior saldo médio.
13. Faça um algoritmo que leia 80 números reais, imprima o menor e o

número de vezes que ele aparece.
Resolução:
principal ( )
inicio
real num, menor;
inteiro vezes , i;
escreva(“Digite o 1o numero real: “);

leia(“%r”, &num );
menor  num;
vezes  1;
para ( i 2; i<= 80; i  i+1)

inicio
escreva(“Digite o %io numero real: “, i );
leia(“%r”, &num );
se ( num < menor)
inicio
menor  num;
vezes  1;
fim
senão
se ( num == menor )
vezes  vezes + 1;
fim
escreva(“O menor numero foi %i e apareceu %i vezes“, menor, vezes);
fim
68/80
14. O sistema de avaliação de uma determinada disciplina obedece aos

seguintes critérios :
 durante o ano letivo são dadas três notas.
 a nota final é obtida pela média aritmética das notas dadas durante
o curso.
 é considerado aprovado o aluno que obtiver a nota final superior ou
igual a 7.0 e que tiver comparecido a um mínimo de 40 aulas.
Faça um algoritmo que:
a) Leia um conjunto de dados contendo a matricula, as três notas e a
freqüência de 100 alunos.
b) Imprima:
 para cada aluno, o número de matricula, a freqüência, a nota
final e uma mensagem informando se este esta aprovado ou
reprovado;
 a maior e a menor nota da turma;
 a nota média da turma; e
 o total de alunos reprovados.
15. Faça um algoritmo que leia uma seqüência de dados contendo a

matrícula e a medida da altura dos funcionários de uma empresa e
imprima:
 altura média dos funcionários;
 o total de funcionários baixos (altura inferior a 1.55 m); e
 o total de funcionários de altura mediana (1.55m <= Altura <=
1.75m).
Obs: - utilize uma marca (um flag) para indicar o final da entrada de dados.
16. Um serviço de correspondência sentimental mantém um fichário de seus

clientes. Cada ficha contém as seguintes informações: Matrícula, Sexo
(M, m, F ou f), Idade, Altura (em m), Peso (em quilogramas), Cor dos
olhos (1-azul, 2-castanhos, 3- outros), Cor dos cabelos (1- ruivos, 2- loiros,
3- outros).
Prepare um algoritmo que leia este fichário e imprima as matrículas
de:
 Todos os homens loiros de olhos castanhos, altura maior que 1.75 m,
pesando entre 75Kg e 95 Kg.
 Todas as mulheres ruivas de olhos azuis, altura entre 1.65 m e 1.75
m, pesando menos de 60 Kg.
Resolução:
//Usarei a digitação de uma matricula negativa ou nula como flag de parada
principal ( )
inicio
inteiro matricula, idade, cor_olhos, cor_cab;
real altura, peso;
69/80
caractere sexo;
faca
inicio
escreva(“Digite a matricula ou matricula <= 0 para parar: “);
leia(“%i”, &matricula);
se ( matricula > 0 )
inicio
escreva(“Sexo (m ou f): “);
leia(“ %c”, &sexo);
escreva(“Idade: “);
escreva(“Altura e peso: “);
leia(“%r%r”, &altura, &peso);
escreva(“Cor dos olhos: “);
escreva(“1. Azul ou 2. Castanho ou 3. Outros “);
leia(“%i”, &cor_olhos);
escreva(“Cor dos cabelos: “);
escreva(“1. Ruivos ou 2. Loiros ou 3. Outros “);
leia(“%i”, &cor_cab);
se ( (sexo == ‘F’) ||(sexo==’f’))
se ( cor_cab == 1 )
se (cor_olhos == 1 )
se ( (altura>=1.65) && ( altura<=1.75))
se ( peso < 60)
escreva(“A matricula e %i “, matricula);
se ( (sexo == ‘M’) ||(sexo==’m’))

se ( cor_cab == 2 )
se (cor_olhos == 2 )
se ( altura>1.75)
se ( (peso >= 75) && ( peso <=95))
escreva(“A matricula e %i “, matricula);
fim//se matricula
fim
enquanto(matricula>0);
fim
17. Faça um algoritmo à ser fornecido ao Detran para provimento das

informações abaixo descritas, referentes a acidentes em estradas:
 percentagem de motoristas não-habilitados;
 percentagem de homens no volante; e
 percentagem de motoristas inexperientes (menos de 20 anos).
Os dados de entrada contém o ano de nascimento, o sexo e o código de
habilitação dos motoristas, sendo: Código de Habilitação = 1 - motorista
habilitado e Código de Habilitação = 2 - motorista não-habilitado.
70/80
18. Faça um algoritmo que teste a validade de uma senha digitada no

teclado. A digitação deve ser refeita até que a senha correta seja digitada
ou o número de tentativas seja maior que 5. A senha correta é o número
12345.
19. Faça um algoritmo que tendo lido uma vogal minúscula imprima sua
correspondente maiúscula. Repita a leitura quantas vezes for necessário
até que uma vogal maiúscula seja digitada como entrada.
20. Faça um algoritmo que leia um número inteiro no intervalo [1, 12] e
imprima o nome do mês correspondente. Garanta que somente números
no intervalo [1, 12] serão aceitos.
21. Faça um algoritmo que imprima a soma de todos os inteiros no intervalo

[5, 30].
22. Faça um algoritmo que leia N notas, N é lido, calcule e imprima a média
aritmética entre elas.
23. Faça um algoritmo que leia 50 números e imprima o menor e o maior.
24. Dada a série 2 3 4 9 16 29 54 .... Faça um algoritmo que leia os três

primeiros termos e em seguida imprima os próximos 20 termos.
25. Faça um algoritmo que leia o preço e o código de 20 mercadorias

presentes em uma cesta básica. Os códigos obedecem à tabela abaixo:
‘l’ ou ‘L’ : limpeza
‘a’ ou ‘A’ : alimentação
‘h’ ou ‘H’ : higiene
Calcule e imprima:
- o preço total da cesta básica; e
- para cada código, o preço total das mercadorias presentes na cesta.
26. De posse de um conjunto de dados contendo a altura e o sexo (F, f, m ou

M) de 15 pessoas. Faça um algoritmo que calcule e imprima:
 a maior e a menor altura do grupo;
 a altura média das mulheres; e
 o número de homens.
27. A conversão de graus Farenheit para Celsius é obtida por C = 5/9*(F-32).

Faça um algoritmo que calcule e escreva uma tabela de equivalência
entre graus Celsius e graus Farenheit, com os valores variando de 1 em 1
de 50 a 65 graus Farenheit.
28. Uma empresa decidiu fazer um levantamento dos seus 500 funcionários.
Faça um algoritmo que leia para cada funcionário a idade, o sexo (F, f, m
71/80
ou M), experiência de mais de 3 anos no serviço (S, s, n ou N). Calcule e

escreva:
 o número de funcionários do sexo feminino;
 o número de funcionários do sexo masculino;
 a idade média dos homens com mais de 3 anos de experiência no
serviço;
 a porcentagem dos homens com mais de 45 anos entre o total de
homens;
 o número de mulheres com idade inferior a 35 anos com mais de 3
anos de experiência; e
 a menor idade entre as mulheres com experiência no serviço.
29. Faça um algoritmo que imprima as tabuadas de multiplicação dos

números de 1 a 10.
30. Faça um algoritmo que receba 2 notas de 10 alunos. Calcule para cada
aluno sua média e imprima uma mensagem de acordo com a tabela
abaixo:
Média Mensagem
Abaixo de 3 Aluno Reprovado
Entre 3 e 7 Aluno de Recuperação
Maior ou igual a 7 Aluno Aprovado
72/80
UNIDADE VI – Estrutura de Dados Composta Homogênea e

Unidimensional
O que vamos ver:
 Vetores
 Tipos Estruturados
 Variáveis Compostas Homogêneas
 Variáveis Compostas Unidimensionais – VETORES
1. Vetores
Retornando ao conceito de informações e tipos de informação, podemos notar
que foi feita uma divisão imaginária, a fim de tornar mais simples a
classificação das informações. Talvez alguns já tenham notado que a
quantidade de tipos de dados primitivos não é suficiente para representar
toda e qualquer informação que possa surgir. Portanto, em muitas situações,
esses recursos são escassos, o que poderia ser suprido se existissem mais
tipos de dados ou, ainda melhor, se esses tipos pudessem ser “construídos”,
criados, à medida que se fizessem necessários.
2. Tipos Estruturados
São organizações de dados construídas a partir da composição dos tipos
primitivos já existentes (caractere, inteiro, real). Esses novos tipos podem
armazenar um conjunto de dados conhecidos como variáveis compostas. As
variáveis que armazenam esses tipos de dados podem ser classificadas em:
variáveis compostas homogêneas e variáveis compostas heterogêneas.
3. Variáveis Compostas Homogêneas
São variáveis que armazenam vários elementos do mesmo tipo primitivo.
Exemplo: alcatéia (vários lobos), conjunto de números inteiros, e outros.
As variáveis compostas são estruturas de dados (armazenam um conjunto

de dados). Esses dados podem ser armazenados em dois tipos de variáveis:
as variáveis unidimensionais (conhecidas como vetores) e as variáveis
multidimensionais (conhecidas como matriz).
4. Variáveis Compostas Unidimensionais - VETORES

São variáveis que necessitam de apenas um índice para individualizar um
elemento do conjunto.
Exemplo:
real media[40];
ou usando uma constante:
const inteiro TAM=40; // const int TAM = 40;
73/80
real media[TAM]; // float media[TAM];
Estrutura que se forma:
media:
0 1 2 3 4 5 6 ... ... 39
8.0 7.0 5.5 9.5 6.4 9.9 1.0 4.8
Para acessar cada elemento da variável composta unidimensional (vetor) é

necessário especificar o nome da variável seguido do número do elemento
que se deseja acessar (deverá estar entre colchetes). Este número tem o
nome de índice. O índice pode varia de 0 até n-1 (onde n é o número que
representa a quantidade de variáveis simples do vetor).
Exemplos de utilização de um vetor:
leia (“%r”, &media[1]); // scanf(“%f”, &media[1]);
media [2]  8.5; // media[2] = 8.5;
escreva(“ %r “, media[3]);// printf(“%.2f\n”, media[3]);
.......
Exemplo 1: Dados 5 valores numéricos reais elaborar um algoritmo que
calcule e exiba a média dos valores dados e quantos desses valores estão
acima da média.
a) Resolução sem utilizar vetor:
principal ( )
início
inteiro cont ;
real n1, n2, n3, n4, n5, media;
cont 0;
escreva(“ Digite o 1º número: “);
leia (“%r”, &n1);
leia (“%r”, &n2);
leia (“%r”, &n3);
leia (“%r”, &n4);
leia (“%r”, &n5);
media  (n1+n2+n3+n4+n5)/5;
escreva(“A média dos números é %r“, media);
se (n1>media) então
cont  cont + 1;
cont  cont + 1;
cont  cont + 1;
74/80
cont  cont + 1;
cont  cont + 1;
escreva(“Quantidade de números acima da média é %i“, cont);
fim
b) Resolução utilizando variável composta:
principal ( )
início
const inteiro qn = 5; // Quantidade de números
real media, numeros[qn], soma;
inteiro i, cont;
cont  0; soma 0; // Inicialização das variáveis contadora e
// acumuladora
escreva(“Digite os %i números:”, qn);

para (i0; i < qn ; i  i+1)
início
escreva(“Digite o %io número: “, i+1);
leia(“%r”, &numeros[i]);
fim
para (i0; i < qn ; i  i+1)

soma soma + numeros[i];
media  soma/qn;
escreva(“ A média dos números é: %r “, media);
para (i0; i < qn ; i  i+1)

inicio
se (numeros[i]>media) então
cont  cont +1;
fim
escreva(“ Quantidade de números acima da média: %i “, cont);
fim
Exemplo 2 – Elabore um algoritmo que leia, some e imprima o resultado da

soma entre dois vetores inteiros de 50 posições.
Resolução:
principal ( )
início
const inteiro TAM = 50; // Tamanho do vetor
inteiro vet_a[TAM], vet_b[TAM], vet_r[TAM]; // Declaração dos vetores;
inteiro i; // Declaração da var. inteira a ser utilizada para índice
// Entrada de dados para os dois vetores:
para (i 0; i<TAM; i i+1)
inicio
75/80
escreva(“Digite o %io número do vetor a: “, i+1);

leia(“%i”, &vet_a[i]);
escreva(“Digite o %io número do vetor b: “, i+1);
leia(“%i”, &vet_b[i]);
fim
// Processamento de dados
vet_r[i]  vet_a[i] + vet_b[i];
// Saída de dados
escreva (“ Vetor soma: “);
escreva(“ %i”, vet_r[i]);
fim
Exercícios Propostos:
1) Dado um vetor contendo 10 elementos numéricos elabore um
algoritmo que verifique se outro valor dado pertence ou não ao vetor, se
pertencer exibir quantas vezes ele aparece no vetor. Caso contrário, mostrar
uma mensagem informando que o número não está no vetor.
2) Considere um vetor de tamanho máximo 100 de números reais.

Solicite ao usuário qual o limite superior válido que ele deseja e em seguida
desenvolva um algoritmo que leia o vetor até o limite superior escolhido e
determine qual é o menor valor existente no vetor. O algoritmo deve ainda
subtrair de todos os elementos este valor. Exibir o vetor resultado.
3) Faça um algoritmo que receba as notas da primeira prova de 10

alunos e armazene essas notas em um vetor. Receba as notas da Segunda
prova de 10 alunos e armazene essas notas em outro vetor. Calcule e
imprima a média entre essas duas notas de cada aluno.
4) Faça um algoritmo que receba as médias de 10 alunos e armazene

essas média em um vetor. Calcule e imprima:
- a média da classe;
- a quantidade de alunos aprovados, isto é, com média >= 7;
- a quantidade de alunos reprovados, isto é, com média < 7.
5) Faça um algoritmo que receba a temperatura média de cada mês do

ano e armazene essas temperaturas em um vetor; calcule e imprima a maior
e a menor temperatura do ano e em que mês estas temperaturas
aconteceram.
76/80
Exercícios de Fixação VII
1 . Faça um algoritmo que leia um vetor de 40 valores inteiros. Imprima os

índices onde o número 23 aparece.
2. Faça um algoritmo que leia dois vetores A e B de 30 componentes. Gere o

vetor C, do mesmo tipo de A e B, onde cada elemento de C é a subtração do
elemento correspondente de A com B.
3. Faça um algoritmo que tendo lido 2 vetores, A e B, de 20 e 30 elementos,

respectivamente, construa um vetor C composto pela junção dos vetores A e
B.
Por exemplo:
const inteiro tam1 = 20, tam2 = 30;

inteiro vet_a[tam1], vet_b[tam2], vet_c[tam1+tam2];
Exemplo:
vet_a:
0 1
8 7
vet_b:
0 1 2
17 13 55
vet_c:
0 1 2 3 4
8 7 17 13 55
4. Faça um algoritmo que leia um vetor A de 100 componentes. Construa um

vetor B, do mesmo tipo do vetor A, observando a seguinte lei de formação: se
o índice do componente em B é par este deve receber o componente
correspondente em A multiplicado por 2; se o índice em B é impar este
recebe o componente correspondente em A.
Exemplo:
Vet_a:
0 1 2 3 4 5 6 ... ... 99
8 7 5 9 6 9 1 4
Vet_b:
0 1 2 3 4 5 6 ... ... 99
16 7 10 9 12 9 2 4
77/80
5. Faça um algoritmo que leia a nota dos 60 alunos da disciplina de

programação e imprima:
 A nota média da turma
 A menor e a maior nota da turma
 O total de alunos cuja nota é inferior a nota média da turma
6. Faça um algoritmo que leia 50 notas e 50 matrículas dos alunos de

Programação. Informe os números de matrícula dos alunos cuja nota é
inferior à nota média da turma.
7. Um armazém trabalha com 100 mercadorias diferentes identificadas

pelos números inteiros de 1 a 100. O dono do armazém utiliza uma tabela
para guardar o preço de cada mercadoria. A tabela tem o formato mostrado
abaixo:
1 2 3 4 5 ... 100
5 20 10 8 54 ... 4.5
onde, a posição 1 armazena o preço da mercadoria identificada pelo
número 1, e assim por diante.
Faça um algoritmo que tendo lido uma tabela com o formato acima
imprima o número das mercadorias cujo preço é maior que 5 reais.
8. Faça um programa C que tendo lido um vetor VET de 10 números inteiros

positivos, crie um novo vetor VETPAR com os elementos pares do vetor
VET. Antes de preencher o vetor VETPAR com os números pares de VET
faça com que todos os componentes de VETPAR recebam o valor zero.
Exemplo:
0 1 2 3 4 5 6 7 8 9
Vetor VET = 2 9 7 5 10 4 3 1 6 21
0 1 2 3 4 5 6 7 8 9
Vetor VETPAR = 2 10 4 6 0 0 0 0 0 0
Mostre os dois vetores (VET e VETPAR) sendo que de VETPAR queremos

exibir somente os números de VET.
9. Faça um algoritmo que leia dois vetores de 10 elementos do tipo real.

Intercale os elementos destes dois vetores criando um novo vetor de 20
elementos.
Exemplo:
Vetor1
0 1 2 3 4 5 6 7 8 9
78/80
2 9 7 5.5 10 4 3 -1 6 21
Vetor2
0 1 2 3 4 5 6 7 8 9
32 -4 12 6 90 -4 5 43 27 82
Vetor criado a partir dos anteriores
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
2 32 9 -4 7 12 5.5 6 10 90 4 -4 3 5 -1 43 6 27 21 82
10. Faça um algoritmo que leia as médias os alunos da turma de

Programação. Calcule a média da turma e imprima as médias maiores ou
iguais a média da turma. Considere que a turma possua no máximo 60
alunos e que existe a possibilidade de não estar completa.
11. Faça um algoritmo que leia 2 vetores, vetor_1 e vetor_2, de 30 elementos

e informe quantas vezes cada elemento de vetor1 aparece no vetor_2.
Exemplo: Considere os vetores abaixo:
Vetor1
0 1 2 3 4
2 9 7 5 1
Vetor2
0 1 2 3 4
2 -4 2 7 5
A saída de dados deve ser:
O 1o numero do vetor 1 ( 2 ) apareceu 2 vez(es) no vetor 2

O 2o numero do vetor 1 ( 9 ) NAO apareceu no vetor 2
O 5o numero do vetor 1 ( 1 ) NAO apareceu no vetor 2
12. Uma empresa comercializa uma peça especial para a fábrica da Ferrari.
O preço da peça é determinado mensalmente de acordo com uma tabela
anual (vetor). Faça um programa C que receba a quantidade de peças
vendidas por MÊS e armazene essas quantidades em um vetor. Receba
também o preço que a peça foi comercializada e armazene esses preços em
outro vetor. Em seguida o programa deve: (a) Calcular e mostrar o total de
peças vendidas e (b) calcular e mostrar o faturamento bruto total da
empresa em um ano (quantidade * preço).
79/80

Algoritmos PC

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Algoritmos PC

Enviado por

Direitos autorais:

Formatos disponíveis

2020

Professor Erlon Pinheiro

UNIDADE I – Introdução à Lógica de Programação

O que vamos ver:

O uso corriqueiro da palavra lógica está normalmente relacionado à

Lógica é a “arte de bem pensar”, que é a “ciência das formas do

Todo mamífero é um animal.

Espírito Santo é um estado do Brasil.

2. EXISTE LÓGICA NO DIA-A-DIA ?

Sempre que pensamos, a lógica ou a ilógica necessariamente nos

Anacleto é mais velho que Felisberto.

3. MAS E A LÓGICA DE PROGRAMAÇÃO?

Significa o uso correto das leis de pensamento, da “ordem da razão” e de

O raciocínio é algo abstrato, intangível. Os seres humanos têm a capacidade

Na medida em que precisamos especificar uma seqüência de passos,

Exemplo de Algoritmo: receita de bolo.

Por que é Importante Construir um Algoritmo?

Um algoritmo tem por objetivo representar mais fielmente o raciocínio

Outra importância da construção dos algoritmos é que, uma vez concebida

A troca de uma lâmpada.

Involuntariamente, já seguimos uma determinada seqüência de ações que

A sequenciação é uma convenção com o objetivo de reger o fluxo de execução

O algoritmo tem um objetivo bem definido: trocar uma lâmpada. Porém, e se

A execução das ações conduziria a uma troca, independentemente de a

Agora estamos ligando algumas ações à condição lâmpada não acender, ou

A solução apresentada está aparentemente adequada, porém, não prevê a

A condição lâmpada não acender permaneceu, e estabelecemos um fluxo

Até agora estamos efetuando a troca de uma única lâmpada, na verdade,

Observamos que o Algoritmo 1.6 é apenas um conjunto de 10 repetições do

Quando a condição ( quantidade de soquetes testados for menor ou igual a

6. DE QUE MANEIRA REPRESENTAMOS O ALGORITMO?

Convém enfatizar mais uma vez que um algoritmo é uma linha de

Os algoritmos representados até o momento estavam em forma textual,

1 - Um homem precisa atravessar um rio com um barco que possui

discos para outra haste.

3. Três jesuítas e três canibais precisam atravessar um rio; para tal,

segurança não se permite que em alguma margem a quantidade de jesuítas

UNIDADE II - Tópicos Preliminares

O que vamos ver:

 Tipos de Dados Básicos

1. TIPOS DE DADOS BÁSICOS

Informação é a matéria-prima que faz com que seja necessária a existência

Aproximando-se da maneira pela qual o computador manipula as

Os dados numéricos dividem-se em dois grupos: inteiros e reais.

Os números inteiros podem ser positivos ou negativos e NÃO possuem parte

a) Ele tem 15 irmãos.

Enfatizando o conceito de dado, vale observar, por exemplo, o item: 8 é um

Observação: Nas linguagens de programação a separação entre a parte

Observação: Os dados do tipo literal na linguagem C são sempre

Entendemos que um dado é constante quando não sofre variação no decorrer

Um dado é classificado como variável quando tem a possibilidade de ser

Quando fazemos um programa, este normalmente recebe dados, os quais

Um exemplo para ilustrar a diferença entre valores constantes e variáveis

No ambiente computacional, as informações variáveis são guardadas em

Visto que na memória (armário) existem inúmeras variáveis (gavetas),

Portanto, precisamos definir nomes para determinadas gavetas

Obs.: Palavras reservadas da linguagem C não podem ser identificadores de

Exemplos de identificadores válidos:

Exemplos de identificadores inválidos:

Obs.: Duas ou mais variáveis NÃO PODEM ter o mesmo nome

Os operadores aritméticos a serem utilizados:

Exemplo: Considere X e Y variáveis do tipo inteiro e com valores 7 e 3

 A ordem da precedência dentro de uma expressão aritmética pode ser