Especificação Código Preço Argamassa ,00 Tijolo 6 Furos ,00 Brita No ,00 Areia ,00

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%

/ 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.

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

//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.

// 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.

// 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