Algoritmos com Pseudocódigo - Lista de Exercícios Resolvida e Comentada - VisualAlg

Prévia do material em texto

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 
 
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 
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) 
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 
 
• 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: inteiroinicio 
 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 
 
 
 
 
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 
 
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) 
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 
 
 
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 
 
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 
 
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 
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