EXERCÍCIOS
1) Um determinado material radioativo perde metade de sua massa a cada 50
segundos. Dada uma massa inicial, em gramas, criar um algoritmo (pseudocódigo)
que determine o tempo necessário para que essa massa se torne menor que 0,5
gramas. Escreva a massa inicial, a massa final e o tempo calculado em horas,
minutos e segundos.
algoritmo "Material Radiotivo"
// Função :
// Autor : Guilherme Borba e Guilherme Ferroni
// Data : 19/3/2012
// Seção de Declarações
var
mi, mf: real
tt: inteiro
ts, tm, th: inteiro
inicio
// Seção de Comandos
escreva ("Insira a massa inicial do material(em gramas): ")
leia (mi)
tt <- 0
enquanto mi >= 0.5 faca
mi <- mi/2
tt <- tt + 1
fimenquanto
escreval ("Sua massa final é: ", mi:5:2)
tt <- tt*50
escreval ("Seu tempo em segundos foi: ", tt, "s")
tm <- tt\60
ts <- tt - (tm*60)
escreval ("Seu tempo em minutos foi: ", tm, "min,", ts, "s")
th <- tm\60
tm <- (tm) - (th*60)
escreval ("Seu tempo em horas foi: ", th, "h,", tm, "min,", ts, "s")
fimalgoritmo
2) Criar um algoritmo que compare o crescimento populacional de dois países. O
programa deve ler o nome do país A, sua população e sua taxa de crescimento
anual; o nome o País B, sua população e sua taxa de crescimento anual.
Primeiramente o programa deve verificar se é possível que o país com menor
população alcance o país com maior população (taxa de crescimento do país com
menor população maior que a taxa de crescimento do país com maior população).
Em caso positivo, o programa deve calcular e listar quantos anos serão necessários
para que um país alcance o outro. Em caso negativo, o programa deve listar a
mensagem “Problema sem solução”.
algoritmo "semnome"
// Função : compare o crescimento
// Autor :
// Data : 19/3/2012
// Seção de Declarações
var
A , B : caracter
L : inteiro
PA , PB , TA , TB : real
inicio
L <- 0
escreva ("Informe o nome do país A: ")
leia (A)
escreva ("Informe a população do(a) ", A, ": ")
leia (PA)
escreva ("Informe a taxa de crescimento populacional (%) do(a) ", A,
": ")
leia (TA)
escreval
escreva ("Informe o nome do país B: ")
leia (B)
escreva ("Informe a população do(a) ", B, ": ")
leia (PB)
escreva ("Informe a taxa de crescimento populacional (%) do(a) ", B,
": ")
leia (TB)
escreval
TA <- TA/100
TB <- TB/100
se (TA > TB) e (PA < PB) ou (TA < TB) e (PA > PB) entao
se (TA > TB) e (PA < PB) entao
enquanto (PA < PB) faca
PA <- PA + (PA*TA)
PB <- PB + (PB*TB)
L <- L + 1
fimenquanto
escreval ("A população do(a) ", A, " alcançará a população
do(a) ", B, " em", L, " anos")
fimse
se (TA < TB) e (PA > PB) entao
enquanto (PA > PB) faca
PA <- PA + (PA*TA)
PB <- PB + (PB*TB)
L <- L + 1
fimenquanto
escreval ("A população do(a) ", B, " alcançará a população
do(a) ", A, " em", L, " anos")
fimse
senao
escreval ("Problema sem solução!")
fimse
fimalgoritmo
3) A lista de preços de uma loja de material de construção é a seguinte:
Especificação
Argamassa
Tijolo 6 Furos
Brita No. 2
Areia
Código
100
101
102
103
Preço
58,00
139,00
93,00
26,00
Criar um algoritmo que leia o código do item pedido, a quantidade e calcule o valor
a ser pago por aquele pedido. Considere que o cliente pode pedir vários itens
sequencialmente. Calcular e escrever a conta do cliente. Fazer enquanto o usuário
desejar. Rejeitar código inválido com mensagem explicativa e solicitando se deseja
continuar.
algoritmo "lojamateriais"
// Função :
// Autor : Patrícia Brunato e Guilherme Darabas
// Data : 16/03/2012
// Seção de Declarações
var c, q: inteiro
v, a: real
r: caractere
inicio
r <- "s"
enquanto (r = "s") faca
escreval ("Digite o código do produto:")
leia (c)
se c= 100 entao
v <- 58,00
escreval ("Argamassa - R$58,00")
senao
se c= 101 entao
v <- 139,00
escreval ("Tijolo 6 furos - R$139,00")
senao
se c = 102 entao
v <- 93,00
escreval ("Brita no. 2 - R$93,00")
senao
se c = 103 entao
v <- 26,00
escreval ("Areia - R$26,00")
senao
escreval ("Produto não cadastrado.")
q <-0
fimse
fimse
fimse
fimse
se (c = 100) ou (c = 101) ou (c = 102) ou (c = 103) entao
escreval ("Digite a quantidade do produto:")
leia (q)
escreval (q, "UN X", v, " =", q*v)
fimse
a <- a + q*v
se (c = 100) ou (c = 101) ou (c = 102) ou (c = 103) entao
escreval ("Subtotal = R$",a)
fimse
escreval ("Deseja continuar? (s/n)")
leia (r)
fimenquanto
escreval ("O valor total do pedido é: R$", a)
fimalgoritmo
4) Criar um algoritmo que calcule o imposto de renda de pessoa física. O usuário
deverá informar o CPF, o número de dependentes, e a renda mensal. Deverá ser
deduzido da renda mensal o valor de R$ 50,00 por cada dependente (limitar o
número de dependentes a 10). Para cada pessoa física deverá ser calculado e escrito
o CPF, a renda líquida (renda mensal – descontos de dependentes), o percentual do
IR a ser calculado (ver tabela a baixo) e o valor do IR apurado. O algoritmo irá
terminar quando for informado CPF = 0. No final escrever para quantas pessoas foi
apurado o IR.
Desconto
Renda Líquida
Até R$ 3.000,00
Isento
R$ 3.000,01 a R$ 6.000,00
5%
R$ 6.000,01 a R$ 10.000,00
10%
Acima de R$ 10.000,01
15%
algoritmo "Cálculo do Imposto de Renda"
/ Autor : Larissa Rodrigues
// Data : 17/03/2012
// Seção de Declarações
var
cpf, numDep, acumulador: inteiro
rendaMensal, rendaLiq, valIRApurado, pctIR: real
pct: caracter
inicio
// Seção de Comandos
//
cpf <- 1
acumulador <- 0
escreval("Para encerrar, digite 0 para o CPF.")
escreval("Informe o CPF: ")
leia(cpf)
enquanto (cpf > 0) faca
rendaMensal <- 0
escreval("Informe a quantidade de dependentes (no máximo 10): ")
leia(numDep)
se numDep > 10 entao
escreval("Quantidade de dependentes inválida!")
senao
enquanto rendaMensal <= 0 faca
escreval("Informe a renda mensal: ")
leia(rendaMensal)
fimenquanto
rendaLiq <- rendaMensal - (numDep*50)
se (rendaLiq <= 3000) entao
pct <- "Isento"
pctIr <- 0
senao
se (rendaLiq > 3000) e (rendaLiq <= 6000) entao
pct <- "5%"
pctIr <- 0.05
senao
se (rendaLiq > 6000) e (rendaLiq <= 10000) entao
pct <- "10%"
pctIr <- 0.1
senao
pct <- "15%"
pctIr <- 0.15
fimse
fimse
fimse
valIRApurado <- rendaLiq * pctIR
escreval("******************************")
escreval("CPF: ",cpf)
escreval("Renda Líquida: ",rendaLiq)
escreval("Percentual do IR: ",pct)
escreval("Valor do IR apurado: ",valIRApurado)
acumulador <- acumulador + 1
escreval("Informe o CPF: ")
leia(cpf)
fimse
fimenquanto
escreval("Quantidade de apurações do IR: ",acumulador)
fimalgoritmo
5) Em Joinville de Janeiro a Março de 2011 não ocorreram temperaturas inferiores a
10 graus e nem superiores a 40 graus. Criar um algoritmo para ler as temperaturas
diárias e calcular para o quadrimestre: - a média das temperaturas e; - o número de
dias que a temperatura foi igual a 20º. Validar temperaturas informadas fora dos
limites.
algoritmo "semnome"
// Função temperaturas
// Autor : Marcos
//
Gabriel
// Data : 19/03/2012
// Seção de Declarações
var
temp, soma: real
dia20, dia: inteiro
media : real
inicio
// Seção de Comandos
dia<-0
dia20<-0
para dia de 0 ate 9 faca
escreval("Digite a temperatura do dia ",dia + 1, ":")
leia(temp)
//programa tem restrição para temperatura
enquanto (temp<10) ou (temp>40) faca
escreval("Temperatura inválida. ")
escreval("Digite uma temperatura entre 10 e 40 graus para
o dia", dia + 1, ":")
leia(temp)
fimenquanto
//para contar os dias em que a temperatura é 20
se temp = 20 entao
dia20<-dia20+1
fimse
//soma para calcular a media
soma<- soma+temp
fimpara
//calcula media
media<-soma/10
escreval("")
escreval("A média das temperaturas no trimestre foi de ", MEDIA:2:1,
" °C.")
escreval("Neste trimestre,",dia20, " dias registraram a temperatura
de 20°C.")
fimalgoritmo
6) Escrever um algoritmo que determine qual a maior e a menor duração de uma
partida de xadrez em um campeonato que teve 23 partidas. Ler a hora de início e de
fim de cada uma das partidas (considere apenas horas inteiras, sem os minutos).
Calcular a duração do jogo em horas, sabendo-se que o tempo máximo de duração
do jogo é de 4 horas e que o jogo pode iniciar em um dia e terminar no dia seguinte.
Casos de duração maior de 4 horas devem ser rejeitados com mensagem explicativa
e o correto deve ser reinformado.
algoritmo "COMPETIÇÃO DE XADREZ"
// Autor : Fernando / Karina
// Data : 16/3/2012
// Seção de Declarações
var i, f, mn, mx, d, n, erro : inteiro
inicio
// Seção de Comandos
mn <- 4
mx <- 0
Para n de 1 ate 23 faca
erro <- 1
Enquanto erro = (1) faca
Escreva ("Horário de Início da Partida ", n, " - ")
Leia (i)
Escreva ("Horário de Fim da Partida ", n, " - ")
Leia (f)
Se f>=i entao
d <- (f-i)
Senao
d <- (24-i+f)
Fimse
//--------------------------Se (d >=0) e (d <= 4) entao
Se d < mn entao
mn <- d
Fimse
Se d > mx entao
mx <- d
Fimse
erro <- 0
Senao
Escreval ("
ERRO: Duração da Partida Superior a 4h")
Escreval ("
Reinformar Horários")
Fimse
Fimenquanto
Escreval
Fimpara
//--------------------------------
Escreval
Escreval ("Menor Duração de Partida: ", mn, "h")
Escreval ("Maior Duração de Partida: ", mx, "h")
fimalgoritmo
7) Escrever um algoritmo que apure o resultado das finais da copa Libertadores da
América. O algoritmo deverá ler primeiramente o nome dos dois times que
disputarão as finais. Em seguida deverá informar a ordem dos confrontos (TIMEA x
TIMEB e vice-versa) e ler para cada jogo os gols marcados por cada time. Para
determinar o campeão seguem as seguintes regras:
– Maior número de pontos ganhos (Vitória 3 pontos, Empate 1 ponto e derrota 0
pontos);
– Em caso de empate em pontos deve se verificar o maior saldo de gols;
- Em caso de empate no saldo de gols, verificar o time que marcou mais gols na casa
do adversário;
- Em caso de empate também nos gols na casa do adversário solicitar que o usuário
informe o resultado obtido na cobrança dos Pênaltis e assim informar o campeão.
algoritmo "Final da Taça Libertadores da América"
// Autor : Mateus Felipe de Moliner e Andre Vale da Silva
// Data : 19/3/2012
// Seção de Declarações
var
T1: caractere
T2: caractere
m1:inteiro //Número de gols do t1 (primeiro jogo)
m2:inteiro //Número de gols do t1 (segundo jogo)
f1:inteiro //Número de gols do t2 (primeiro jogo)
f2:inteiro //Número de gols do t2 (segundo jogo)
x1:inteiro
x2:inteiro
inicio
escreval ("Informe o nome dos times:")
escreval ("Obs: Coloque primeiramente o time que joga o primeiro jogo
em casa.")
escreva ("Time 1: ")
leia (T1)
escreva ("Time 2: ")
leia (t2)
escreval ("Confronto 1: " ,t1, " x " ,t2, " - Estádio do " , t1)
escreval ("Confronto 2: " ,t2, " x " ,t1, " - Estádio do " , t2)
escreval ("Informe o número de gols que "
,t1, " marcou no primeiro
jogo: ")
leia (m1)
escreval ("Informe o número de gols que " , t2, " marcou no primeiro
jogo: ")
leia (f1)
escreval ("Informe o número de gols que ",t1, " marcou no segundo jogo:
")
leia (m2)
escreval ("Informe o número de gols que " ,t2, " marcou no segundo
jogo: ")
leia (f2)
se (m1+m2)>(f1+f2) entao
escreva ( " campeão: ",t1, " vice-campeao: ",t2 )
senao
se (m1+m2)<(f1+f2) entao
escreva ( " campeão: ",t2, " vice-campeao: ",t1 )
senao
se (m1+m2)=(f1+f2) entao
se (f1<m2) entao
escreva ( " campeão: ",t1, " vice-campeao: ",t2 )
senao
se (f1>m2) entao
escreva ( " campeão: ",t2, " vice-campeao: ",t1 )
senao
se (f1=m2) entao
escreval ("Informe o número de pênaltis convertidos pelo ",t1)
leia (x1)
escreval ("Informe o número de pênaltis convertidos pelo ",t2)
leia (x2)
se (x1=x2)entao
escreval (" O jogo ainda nao acabou! ")
senao
se (x1>x2) entao
escreval ( " campeão: ",t1, " vice-campeao: ",t2 )
senao
escreval ( " campeão: ",t2, " vice-campeao: ",t1 )
fimse
fimse
fimse
fimse
fimse
fimse
fimse
fimse
fimalgoritmo
8) O departamento que controla o índice de poluição diário do meio ambiente mantém
3 grupos de indústrias que são altamente poluentes do meio ambiente. O índice de
poluição aceitável varia de 0,05 até 0,25. Se o índice sobe para 0,3 as indústrias do
1o grupo são intimadas a suspenderem suas atividades, se o índice cresce para 0,4 as
do 1o e 2o grupo são intimadas a suspenderem suas atividades e se o índice atingir
0,5 todos os 3 grupos devem ser notificados a paralisarem suas atividades. Criar um
algoritmo que leia o índice de poluição medido diariamente para o mês de
agosto/2009 e emita a notificação adequada aos diferentes grupos de empresas para
cada um dos dias. No final escrever quantos dias o índice de poluição ficou em
patamares aceitáveis e quantos dias superou o mínimo aceitável.
algoritmo "Indice de poluição"
// Função : índice de poluição
// Autor : Priscilla Einecke Schmitz e Ana Stolf
// Data : 22/03/2012
// Seção de Declarações
var
a,f, g : real
d: inteiro
inicio
// Seção de Comandos
f <- 0
g <- 0
para d de 1 ate 3 passo 1 faca
escreval (" Qual o índice médio de poluição no dia ", d ," de
agosto/2009 dos 3 grupos de empresas? ")
leia (a)
se (a >= 0.05) e (a <= 0.25) entao
escreval ("
ÍNDICE DE POLUIÇÃO ACEITÁVEL
")
f <- (f + 1)
senao
se (a>=0.3) e (a<0.4) entao
escreval (" GRUPO 1 ESTÁ INTIMADO A SUSPENDER SUAS ATIVIDADES ")
g <- (g + 1)
senao
se (a>=0.4) e (a<0.5) entao
escreval (" GRUPOS 1 E 2 ESTÃO INTIMADOS A SUSPENDER SUAS
ATIVIDADES ")
g <- (g + 1)
senao
se (a>=0.5) entao
escreval (" OS 3 GRUPOS ESTÃO INTIMADOS A SUSPENDEREM SUAS
ATIVIDADES ")
g <- (g + 1)
fimse
fimse
fimse
fimse
fimpara
Escreval
escreval (" Quantidade de dias com índice de poluição em patamares
aceitáveis: ", f)
escreval (" Quantidade de dias em que o índice de poluição superou o
mínimo aceitável: ", g)
fimalgoritmo
9) Criar um algoritmo que adivinhe um determinado número (1 a 100). Primeiramente
o algoritmo deve pedir o número a ser adivinhado. Após, pedir o número candidato
até que o usuário acerte. A cada tentativa de acerto o programa deve proceder da
seguinte forma: Se o número candidato for igual ao número a ser adivinhado, emitir
mensagem de sucesso. Caso contrário, emitir mensagem alterando o intervalo inicial
(1-100) conforme exemplo:
• Número a ser adivinhado: 50
• Número candidato: 45 (1ª Tentativa)
• Mensagem: Informe novo número entre 45 e 100.
• Número candidato: 65 (2ª Tentativa)
• Mensagem: Informe novo número entre 45 e 65.
algoritmo "Exercício nº9"
// Autor : Micael Anderson Pereira, Marília Arent Michels
// Data : 19/3/2012
var
num: inteiro
tent: inteiro
max: inteiro
min: inteiro
qt: inteiro
inicio
// Seção de Comandos
max <- 100
min <- 1
qt <- 1
tent <- 0
escreva ("Informe o número a ser adivinhado entre 1 e 100: ")
leia (num)
enquanto (num <> tent) faca
escreva (qt, "ª tentativa: ")
leia (tent)
se(tent = num) entao
escreva ("Parabéns!")
senao
se (tent < num) entao
min <- tent
senao
max <- tent
fimse
escreval ("Inserir um novo número entre ", min, " e", max)
fimse
qt <- qt + 1
fimenquanto
fimalgoritmo
10) O cardápio de uma lancheria é o seguinte:
Especificação
Cachorro quente
Hambúrger
Cheeseburguer
Refrigerante
Código
100
101
102
103
Preço
2,50
3,30
4,50
2,00
Escrever um programa um algoritmo que leia o código do item pedido e a quantidade.
Calcule e escreva o valor a ser pago por aquele lanche. O cliente poderá fazer vários
pedidos se desejar. Calcular e escrever o valor da conta do cliente. No final calcular e
escrever o faturamento da lanchonete no dia. Rejeitar códigos inválidos com mensagem
explicativa.
algoritmo "Faturamento de uma lanchonete"
// Função : O cardápio
// Autor : Thaisa Lana Pilz, Katia Medved.
// Data : 19/3/2012
// Seção de Declarações
var
conta, total: real
qtd, cod: inteiro
resp, cliente: caracter
inicio
// Seção de Comandos
cliente <- "s"
resp <- "s"
conta <- 0
total <- 0
escreval ("Código Cachorro-quente: 100")
escreval ("Código
Hambúrguer: 101")
escreval ("Código
Cheeseburguer: 102")
escreval ("Código
Refrigerante: 103")
escreval (" ")
enquanto cliente = "s" faca
enquanto resp = "s" faca
escreva ("Qual é o pedido do cliente? Informe o código: ")
leia (cod)
se (cod <> 100) e (cod <> 101) e (cod <> 102) e (cod <>103) entao
escreval ("Código inválido!!!")
senao
escreval ("Quantos o cliente deseja? ")
leia (qtd)
se (cod = 100) entao
conta <- conta + qtd * 2.5
fimse
se (cod = 101) entao
conta <- conta + qtd * 3.30
fimse
se (cod = 102) entao
conta <- conta + qtd * 4.50
fimse
se (cod = 103) entao
conta <- conta + qtd * 2
fimse
fimse
escreval ("Deseja fazer mais algum pedido? s/n")
leia (resp)
fimenquanto
escreval ("O valor a ser pago é", conta, " reais")
escreval ("A lanchonete possui clientes? s/n")
leia (cliente)
escreval (" ")
resp <- "s"
total <- total + conta
conta <- 0
fimenquanto
escreval ("Faturamento total =", total," reais")
fimalgoritmo