exerc_algoritmos

Prévia do material em texto

Faça um algoritmo que leia dois números inteiros (A e B) pelo teclado. Apresente na tela o resultado das seguintes operações:
A + B
A – B
A * B
AB
Raiz quadrada de B
algoritmo "01"
//1.	Faça um algoritmo que leia dois números inteiros (A e B) pelo teclado.
//Apresente na tela o resultado das seguintes operações:
//	A + B
//	A - B
//	A * B
//	A2
//	Raiz quadrada de B
var
A, B: inteiro
soma, subtracao, multiplicacao : inteiro
aelevadoB, raizquadradadeA : real
inicio
// Seção de Comandos
//leitura das variáveis
escreval ("Digite o valor de A")
leia (A)
escreval ("Digite o valor de B")
leia (B)
//cálculo das operações - processo
soma <-	(A + B)
subtracao <- (A - B)
multiplicacao <- (A * B)
aElevadoB <- (A^B)
raizquadradadeA <- Raizq(A)
//saída de dados
Escreval (A," + ",B," = ", soma)
Escreval (A," - ",B," = ", subtracao)
Escreval (A," * ",B," = ", multiplicacao)
Escreval (A," elevado a ",B," = ", aElevadoB)
Escreval (" Raiz quadrada de ",A," = ", raizquadradadeA)
fimalgoritmo
Faça um algoritmo que leia três números inteiros (A, B e C) pelo teclado. Considere que A representa um valor de hora, B representa um valor de minutos e C representa um valor em segundos. Mostre na tela o resultado da conversão do valor total dos três números em segundos. Considere 1hora = 60 minutos e 1 minutos = 60 segundos.
algoritmo "02"
//2.	Faça um algoritmo que leia três números inteiros (A, B e C) pelo teclado.
//Considere que A representa um valor de hora, B representa um valor de minutos e
//representa um valor em segundos. Mostre na tela o resultado da conversão do valor
//total dos três números em segundos. Considere 1hora = 60 minutos e 1 minutos = 60 segundos.
var
 A, B, C : inteiro
 totalsegundos: inteiro
inicio
// Seção de Comandos 
//leitura de dados
 escreval ("Digite o valor da hora")
 leia (A)
 escreval ("Digite o valor dos minutos")
 leia (B)
 escreval ("Digite o valor dos segundos")
 leia (C)
// processo
 totalsegundos <- (a * 60 * 60) + (b * 60) + c
//saída de dados
 escreval ("o total em segundos é ", totalsegundos)
fimalgoritmo
Faça um algoritmo que leia um valor real pelo teclado que representa o valor de um produto qualquer. Calcule e mostre os seguintes valores:
O valor do produto caso seja descontado 20 % pelo pagamento a vista;
O valor do produto caso seja acrescentado 10 % pelo parcelamento em 3 vezes.
algoritmo "03"
//3.	Faça um algoritmo que leia um valor real pelo teclado que representa o
//valor de um produto qualquer. Calcule e mostre os seguintes valores:
//"	O valor do produto caso seja descontado 20 % pelo pagamento a vista;
//"	O valor do produto caso seja acrescentado 10 % pelo parcelamento em 3 vezes.
var
 valor, desconto20, acrescimo10, valorDesconto, valorAcrescimo : real
inicio
// Seção de Comandos 
//leitura de dados
 escreval ("digite o valor do produto")
 leia (valor)
//processo
 desconto20 <- valor * 20/100
 valorDesconto <- valor - desconto20
 acrescimo10 <- valor * 10/100
 valorAcrescimo <- valor + acrescimo10
//saída de dados
 escreval ("valor do produto com desconto de 20% = ",valordesconto)
 escreval ("valor do produto com acrescimo de 10% = ",valorAcrescimo)
fimalgoritmo
Estruturas de Decisão - Utilizando a estrutura Simples (Se-fimse)
Faça um algoritmo que leia dois números (A e B) pelo teclado. Se B = 0 então escreva uma mensagem informando que não existe divisão por zero. Se B <> 0 então apresente na tela o resultado das seguintes operações:
A / B
O resto da divisão de A por B
O valor inteiro do resultado da divisão de A por B
algoritmo "04"
//4.	Faça um algoritmo que leia dois números (A e B) pelo teclado. Se B = 0 então escreva uma mensagem informando que não existe divisão por zero. Se B <> 0 então apresente na tela o resultado das seguintes operações:
//	A / B
//	O resto da divisão de A por B
//	O valor inteiro do resultado da divisão de A por B
var
 A, B, valorResto, valorInteiro:inteiro
 valorDivisao: real
inicio
// Seção de Comandos 
//leitura de dados
 escreval ("digite o valor de A")
 leia (A)
 escreval ("digite o valor de B")
 leia (B)
//processo
 se (B = 0) entao
 //Saída de dados
 escreval ("não existe divisão por zero")
 fimse
 Se (B <> 0) entao
 valorDivisao <- A/B
 valorResto <- (A mod B)
 valorInteiro <- (A div B)
 //Saída de dados
 escreval (A, " / ",B, " = ",valorDivisao)
 escreval ("resto de ",A, " / ",B, " = ",valorResto)
 escreval ("inteiro de ",A, " / ",B, " = ",valorInteiro)
 fimse
fimalgoritmo
Escreva um algoritmo que leia um número inteiro (A) pelo teclado e mostre na tela se esse número é par ou impar.
algoritmo "05"
//5.	Escreva um algoritmo que leia um número inteiro (A)
//pelo teclado e mostre na tela se esse número é par ou impar.
var
 A: inteiro
inicio
// Seção de Comandos 
//entrada de dados
 escreval ("digite um número")
 leia (A)
//processo
 se ((A mod 2)=0) entao
 //saída de dados
 escreval ("é par")
 fimse
 se ((A mod 2)<> 0) entao
 //saída de dados
 escreval ("é impar")
 fimse
fimalgoritmo
Escreva um algoritmo que leia dois números inteiros (A e B) pelo teclado. Mostre na tela uma mensagem informando se os números são iguais ou diferentes. Se os números forem diferentes mostre na tela os números em ordem crescente e em ordem decrescente.
algoritmo "06"
//6.	Escreva um algoritmo que leia dois números inteiros (A e B) pelo teclado.
//Mostre na tela uma mensagem informando se os números são iguais ou diferentes.
//Se os números forem diferentes mostre na tela os números em ordem crescente e em ordem decrescente.
var
 A, B: inteiro
inicio
// Seção de Comandos 
//leitura de dados
 escreval ("digite o valor de A")
 leia (A)
 escreval ("digite o valor de B")
 leia (B)
//processo
 se (A = B) entao
 //saída de dados
 escreval (A," e ",B," são iguais")
 fimse
 se (A <> B) entao
 //saída de dados
 escreval (A," e ",B," são diferentes")
 se (A < B) entao
 //saída de dados
 escreval ("números em ordem crescente: ", A,B)
 escreval ("números em ordem decrescente: ", B,A)
 fimse
 fimse
fimalgoritmo
Faça um algoritmo que receba um número inteiro (A) pelo teclado e mostre na tela:
Se o número é negativo
Se o número é nulo (zero)
Se o número é positivo.
algoritmo "07"
//7.	Faça um algoritmo que receba um número inteiro (A) pelo teclado e mostre na tela:
//	Se o número é negativo
//	Se o número é nulo (zero)
//	Se o número é positivo.
var
 A : inteiro
inicio
// Seção de Comandos
//leitura de dados
 escreval ("digite um número")
 leia (A)
//processo
 se (A < 0) entao
 //saída de dados
 escreval ("o número é negativo")
 fimse
 se (A = 0) entao
 //saída de dados
 escreval ("o número é nulo ou zero")
 fimse
 se (A > 0) entao
 //saída de dados
 escreval ("o número é positivo")
 fimse
fimalgoritmo
Estruturas de Decisão - Utilizando a estrutura Composta (Se-Senão-fimse)
Faça um algoritmo que leia dois números (A e B) pelo teclado. Se B = 0 então escreva uma mensagem informando que não existe divisão por zero. Se B <> 0 então apresente na tela o resultado das seguintes operações:
A / B
O resto da divisão de A por B
O valor inteiro do resultadoda divisão de A por B
algoritmo "08"
//4.	Faça um algoritmo que leia dois números (A e B) pelo teclado. Se B = 0 então escreva uma mensagem informando que não existe divisão por zero. Se B <> 0 então apresente na tela o resultado das seguintes operações:
//	A / B
//	O resto da divisão de A por B
//	O valor inteiro do resultado da divisão de A por B
var
 A, B, valorResto, valorInteiro:inteiro
 valorDivisao: real
inicio
// Seção de Comandos 
//leitura de dados
 escreval ("digite o valor de A")
 leia (A)
 escreval ("digite o valor de B")
 leia (B)
//processo
 se (B = 0) entao
 //Saída de dados
 escreval ("não existe divisão por zero")
 senao
 valorDivisao <- A/B
 valorResto <- (A mod B)
 valorInteiro <- (A div B)
 //Saída de dados
 escreval (A, " / ",B, " = ",valorDivisao)
 escreval ("resto de ",A, " / ",B, " = ",valorResto)
 escreval ("inteiro de ",A, " / ",B, " = ",valorInteiro)
 fimse
fimalgoritmo
Escreva um algoritmo que leia um número inteiro (A) pelo teclado e mostre na tela se esse número é par ou impar.
algoritmo "09"
//5.	Escreva um algoritmo que leia um número inteiro (A)
//pelo teclado e mostre na tela se esse número é par ou impar.
var
 A: inteiro
inicio
// Seção de Comandos 
//entrada de dados
 escreval ("digite um número")
 leia (A)
//processo
 se ((A mod 2)=0) entao
 //saída de dados
 escreval ("é par")
 senao
 //saída de dados
 escreval ("é impar")
 fimse
fimalgoritmo
Escreva um algoritmo que leia dois números inteiros (A e B) pelo teclado. Mostre na tela uma mensagem informando se os números são iguais ou diferentes. Se os números forem diferentes mostre na tela os números em ordem crescente e em ordem decrescente.
algoritmo "10"
//6.	Escreva um algoritmo que leia dois números inteiros (A e B) pelo teclado.
//Mostre na tela uma mensagem informando se os números são iguais ou diferentes.
//Se os números forem diferentes mostre na tela os números em ordem crescente e em ordem decrescente.
var
 A, B: inteiro
inicio
// Seção de Comandos 
//leitura de dados
 escreval ("digite o valor de A")
 leia (A)
 escreval ("digite o valor de B")
 leia (B)
//processo
 se (A = B) entao
 //saída de dados
 escreval (A," e ",B," são iguais")
 senao
 //saída de dados
 escreval (A," e ",B," são diferentes")
 se (A < B) entao
 //saída de dados
 escreval ("números em ordem crescente: ", A,B)
 escreval ("números em ordem decrescente: ", B,A)
 fimse
 fimse
fimalgoritmo
Faça um algoritmo que receba um número inteiro (A) pelo teclado e mostre na tela:
Se o número é negativo
Se o número é nulo (zero)
Se o número é positivo.
algoritmo "11"
//7.	Faça um algoritmo que receba um número inteiro (A) pelo teclado e mostre na tela:
//	Se o número é negativo
//	Se o número é nulo (zero)
//	Se o número é positivo.
var
 A : inteiro
inicio
// Seção de Comandos
//leitura de dados
 escreval ("digite um número")
 leia (A)
//processo
 se (A < 0) entao
 //saída de dados
 escreval ("o número é negativo")
 senao
 se (A = 0) entao
 //saída de dados
 escreval ("o número é nulo ou zero")
 senao
 //saída de dados
 escreval ("o número é positivo")
 fimse
 fimse
fimalgoritmo
Estruturas de Repetição - Utilizando a estrutura Para
Faça um algoritmo que some os números de 1 a 3000 e mostre na tela o resultado.
algoritmo "12"
//12.	Faça um algoritmo que some os números de 1 a 3000 e mostre na tela o resultado.
var
 cont, soma: inteiro
inicio
// Seção de Comandos 
//não tem leitura de dados
//processo
 para cont de 1 ate 3000 faca
 //cálculo do somatório
 soma <- soma + cont
 fimpara
 escreval ("soma de 1 a 3000 é = ", soma)
fimalgoritmo
Faça um algoritmo que leia a idade de 13 pessoas e ao final mostre na tela a soma das idades digitadas.
algoritmo "13"
//13.	Faça um algoritmo que leia a idade de 13 pessoas e ao final mostre na tela a soma das idades digitadas.
var
 cont, idade, somaIdades : inteiro
inicio
// Seção de Comandos 
//processo
 somaIdades <- 0
 para cont de 1 ate 13 faca
 //leitura de dados
 escreval ("digite a idade da ",cont,"a. pessoa")
 leia (idade)
 somaIdades <- somaIdades + idade
 fimpara
 //saída de dados
 escreval ("a soma das idades das 13 pessoas é = ",somaIdades)
fimalgoritmo
Faça um algoritmo que leia a idade de 13 pessoas e ao final mostre na tela a média das idades digitadas.
algoritmo "14"
//14.	Faça um algoritmo que leia a idade de 13 pessoas e ao final mostre na tela a média das idades digitadas.
var
 cont, idade, somaIdades: inteiro
 mediaIdades: real
inicio
// Seção de Comandos 
//processo
 somaIdades <- 0
 para cont de 1 ate 13 faca
 //leitura de dados
 escreval ("digite a idade da ",cont,"a. pessoa")
 leia (idade)
 somaIdades <- somaIdades + idade
 fimpara
 //cálculo da média
 mediaIdades <- somaIdades/13
 //saída de dados
 escreval ("a media das idades das 13 pessoas é = ", mediaIdades)
fimalgoritmo
Faça um algoritmo que leia a idade de 13 pessoas e ao final mostre na tela a menor idade digitada.
algoritmo "15"
//15.	Faça um algoritmo que leia a idade de 13 pessoas e ao final mostre na tela a menor idade digitada.
var
 cont, idade, menorIdade: inteiro
inicio
// Seção de Comandos 
//processo
 para cont de 1 ate 13 faca
 //leitura de dados
 escreval ("digite a idade da ",cont,"a. pessoa")
 leia (idade)
 se (cont = 1) entao
 menorIdade <- idade
 senao
 se (idade < menorIdade) entao
 menorIdade <- idade
 fimse
 fimse
 fimpara
 //saída de dados
 escreval ("a menor idade das 13 pessoas é = ",menorIdade)
fimalgoritmo
Faça um algoritmo que leia a idade de 13 pessoas e ao final mostre na tela a maior idade digitada.
algoritmo "16"
//16.	Faça um algoritmo que leia a idade de 13 pessoas e ao final mostre na tela a maior idade digitada.
var
 cont, idade, maiorIdade: inteiro
inicio
// Seção de Comandos 
//processo
 para cont de 1 ate 13 faca
 //leitura de dados
 escreval ("digite a idade da ",cont,"a. pessoa")
 leia (idade)
 se (cont = 1) entao
 maiorIdade <- idade
 senao
 se (idade > maiorIdade) entao
 maiorIdade <- idade
 fimse
 fimse
 fimpara
 //saída de dados
 escreval ("a maior idade das 13 pessoas é = ",maiorIdade)
fimalgoritmo
Faça um algoritmo que leia a idade de 13 pessoas e ao final mostre na tela a quantidade de idades abaixo de 18 anos (idade < 18) digitadas.
algoritmo "17"
//17.	Faça um algoritmo que leia a idade de 13 pessoas e ao final mostre na tela a quantidade de idades abaixo de 18 anos (idade < 18) digitadas.
var
 cont, idade, qtdMenor18: inteiro
inicio
// Seção de Comandos 
//processoqtdMenor18 <- 0
 para cont de 1 ate 13 faca
 //leitura de dados
 escreval ("digite a idade da ",cont,"a. pessoa")
 leia (idade)
 se (idade < 18) entao
 qtdMenor18 <- qtdMenor18 +1
 fimse
 fimpara
 //saída de dados
 escreval ("a quantidade de pessoas menores de 18 anos nas 13 pessoas é = ",qtdMenor18)
fimalgoritmo
Faça um algoritmo que leia a idade de 13 pessoas e ao final mostre na tela a porcentagem de idades de pessoas acima de 65 anos (idade > 65) digitadas.
algoritmo "17"
//18.	Faça um algoritmo que leia a idade de 13 pessoas e ao final mostre na tela a porcentagem de idades de pessoas acima de 65 anos (idade > 65) digitadas.
var
 cont, idade, qtdmaior65: inteiro
 porcentagemMaior65: real
inicio
// Seção de Comandos 
//processo
 qtdMaior65 <- 0
 para cont de 1 ate 13 faca
 //leitura de dados
 escreval ("digite a idade da ",cont,"a. pessoa")
 leia (idade)
 se (idade > 65) entao
 qtdMaior65 <- qtdMaior65 +1
 fimse
 fimpara
 //cálculo da porcentagem
 porcentagemMaior65 <- qtdMaior65 * 100/13
 //saída de dados
 escreval (qtdMaior65)
 escreval ("a porcentagem de pessoas maiores de 65 anos anos nas 13 pessoas é = ",porcentagemMaior65)
fimalgoritmo
Estruturas de Repetição – Utilizando a estrutura Repita
Faça um algoritmo que some os números de 1 a 3000 e mostre na tela o resultado.
algoritmo "19"
//19.	Faça um algoritmo que some os números de 1 a 3000 e mostre na tela o resultado. - usando REPITA
var
 cont, soma: inteiro
inicio
// Seção de Comandos 
//não tem leitura de dados
//processo
 soma <- 0
 cont <- 1
 repita
 //cálculo do somatório
 soma <- soma + cont
 cont <- cont + 1
 ate cont = 3001
 escreval ("soma de 1 a 3000 é = ", soma)
fimalgoritmo
Faça um algoritmo que calcule a soma de números inteiros digitados pelo teclado. Os números serão lidos até que o número zero seja digitado. Nesse caso, a leitura deve parar e o resultado da soma deve ser apresentado na tela.
algoritmo "20"
//20.	Faça um algoritmo que calcule a soma de números inteiros digitados pelo teclado.
//Os números serão lidos até que o número zero seja digitado. Nesse caso,
//a leitura deve parar e o resultado da soma deve ser apresentado na tela.
// usando REPITA
var
 cont, numero, soma: inteiro
inicio
// Seção de Comandos 
//não tem leitura de dados
//processo
 soma <- 0
 repita
 //entrada de dados
 escreval ("digite um nomero a ser somado")
 leia (numero)
 soma <- soma + numero
 ate (numero = 0)
 escreval ("soma dos números digitados é = ", soma)
fimalgoritmo
Estruturas de Repetição - Utilizando a estrutura Enquanto
Faça um algoritmo que some os números de 1 a 3000 e mostre na tela o resultado.
algoritmo "21"
//21.	Faça um algoritmo que some os números de 1 a 3000 e mostre na tela o resultado. - usando ENQUANTO
var
 cont, soma: inteiro
inicio
// Seção de Comandos 
//não tem leitura de dados
//processo
 soma <- 0
 cont <- 1
 enquanto (cont < 3001) faca
 //cálculo do somatório
 soma <- soma + cont
 cont <- cont + 1
 fimenquanto
 escreval ("soma de 1 a 3000 é = ", soma)
fimalgoritmo
Faça um algoritmo usando a estrutura Enquanto-faça, que mostre na tela o fatorial de um número digitado pelo usuário.
algoritmo "22"
// 22. Faça um algoritmo usando a estrutura Enquanto-faça,
// que mostre na tela o fatorial de um número digitado pelo usuário.
var
 cont, numero, fatorial: inteiro
inicio
// Seção de Comandos 
//leitura de dados
 escreval ("digite um número")
 leia (numero)
//processo
 fatorial <- 1
 cont <- 1
 enquanto (cont <= numero) faca
 fatorial <- fatorial * cont
 cont <- cont + 1
 fimenquanto
 //saída de dados
 escreval ("o fatorial de ",numero," é ", fatorial)
fimalgoritmo