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
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
Código
Preço
Argamassa
100
58,00
Tijolo 6 Furos
101
139,00
Brita No. 2
102
93,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.
Renda Líquida
Desconto
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%"
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 vartemp, 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
//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: ")
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
Código
Preço
Cachorro quente
100
2,50
Hambúrger
101
3,30
Cheeseburguer
102
4,50
Refrigerante
103
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