O documento apresenta quatro exercícios resolvidos com pseudocódigo para trabalhar com estruturas sequenciais, condicionais e de repetição. Os exercícios incluem calcular a área de um retângulo, trocar valores de variáveis, verificar o tipo de um triângulo e multiplicar números com somas repetidas.

1. ALGORITMOS COM PSEUDOCÓDIGO
LISTA DE EXERCÍCIOS RESOLVIDA E COMENTADA
OBS: Os algoritmos das soluções abaixo estão com a sintaxe de acordo com o VisuAlg, para que
possam ser executados no mesmo
EXERCÍCIOS SOBRE ESTRUTURAS SEQUENCIAIS:
1 – calcular a área de um retângulo
• A área de uma figura geométrica retangular é calculada pela fórmula área = largura x
altura
• As variáveis de entrada são altura e largura, do tipo real, pois pode haver medida com
parte fracionária
• Poderíamos criar uma variável de saída para a área, porém podemos calcular e mostrar o
resultado sem usar essa variável
• O esboço da solução em linguagem natural seria:
o Solicitar valor da largura e altura
o Calcular área e mostrar resultado
algoritmo "area retangulo"
var
altura, largura: real
inicio
Escreva("Digite a altura: ")
Leia(altura)
Escreva("Digite a largura: ")
Leia(largura)
Escreval("A área é: ",altura*largura)
fimalgoritmo
2 - Armazenar dois números em variáveis e trocar os valores das variáveis
algoritmo "troca variaveis"
// para fazer a troca de valores de duas variáveis
// é necessário uma variável auxiliar pois se fizermos
// a troca direta, um dos valores será perdido
var
a,b,aux: inteiro
inicio
Escreva("Digite o valor para a variavel A: ")
Leia(a)
Escreva("Digite o valor para a variavel B: ")
Leia(b)
aux <- a // guarda valor de a em aux para não ser perdido
a <- b // guarda valor de b em a
b <- aux // guarda valor de aux em b
Escreva("Valores após a troca: a=",a," b=",b)
fimalgoritmo

2. 3 - Calcular as raízes de uma equação do segundo grau
algoritmo "raizes equacao do 2o grau"
// OBS: Como o VisuAlg não tem a função RAIZ(), iremos solicitar
// o valor da raiz de delta ao usuário. Em uma linguagem que tenha
// a função RAIZ(), basta fazer raizdelta <- raiz(delta)
var
a,b,c,delta,raizdelta,x1,x2: real
inicio
Escreval("Raizes de uma equação do 2o grau")
escreva("Digite o valor de a: ")
Leia(a)
escreva("Digite o valor de b: ")
Leia(b)
escreva("Digite o valor de c: ")
Leia(c)
// calcula delta
delta <- b^2 - 4 * a * c
Escreval("Valor de DELTA: ",delta)
// verifica se delta é negativo (não tem raizes)
se delta<0 entao
escreva("Essa equação não tem raízes reais.")
senao
// OBS: como o VisuAlg não calcula raiz quadrada, iremos pedir
// o valor ao usuário
Escreva("Qual a raiz de ",delta,"? ")
Leia(raizdelta)
x1<-( -b + raizdelta ) / 2 * a
x2<-( -b - raizdelta ) / 2 * a
Escreval("As raízes são: x1=",x1," x2=",x2)
FimSe
fimalgoritmo
4 - Calcular o custo estimado com combustível em uma viagem de carro
• A lógica para solução deste problema é a seguinte: cada carro tem um consumo típico para
cada tipo de combustível (gasolina ou álcool), medido em quilômetros por litro (Km/l).
Dividindo a distância a ser percorrida na viagem por esse parâmetro (Km/l), podemos
saber quantos litros de combustível serão necessários. Após isso, basta multiplicar essa
quantidade de litros pelo preço unitário do litro de combustível.
• As variáveis de entrada estão destacadas no item anterior e deverão ser todas do tipo real
pois todas podem ter valores fracionários. A variável de saída será o custo, que é opcional
pois podemos calcular e mostrar o resultado sem usar essa variável
• O esboço da solução em linguagem natural seria:
o Solicitar os dados de entrada: quilômetros por litro, distancia a ser percorrida e preço
unitário do litro de combustível
o Calcular o custo e mostrar resultado
algoritmo "custo com combustivel"
var
kmporlitro,distancia,precolitro: real
inicio
Escreva("Quantos quilômetros por litro o seu carro faz? ")
Leia(kmporlitro)
Escreva("Qual a distância da viagem em Km? ")
Leia(distancia)
Escreva("Qual o preço do litro do combustível em R$? ")
Leia(precolitro)
Escreval("O custo estimado da viagem será R$ ",distancia/kmporlitro*precolitro)
fimalgoritmo

3. EXERCÍCIOS SOBRE ESTRUTURAS CONDICIONAIS:
1 - Faça um algoritmo que leia um número inteiro diferente de zero e diga se este é positivo ou
negativo
2 - Altere o algoritmo anterior para dizer também se o número é igual a zero (use se encadeados)
algoritmo "positivo ou negativo"
var
num: inteiro
inicio
Escreva("Digite um número: ")
Leia(num)
se num>0 entao
escreva("O número é positivo")
fimse
se num<0 entao
escreva("O número é negativo")
senão
escreva("O número é zero")
fimse
fimalgoritmo
3 - Faça uma algoritmo que leia três valores que representam os três lados de um triângulo e
verifique:
• Se o triângulo é válido
• Se é um triângulo equilátero, isósceles ou escaleno. Propriedades de um triângulo:
• A soma de dois lados não pode ser menor que a do terceiro lado (ou o comprimento
de cada lado deve ser menor que a soma dos outros dois lados)
• Equilátero: três lados iguais
• Isósceles: dois lados iguais
• Escaleno: três lados diferentes
(veja soluções nas folhas seguintes)

4. Solução 1 (com o teste do isósceles, que é mais complexo)
Algoritmo "Triangulo"
Var
lado1, lado2 , lado3 : real
Inicio
Escreva("Digite o lado 1: ")
Leia(lado1)
Escreva("Digite o lado 2: ")
Leia(lado2)
Escreva("Digite o lado 3: ")
Leia(lado3)
// testa se o triângulo é válido
// (a soma de dois lados não pode ser menor que a do terceiro lado)
se (lado1+lado2<lado3) OU (lado2+lado3<lado1) OU
(lado1+lado3<lado2) entao
Escreva("O triângulo não é válido.")
senao
// verifica o tipo de triângulo
// equilatero
se (lado1=lado2) E (lado2=lado3) entao
Escreval("O triângulo é equilátero")
fimse
// escaleno
Se (lado1<>lado2) E (lado2<>lado3) E (lado1<>lado3) entao
Escreval(“O triangulo é escaleno”)
Senao
// isosceles
se ((lado1=lado2) E (lado1<>lado3)) OU
((lado2=lado3) E (lado2<>lado1)) OU
((lado1=lado3) E (lado1<>lado2)) entao
Escreva("O triângulo é isósceles")
FimSe
FimSe
fimalgoritmo

5. • Solução 2: sem o teste do isósceles, usando estruturas se..senao
Algoritmo "Triangulo"
Var
lado1, lado2 , lado3 : real
Inicio
Escreva("Digite o lado 1: ")
Leia(lado1)
Escreva("Digite o lado 2: ")
Leia(lado2)
Escreva("Digite o lado 3: ")
Leia(lado3)
// testa se o triângulo é válido
// (a soma de dois lados não pode ser menor que a do terceiro lado)
se (lado1+lado2<lado3) OU
(lado2+lado3<lado1) OU
(lado1+lado3<lado2) entao
Escreva("O triângulo não é válido.")
senao
// verifica o tipo de triângulo
// equilatero
se (lado1=lado2) E (lado2=lado3) entao
Escreval("O triângulo é equilátero")
Senao
// escaleno
Se (lado1<>lado2) E (lado2<>lado3) E (lado1<>lado3) entao
Escreval(“O triangulo é escaleno”)
// se não é eqüilátero nem escaleno, então é isósceles
Senão
Escreva("O triângulo é isósceles")
FimSe
FimSe
FimSe
fimalgoritmo
EXERCÍCIOS SOBRE ESRUTURAS DE REPETIÇÃO:
1 - Multiplicar dois números usando somas repetidas
• Neste algoritmo o “segredo” é usar uma variável para acumular o valor da soma (que
no caso será a variável “produto” no algoritmo abaixo) de um dos fatores (no caso o
multiplicando “num2”) repetindo essa soma na quantidade do multiplicador (num1), O
comando que acumula a soma é produto<-produto+num2:
algoritmo "multiplicacao com somas"
var
num1,num2,aux,produto: inteiro
inicio
Escreva("Digite o multiplicador: ")
Leia(num1)
Escreva("Digite o multiplicando: ")
Leia(num2)
produto<-0
para aux de 1 ate num1 faca
produto<-produto+num2
fimpara
escreva("O produto é: ",produto)
fimalgoritmo

6. 2 - Solicitar uma quantidade pré-determinada de números e calcular a soma e média entre esses
números
• Já vimos como fazer a soma de números. Para calcular a média basta dividir a soma
pela quantidade de números digitados. Como não sabemos a quantidade de números
que o usuário quer digitar, então devemos perguntar e usar uma estrutura “para” para
repetir os comandos de solicitar um número e somar esse número essa quantidade de
vezes,. O cálculo da média a apresentação dos resultados deve ficar após a estrutura de
repetiçã
• Variáveis de entrada: quantidade de números (“quantidade”) (tipo inteiro)
• Variável de contagem: c
• Variáveis de processamento e saída: soma (inteiro) e media (real, pois a média pode
ter parte fracionária)
algoritmo "soma e média de números”
var
quantidade,numero,soma,c: inteiro
media: real
inicio
escreva("Quantos números você quer somar? ")
leia(quantidade)
para c de 1 ate quantidade faca
escreva("Digite o ",c,"o número: ")
leia(numero)
soma<-soma+numero
fimpara
media<-soma/quantidade
Escreval("A soma é: ",soma)
Escreval("A média é: ",media)
Fimalgoritmo
3 - Calcular a soma dos números ímpares entre um intervalo informado
• Este algoritmo é parecido com o anterior, sendo que, em vez de termos uma estrutura
para de 1 até uma quantidade, teremos um intervalo
• Variáveis de entrada: valor inicial (“ini”), limite (tipo inteiro)
• Variável de contagem: i
• Variáveis de processamento e saída: soma (inteiro)
Algoritmo "soma numeros Impares"
Var
i,ini,limite,soma: Inteiro
Inicio
Escreva("Digite o número inicial: ")
Leia(ini)
Escreva("Digite o número final: ")
Leia(limite)
soma<-0
Para i de ini ate limite faca
se (i mod 2) <> 0 entao
Escreval(i)
soma<-soma+i
FimSe
FimPara
Escreva("A soma desses números ímpares é: ",soma)
fimalgoritmo

7. 4 - Calcular o fatorial de um número. Dicas:
N ! = N * (n-1) * (n-2)... * 1 Ex: 5! = 5 * 4 * 3 * 1 = 60
• Podemos observar na fórmula do fatorial que precisaremos fazer multiplicações sucessivas,
onde o resultado da última multiplicação será multiplicado novamente por um outro
número (ex: 5*4 = 20; 20 * 3 = 60 ; 60 * 1 = 60). Essa multiplicação pode ser feita de
forma similar à variável acumuladora, só que em vez de somar, multiplicando. Ex: resl <-
res * num.
• Precisaremos de uma estrutura PARA p/ obter os multiplicadores, que podem estar tanto em
ordem crescente como decrescente
• Um pequeno detalhe do algoritmo é que precisamos iniciar a variável acumuladora dos
produtos com 1 ou com o primeiro número das multiplicações (conforme o algoritmo a ser
usado), senão estaremos multiplicando por zero
• Variáveis de entrada: número a calcular o fatorial (“num”) (tipo inteiro)
• Variável de contagem: c
• Variáveis de processamento e saída: fatorial (inteiro)
• Solução 1:
Algoritmo "fatorial"
var
num,c,fatorial: inteiro
Inicio
escreva("Numero a calcular o fatorial: ")
leia(num)
fatorial<-1
para c de num ate 1 passo -1 faca
fatorial<-fatorial*c
fimpara
escreva("O fatorial é:",fatorial)
fimalgoritmo
• Solução 2 (mais “enfeitada”, mostrando o cálculo passo a passo):
Algoritmo "fatorial"
var
num,c,fatorial: inteiro
Inicio
escreva("Numero a calcular o fatorial: ")
leia(num)
escreval("Cálculo do fatorial:")
fatorial<-num
Escreva(num) // imprime primeiro fator
para c de num-1 ate 1 passo -1 faca
Escreva(" * ",c) // imprime cada fator seguinte sucedido por *
fatorial<-fatorial*c
fimpara
escreval(" = ",fatorial) // imprime sinal “=” e o fatorial
fimalgoritmo
• OBS: As duas soluções acima estão com a estrutura PARA em ordem decrescente, mas nada
imprede que façamos o algoritmo com a estrutura PARA em ordem crescente (a ordem dos
fatores não altera o produto)

8. EXERCÍCIOS SOBRE VETORES:
1- Faça algoritmo para ler um vetor de 10 valores inteiros e depois identificar e mostrar o menor
valor
• A lógica deste algoritmo é:
o Preencher o vetor
o Percorrer cada posição do vetor, procurando qual é o menor número (ao iniciar,
supomos que o menor é o primeiro do vetor)
2- Altere o algoritmo anterior para procurar um número digitado pelo usuário, informando a sua
posição, se ele constar no vetor
• Aqui acrescentamos os trechos destacados para a pergunta e um teste a mais dentro do
PARA
algoritmo "Vetor 10 numeros"
var
vet: vetor[1..10] de inteiro
c,menor,num,posicao: inteiro
inicio
// preenche o vetor
para c de 1 ate 10 faca
escreva("Digite o ",c,"o numero: ")
leia(vet[c])
fimpara
// testa se um numero existe no vetor
Escreva("Digite o numero a procurar no vetor: ")
Leia(num)
// -- procura o menor e o número digitado
menor<-vet[1] // no início, o menor será o primeiro do vetor
para c de 1 ate 10 faca
escreva(vet[c])
// se o número na posição do vetor for menor que o menor
se vet[c]<menor entao
menor<-vet[c]
fimse
// testa se o número está no vetor
se num=vet[i] entao
Escreval("O número que você digitou está na posição ",i)
posicao<-i
fimse
fimpara
// mostra resultado
escreval("")
escreval("O menor é:",menor)
se posicao=0 entao
Escreval("O número não consta no vetor")
Fimse
fimalgoritmo

9. 3- Faça um algoritmo que inverta a posição dos valores de um vetor de seis posições de inteiros
• Neste algoritmo a lógica é usar uma variável auxiliar para a troca (veja exercício da troca do
valor de duas variáveis) e achar uma expressão matemática para referenciar o elemento da
posição simétrica, onde será feita a troca
• Para a troca, basta percorrermos a metade do vetor e usarmos a variável auxiliar e a
expressão encontrada no passo anterior
Algoritmo "menor valor no vetor"
var
vet: vetor[1..6] de inteiro
i, aux: Inteiro
Inicio
Para i de 1 ate 6 faca
Escreva("Digite o ",i,"º valor do vetor: ")
Leia(vet[i])
FimPara
Para i de 1 ate 3 faca
aux<-vet[i]
vet[i]<-vet[7-i]
vet[7-i]<-aux
FimPara
Escreval("Vetor invertido:")
para i de 1 ate 6 faca
escreval(vet[i])
fimpara
FimAlgoritmo

10. EXERCÍCIOS SOBRE MATRIZES:
1- Crie um algoritmo que crie uma matriz 4 x 4 de inteiros, solicite os valores ao usuário e depois
mostre qual o maior e menor valor na matriz
• Este algoritmo é similar as exercícios 1 e 2 de vetores, sendo que para preencher e
percorrer a matriz precisaremos de duas estruturas PARA (uma para as linhas e outra para
as colunas da matriz)
2- Altere o algoritmo anterior para procurar na matriz um valor digitado pelo usuário
• Aqui acrescentamos os trechos destacados para a pergunta e um teste a mais dentro do
PARA
algoritmo "matriz 4x4"
var
num: vetor[1..4,1..4] de inteiro
l,c,menor,maior,numproc,linha,coluna: inteiro
inicio
// preenche a matriz
para l de 1 ate 4 faca
para c de 1 ate 4 faca
escreva("Digite o numero da pos.",l,",",c,": ")
leia(num[l,c])
fimpara
fimpara
// pergunta qual número deseja procurar na matriz
Escreva("Digite o numero a procurar na matriz: ")
Leia(numproc)
// no início supomos que o primeiro é o maior e o menor valor
menor<-num[1,1]
maior<-num[1,1]
// percorre a matriz procurando o maior e menor valor
para l de 1 ate 4 faca
para c de 1 ate 4 faca
escreva(num[l,c]) // mostra item da matriz
// se item da linha e coluna for menor que o menor
se num[l,c]<menor entao
menor<-num[l,c]
fimse
// se item da linha e coluna for maior que o maior
se num[l,c]>maior entao
maior<-num[l,c]
fimse
// testa se o número está na matriz
se numproc=num[l,c] entao
Escreval("O número que você digitou está na posição
",l,",”,c)
linha<-l
coluna<-c
fimse
fimpara
escreval("") // salta linha
fimpara
escreval("")
escreval("O menor é:",menor)
escreval("O maior é:",maior)
se linha=0 entao
Escreval("O número não consta na matriz")
Fimse
fimalgoritmo

11. 3- Faça um algoritmo para guardar os nomes e resultados de jogos da loteria esportiva
4-Faça um algoritmo para multiplicar duas matrizes
algoritmo "multiplica matrizes 4x4"
var
matriz1: vetor[1..4,1..4] de inteiro
matriz2: vetor[1..4,1..4] de inteiro
produto: vetor[1..4,1..4] de inteiro
l,c: inteiro
inicio
// preenche a matriz 1
Escreval("Digite os valores para a matriz 1:")
para l de 1 ate 4 faca
para c de 1 ate 4 faca
escreva("Digite o numero da pos.",l,",",c,": ")
leia(matriz1[l,c])
fimpara
fimpara
// preenche a matriz 2
Escreval("Digite os valores para a matriz 1:")
para l de 1 ate 4 faca
para c de 1 ate 4 faca
escreva("Digite o numero da pos.",l,",",c,": ")
leia(matriz2[l,c])
fimpara
fimpara
// multiplica
Escreval(“Matriz-produto:”)
para l de 1 ate 4 faca
para c de 1 ate 4 faca
produto[l,c]=matriz1[l,c] * matriz2[c,l]
escreva(produto[l,c])
fimpara
escreval("") // salta linha
fimpara
fimalgoritmo
5-Faça um algoritmo para calcular o determinante de uma matriz
EXERCÍCIO SOBRE REGISTROS:
1. Crie um algoritmo para guardar o nome e as duas notas dos 40 alunos de uma turma e depois
calcular a média e resultado de cada um deles, sendo que a média para aprovação é 7
EXERCÍCIOS SOBRE SUB-ALGORITMOS:
1. Reescreva um dos exercícios de vetores ou matrizes criando um procedimento para ler os
dados e outro para processar e mostrar os resultados

12. 2. Crie uma função para calcular o fatorial de um número
algoritmo "Fatorial"
var
num,res: inteiro
funcao fat(x: inteiro) : inteiro
var
fatorial,c: inteiro
Inicio
fatorial<-1
para c de x ate 2 passo -1 faca
fatorial<-fatorial*c
fimpara
retorne fatorial
fimfuncao
Inicio
escreva("Numero a calcular o fatorial: ")
leia(num)
res<-fat(num)
escreva("O fatorial é:",res)
fimalgoritmo
3. Crie uma função para determinar se um número é primo