Lista 03 - Pagina 46
Exercícios resolvidos
da apostila Manzano usando a estrutura de repetição do tipo ENQUANTO.
a. Apresentar
os resultados de uma tabuada de multiplicar (de 1 até 10) de um número
qualquer.
Algoritmo
"tabuada"
//
//
//
Var
//
Seção de Declarações das variáveis
tabuada,
numero, cont: inteiro
Inicio
//
Seção de Comandos, procedimento, funções, operadores, etc...
cont
<- 1
escreval
("digite um numero qualquer")
leia
(numero)
enquanto
(cont<=10) faça
tabuada
<- numero*cont
escreval
(numero," *",cont, " =",tabuada)
cont
<- cont+1
fimenquanto
Fimalgoritmo
b. Apresentar
o total da soma obtida dos cem primeiros números inteiros
(1+2+3+4+...+98+99+100).
Algoritmo
"soma"
//
//
//
Var
//
Seção de Declarações das variáveis
cont,
soma: inteiro
Inicio
//
Seção de Comandos, procedimento, funções, operadores, etc...
cont
<- 1
enquanto
(cont<=100) faça
soma
<- soma + cont
cont
<- cont+1
fimenquanto
escreval
("a soma dos 100 primeiros números inteiros é", soma)
Fimalgoritmo
c. Elaborar
um programa que apresente no final o somatório dos valores pares existentes na
faixa de 1 até 500.
Algoritmo
"somatorioPar"
//
//
//
Var
//
Seção de Declarações das variáveis
cont,
soma: inteiro
Inicio
//
Seção de Comandos, procedimento, funções, operadores, etc...
cont
<- 1
enquanto
(cont<=500) faça
se
(cont mod 2=0) então
soma
<- soma + cont
fimse
cont
<- cont+1
fimenquanto
escreval
("o somatório dos valores pares existentes de 1 até 500 é:", soma)
Fimalgoritmo
d. Apresentar
todos os valores numéricos inteiros ímpares situados na faixa de 0 a 20. Para
verificar se o número é ímpar, efetuar dentro da malha a verificação lógica
desta condição com a instrução se, perguntando se o número é ímpar; sendo,
mostre-o; não sendo, passe para o próximo passo.
Algoritmo
"numerosImpares"
//
//
//
Var
//
Seção de Declarações das variáveis
cont:
inteiro
Inicio
//
Seção de Comandos, procedimento, funções, operadores, etc...
cont
<- 1
escreval
("os numéricos inteiros ímpares situados na faixa de 0 a 20 é:")
enquanto
(cont<=20) faça
se
(cont mod 2=1) então
escreval
(cont)
fimse
cont
<- cont+1
fimenquanto
Fimalgoritmo
e. Apresentar
os resultados das potências de 3, variando do expoente 0 até o expoente 15.
Deve ser considerado que qualquer número elevado a zero é 1, e elevado a 1 é
ele próprio. Observe que neste exercício não pode ser utilizado o operador de
exponenciação do portuguol (^).
Algoritmo
"expoente"
//
Var
// Seção de Declarações das variáveis
cont,result,expoente,numero:inteiro
Inicio
// Seção de Comandos, procedimento, funções,
operadores, etc...
numero <- 3
result <- 1
escreval("o resultado da potência de 3
de 0 à 15 é:")
enquanto (expoente<=15) faça
result <-1
cont <-1
enquanto (cont<= expoente) faça
result <- result * numero
cont <-cont + 1
fimenquanto
escreval(expoente,result)
expoente<- expoente+1
fimenquanto
Fimalgoritmo
f. Elaborar
um programa que apresente como resultado o valor de uma potência de uma base
qualquer elevada a um expoente qualquer, ou seja, de BE, em que B é
o valor da base e E o valor do expoente. Observe que neste exercício não pode
ser utilizado o operador de exponenciação do portuguol (^).
Algoritmo
"potenciaBase"
//
Var
//
Seção de Declarações das variáveis
expoente,cont,result,base:inteiro
Inicio
//
Seção de Comandos, procedimento, funções, operadores, etc...
cont
<- 1
result
<- 1
escreval("digite
o valor da base e do expoente:")
leia
(base, expoente)
enquanto
(cont<=expoente) faça
result
<- result * base
cont
<-cont+1
fimenquanto
escreval(result)
Fimalgoritmo
g. Escreva
um programa que apresente a série de Fibonacci até o décimo quinto termo. A
série de Fibonacci é formada pela sequência: 1, 1, 2, 3, 5, 8, 13, 21, 34, ...,
etc. Esta série se caracteriza pela soma de um termo atual com o seu anterior
subsequente, para que seja formado o próximo valor da sequência. Portanto
começando com os números 1, 1 o próximo termo é 1+1=2, o próximo é 1+2=3, o
próximo é 2+3=5, o próximo 3+5=8, etc.
Algoritmo
"serieFibonacci"
//
Var
//
Seção de Declarações das variáveis
atual,
prox, cont, ant:inteiro
Inicio
//
Seção de Comandos, procedimento, funções, operadores, etc...
cont
<- 3
atual
<-1
ant
<- 1
escreval
(" a série de Fibonacci até o décimo quinto termo é:")
escreval
(ant)
escreval
(atual)
enquanto
(cont<=15) faça
prox
<- atual + ant
escreval
(prox)
cont
<- cont +1
ant
<- atual
atual
<- prox
fimenquanto
Fimalgoritmo
h. Elaborar
um programa que apresente os valores de conversão de graus Celsius em
Fahrenheit, de 10 em 10 graus, iniciando a contagem em 10 graus Celsius e
finalizando em 100 graus Celsius. O programa deve apresentar
os valores das duas
temperaturas. A fórmula de
conversão é F = (9C + 160) /5, sendo F a temperatura em Fahrenheit e C a
temperatura em Celsius.
Algoritmo
"conversaoFahrenheit"
//
Var
//
Seção de Declarações das variáveis
c,
f:real
Inicio
//
Seção de Comandos, procedimento, funções, operadores, etc...
c
<- 10
escreval
(" a conversão de graus Celsius em Fahrenheit de 10 em 10 graus é:")
enquanto
(c<=100) faça
f
<- (9*c + 160)/5
escreval
(c," em graus Celsius", " é", f, " graus em
Fahrenheit")
c
<- c+10
fimenquanto
Fimalgoritmo
i. Elaborar
um programa que efetue a leitura de 10 valores numéricos e apresente no final o
total do somatório e a média aritmética dos valores lidos.
Algoritmo
"somatorio"
//
Var
//
Seção de Declarações das variáveis
cont,
n, s:inteiro
m:
real
Inicio
//
Seção de Comandos, procedimento, funções, operadores, etc...
cont
<- 1
escreval
(" digite 10 valores numéricos :")
enquanto
(cont<=10) faça
leia
(n)
s
<- s+n
m
<- s/cont
cont
<- cont+1
fimenquanto
escreval
("a soma é:", s, " e a media é:", m)
Fimalgoritmo
j. Elaborar
um programa que apresente os resultados da soma e da média aritmética dos
valores pares situados na faixa numérica de 50 a 70.
Algoritmo
"somaAritmetica"
//
Var
//
Seção de Declarações das variáveis
aux,
cont, s:inteiro
m:
real
Inicio
//
Seção de Comandos, procedimento, funções, operadores, etc...
cont
<- 50
escreval
("soma e média aritmética dos pares na faixa de 50 a 70")
escreval
(" ")
enquanto
(cont<=70) faça
se
(cont mod 2=0) entao
s
<- s+cont
aux
<- aux+1
fimse
cont
<- cont+1
fimenquanto
m
<- s/aux
escreval
("a soma é:", s, " e a media é:", m)
Fimalgoritmo
k. Elaborar
um programa que possibilite calcular a área total de uma residência (sala,
cozinha, banheiro, quartos, área de serviço, quintal, garagem, etc.). O
programa deve solicitar a entrada do nome, a largura e o comprimento de um
determinado cômodo. Em seguida, deve apresentar a área do cômodo lido e também
uma mensagem solicitando do usuário a confirmação de continuar calculando novos
cômodos. Caso o usuário responda “NAO”, o programa deve apresentar o valor
total acumulado da área residencial.
Algoritmo
"arearesidencia"
//
//
//
Var
area,
comprimento, largura, total: real
comodo,
opcao: caracter
//
Seção de Declarações das variáveis
Inicio
//
Seção de Comandos, procedimento, funções, operadores, etc...
opcao
<- "sim"
escreval
("calcular a área total de uma residência")
escreval
(" ")
enquanto
(opcao = "sim") faca
escreval
("informe o comodo")
leia
(comodo)
escreval
("informe a largura em metros")
leia
(largura)
escreval
("informe o comprimento metros")
leia
(comprimento)
area
<- largura * comprimento
escreval
("a area do comodo ", comodo, " é:", area, "
m^2")
escreval
()
escreval
("deseja continuar? informe sim ou nao")
leia
(opcao)
total
<- total + area
fimenquanto
escreva
("a area total da residencia é:", total, " m^2")
Fimalgoritmo
l. Elaborar
um programa que efetue a leitura de valores positivos inteiros até que um valor
negativo seja informado. Ao final devem ser apresentados o maior e o menor
valores informados pelo usuário.
Algoritmo
"valoresPositivos"
//
//
//
Var
numero,
maior, menor: inteiro
//
Seção de Declarações das variáveis
Inicio
//
Seção de Comandos, procedimento, funções, operadores, etc...
escreval
("digite um numero")
leia
(numero)
maior
<- numero
menor
<- numero
enquanto
(numero >=0) faça
se
(numero > maior) entao
maior
<- numero
fimse
se
(numero < menor) entao
menor
<- numero
fimse
leia
(numero)
fimenquanto
escreva
("o maior valor é:", maior, " e o menor valor é:", menor)
Fimalgoritmo