EXERCICIOS RESOLVIDOS DE PROGRAMAÇÃO

7. Construa um algoritmo (pseudocódigo) que: a. Leia o nome de três pessoas (dado do tipo
caractere). b.Escreva os nomes na ordem inversa da que foram informados.

algoritmo "Exer_7"

// Função :

// Autor : Majenda

// Data : 21-10-2015

// Seção de Declarações

var

a:vetor[1..5] de caracter

b:vetor[1..5] de caracter

op:caracter

i:inteiro

inicio

escreval("Digite 5 nome nomes de pessoas")

para i de 1 ate 5 faca

leia(a[i])

fimpara

para i de 1 ate 5 faca

b[i] <- a[i]

fimpara

escreva("Digite b para mostrar a ordem inversa: ")

leia(op)

escolha (op)

caso "B"
 escreval(b[5])

escreval(b[4])

escreval(b[3])

escreval(b[2])

escreval(b[1])

fimescolha

fimalgoritmo

8. Os funcionários da empresa 'Dois Irmãos' receberão um reajuste de salário. Construa um

algoritmo (pseudocódigo) que: a. Leia o nome de um funcionário (dado do tipo caractere). b. Leia o
valor atual de seu salário (dado do tipo real). c. Leia o percentual de reajuste (assuma que as
entradas serão valores reais entre 0 e 100). d. Calcule o novo salário. e. Exiba o nome do
funcionário e o novo valor do salário.

algoritmo "Exer_8"

// Função :

// Autor : Majenda

// Data : 21-10-2015

// Seção de Declarações

var

a:caracter

b,c,d:real

inicio

// Seção de Comandos

escreval("Entre com o nome do funcionario")

leia(a)

escreval("Introduza o valor actual de ",a)

leia(b)

escreval("Introduza a percentual de reajuste")

leia(c)

se (c>=0) e (c<=100) entao

c <- b * (c / 100) // calculo de percentagem

d <- c + b // novo salario

escreval(a," Seu novo salario é: ",d)

senao

escreval("A percentual de reajuste so pode ser no intervalo de 0% a 100%, tente novamente.")

fimse

fimalgoritmo

11. Construa um algoritmo (pseudocódigo) que determine e mostre o maior número entre vários
fornecidos pelo usuário. A condição de parada é a entrada de um valor 0 (zero), ou seja, o algoritmo
deve ficar escolhendo o maior até que a entrada seja igual a 0 (zero). Utilize a estrutura ENQUANTO
... REPETIR ... no algoritmo. Assuma que valores negativos nunca serão informados pelo usuário.

algoritmo "Exer_11"

// Função :

// Autor : Majenda

// Data : 21-10-2015

// Seção de Declarações

var

num,Maior,menor:inteiro

inicio

maior <- 0

menor<-9999

num<-1

enquanto num <> 0 faca

escreval("digite o numero")

leia(num)

se (num > 0) entao

 se (num > maior) entao

maior <- num

fimse

se num < menor entao

menor <- num

fimse

fimse

fimenquanto

escreval("Menor é ",menor)

escreval("Maior é ",maior)

fimalgoritmo

12. Construa um algoritmo (pseudocódigo) que leia 500 valores inteiros e positivos e: a. Encontre e
mostre o maior valor. b. Encontre e mostre o menor valor. c. Calcule e mostre a média dos números
lidos. Utilize a estrutura ENQUANTO ... REPETIR ... no algoritmo.

algoritmo "Exer_12"

// Função :

// Autor : Majenda

// Data : 21-10-2015

// Seção de Declarações

var

i,nrs,nma,nme,soma:inteiro

media:real

inicio

// Seção de Comandos

nme<-99999

nma<-0
i<-1

enquanto i <= 500 faca

escreval(i)

se (i > nma) entao

nma <- i

fimse

se (i < nme) entao

nme <- i

fimse

soma<-soma+i

media<-soma/500

i<-i+1

fimenquanto

escreval("")

escreval("O numero maior é: ",nma)

escreval("O numero menor é: ",nme)

escreval("A media é: ",media)

fimalgoritmo

14. Utilizando a estrutura PARA... ATÉ... REPETIR..., construa um algoritmo (pseudocódigo) que exiba
os números ímpares entre 100 e 200. Dica: a função mod(X,Y) retorna o resto da divisão de X por Y.

algoritmo "Exer_14"

// Função :

// Autor : Majenda

// Data : 21-10-2015

// Seção de Declarações
var

x:inteiro

inicio

// Seção de Comandos

para x de 100 ate 200 faca

se (x % 2 = 1) entao

escreval(x)

fimse

fimpara

fimalgoritmo

15. Construa um algoritmo (pseudocódigo) que calcule a média de N números reais informados pelo
usuário, onde o valor de N também é informado no início da execução. Utilize a estrutura PARA...
ATÉ... REPETIR... Antes do término da execução do algoritmo, mostre a média calculada

algoritmo "Exer_15_Media_N_Numeros"

// Função : calcular media de n numeros informados pelo usuario

// Autor : Majenda

// Data : 21-10-2015

// Seção de Declarações

var

i,quant:inteiro

media,soma,numero:real

r:caracter

inicio

// Seção de Comandos

escreval("Informe a quantidade dos numeros")

leia(quant)
para i de 1 ate quant faca

escreva("Digite o ",i,"o numero: ")

leia(numero)

soma<-soma+numero

media<-soma/quant

fimpara

escreval("")

escreval("A media é: ",media)

fimalgoritmo

16. Tendo como dados de entrada a altura e o sexo de uma pessoa, construa um algoritmo
(pseudocódigo ) que calcule seu peso ideal, utilizando as seguintes fórmulas: Para homens: (72,7 *
altura) – 58. Para mulheres: (62,1 * altura) – 44,7

Ao perguntar o sexo, o algoritmo deverá garantir que as únicas entradas aceitas sejam ‘M’ para
homens e ‘F’ para mulheres. Ou seja, caso um valor diferente de ‘M’ ou ‘F’ seja informado, o
programa deverá requisitar ao usuário que informe o sexo novamente até a entrada ser válida. Dica:
utilize a estrutura de repetição mais adequada dentre as três vistas em aula.

algoritmo "Exer_16"

// Função :

// Autor : Majenda

// Data : 22-10-2015

// Seção de Declarações

var

altura,peso:real

genero,nome:caracter

inicio

// Seção de Comandos
Escreval("Informe teu nome")

leia(nome)

escreval("Informe tua altura")

leia(altura)

escreval("Informe teu genero")

leia(genero)

escreval("")

escolha (genero)

caso "M"

peso <- (72.7 * altura) - 58 // para homem

escreva("Senhor ",nome)

caso "F"

peso <- (72.1 * altura) - 44.7 // para mulher

escreva("Senhora ",nome)

fimescolha

enquanto (genero <> "M") e (Genero <> "F") faca

escreval("Informe teu genero. Sugestao: so eh permitido a entrada de M ou F")

leia(genero)

escreval("")

escolha (genero)

caso "M"

peso <- (72.7 * altura) - 58 // para homem

escreva("Senhor ",nome)

caso "F"

peso <- (72.1 * altura) - 44.7 // para mulher

escreva("Senhora ",nome)

fimescolha
 fimenquanto

escreval(" teu peso é: ",peso)

escreval("")

fimalgoritmo

17. Escreva um algoritmo (pseudocódigo) que leia três valores inteiros e mostre-os em ordem
decrescente. Dica: utilize estruturas de decisão encadeadas.

algoritmo "Exer_17"

// Função :

// Autor : Majenda

// Data : 22-10-2015

// Seção de Declarações

var

a,b,c:inteiro

inicio

// Seção de Comandos

escreval("Informe tres valores")

leia(a,b,c)

se (a<b) e (b<c) entao

escreval(a,b,c)

senao

se (a<b) e (b>c) e (c>a) entao

escreval(a,c,b)

senao

se (a>b) e (a>c) e (b>c) entao

escreval(c,b,a)

senao
 se (a>b) e (b<c) e (c<a) entao

escreval(b,c,a)

senao

se (a>b) e (b<a) e (c>a) entao

escreval(b,a,c)

senao

se (a<b) e (b>c) e (c<a) entao

escreval(c,a,b)

fimse

fimse

fimse

fimse

fimse

fimse

fimalgoritmo

18. Construa um algoritmo (pseudocódigo) que escreva uma contagem de 10 (dez) minutos, ou seja,
mostre 0:00, e então 0:01, 0:02, ..., 0:58, 0:59, 1:00, 1:01, 1:02,...,até 10:00. Dica: utilize a estrutura
de repetição mais adequada dentre as três vistas em aula.

algoritmo "CRONOMETRO"

// Função :

// Autor : Majenda

// Data : 22-10-2015

// Seção de Declarações

var

hora, minuto, segundo:Inteiro

inicio
// Seção de Comandos

hora <- 0

minuto <- 0

segundo <-0

//enquanto hora < 25 faca

enquanto minuto < 10 faca

timer 1000 //simulacao do tempo real

timer 0

segundo <- segundo + 1 // contador de segundos

se segundo > 59 entao // controlador de segundos

segundo <- 0 // zero segundo = a 60 segundos

//-------------------------------

minuto <- minuto + 1

se minuto > 59 entao

minuto <- 0

//-------------------------------

hora <- hora + 1

se hora > 23 entao

hora <- 0 // //zero hora = a 24 horas//

fimse

fimse

fimse

limpatela

escreval(hora,"h:",minuto,"m:",segundo,"s")

fimenquanto

fimalgoritmo
19. Construa três algoritmos (pseudocódigos) que imprimam a tabuada do 5 (cinco). Em cada um
deles utilize uma das estruturas de repetição vistas em aula. Dica: verifique se o resultado está
correcto fazendo um teste de mesa para cada uma das soluções apresentadas.

algoritmo "Exer_19"

// Função :

// Autor : Majenda

// Data : 22-10-2015

// Seção de Declarações

var

numero,i:inteiro

inicio

// Seção de Comandos //

numero <- 5

i <- 1

enquanto i < 13 faca

escreval(numero," X ",i," = ",numero * i)

i <- i + 1

fimenquanto

fimalgoritmo

20. Escreva um algoritmo que leia 20 valores inteiros e ao final exiba: a) a soma dos números
positivos; b) a quantidade de valores negativos

algoritmo "Exer_20_SomaPosi_QntNegat"

// Função :

// Autor : Majenda

// Data : 22-10-2015

// Seção de Declarações
var

num,quant,i,soma,positivo:inteiro

inicio

quant <- 0 // a variavel (quant) recebe o valor zero (0)

soma <- 0 // a variavel (soma) recebe o valor zero (0)

escreval("Informe 20 numeros inteiros") // pede para o usuario digitar 20 numeros inteiros

para i de 1 ate 20 faca

leia(num)

se (num > 0) entao // se o numero digitado for maior que zero entao ele faz parte da soma

soma <- soma + num

fimse

se (num < 0) entao // numero menor que zero faz parte da quantidade

quant <- quant + 1

fimse

fimpara

escreval("A soma dos numeros positivos é ",soma)

escreval("")

escreval("A quantidade dos numeros negativos é: ",quant)

escreval("")

fimalgoritmo

21. Faça um algoritmo que escreva na tela os números de um número inicial a um número final. Os
números inicial e final devem ser informados pelo usuário;

algoritmo "Exer_21"

// Função :

// Autor : Majenda

// Data : 25-10-2015
// Seção de Declarações

var

i,numinicial,numfinal,pass:inteiro

inicio

escreval("Informe o valor inicial da contagem") // informe o usuario para introduzir o valor inicial da
contage

leia(numinicial)

escreval("Informe o valor final da contagem") // informe o usuario para introduzir o valor final da
contagem

leia(numfinal)

escreval("informe o passo") // informe o usuario para digitar o passo

leia(pass)

para i de numinicial ate numfinal passo pass faca

escreval(i)

fimpara

fimalgoritmo

22. Escrever um algoritmo que imprima a tabuada de um número informado pelo usuário

algoritmo "Exer_22_Tabuada"

// Função :

// Autor : Majenda

// Data : 22-10-2015

// Seção de Declarações

var

i , n : inteiro

inicio

i<-1
 escreval("Informe o numero")

leia(n)

repita

escreval(n," X ",i," = ",n*i)

i<-i+1

ate i > 12

fimalgoritmo

23. Escrever um algoritmo que gera e escreve os números ímpares entre 100 e 200;

algoritmo "Exer_23_Impar"

// Função :

// Autor :

// Data : 22-10-2015

// Seção de Declarações

var

impar,i:Inteiro

inicio

i<-100

para i de 100 ate 200 faca

se (i mod 2 = 1) entao

escreval(i)

fimse

fimpara
24. Em uma turma há 10 alunos. Cada aluno tem 2 notas. Um professor precisa calcular a média das
duas notas de cada aluno. Crie um programa que resolve este problema.

algoritmo "Exer_24"

// Função :

// Autor : Majenda

// Data : 22-10-2015

// Seção de Declarações

var

n1,n2,media:real

nome:caracter

i:inteiro

inicio

i <- 1

enquanto i < 11 faca

escreval("Informe o nome do ",i,"o estudante ")

leia(nome)

escreval("Informe a primeira nota do ",nome)

leia(n1)

escreval("Informe a segunda nota do ",nome)

leia(n2)

limpatela

media <- (n1+n2)/2

escreval("A media do aluno ",nome," é: ",media)

escreval("")

i<-i+1

fimenquanto

fimalgoritmo
26. Faça o mesmo que antes, porém, ao invés de ler 10 números, o programa deverá ler e somar
números até que o valor digitado seja zero ( 0 ).

algoritmo "Exer_26"

// Função :

// Autor : Majenda

// Data : 22-10-2015

// Seção de Declarações

var

soma,n1,n2:inteiro

inicio

escreval("Introduza o 1o numero")

leia(n1)

soma<-n1

escreval("Digite o numero a somar")

leia(n2)

soma<-soma+n2

se (n2 = 0) entao

escreval("A soma é: ",soma)

fimse

enquanto n2 <> 0 faca

escreval("Digite o numero a somar")

leia(n2)

soma<-soma+n2

se (n2 = 0) entao

escreval("A soma é: ",soma)

fimse
 fimenquanto

fimalgoritmo

27. Escreva um algoritmo que calcule a média dos números digitados pelo usuário, se eles forem
pares. Termine a leitura se o usuário digitar zero (0);

algoritmo "Exer_27_Media_Pares"

// Função :

// Autor : Majenda

// Data : 22-10-2015

// Seção de Declarações

var

quant,par,media,soma:real

i,num:inteiro

inicio

num <-1

// a variavel (num) recebe o valor de um (1) para satisfazer a condicao abaixo, porq se nao atribuir
um valor diferente

// de zero a varial (num) entao ele considera (num) como zero e logo (num = 0) termina a execcao.

enquanto num <> 0 faca

escreval("Digite o numero")

leia(num)

se (num % 2 = 0) entao

quant <- quant + 1

se num = 0 entao

quant <- quant - 1 // subtrai (1) porque o valor zero tambem ele eh lido como um numero par,
e zero nao adiciona nada

fimse
 par <- num

soma <- soma + par

media <- soma / quant

fimse

fimenquanto

escreval("")

escreval("A soma dos numeros pares é: ",soma)

escreval("A media dos numeros pares é: ",media)

escreval("")

fimalgoritmo

28. Escreva um algoritmo que leia valores inteiros e encontre o maior e o menor deles. Termine a
leitura se o usuário digitar zero (0);

algoritmo "Exer_28_Maior_d_varios"

// Função :

// Autor : Majenda

// Data : 23-10-2015

// Seção de Declarações

var

i,nrs,nma,nme:inteiro

inicio

// Seção de Comandos

nme<-999 // numero menor recebe numero maior

nma<-0 // numero maior recebe numero menor

nrs<-1 // numeros recebe o valor inicial diferente de zero

enquanto nrs <> 0 faca

escreva("Informe o numero ")

leia(nrs)

se (nrs > nma) entao

nma <- nrs

fimse

se (nrs < nme) e (nrs <> 0) entao

nme <- nrs

fimse

fimenquanto

escreval("")

escreval("O numero maior é: ",nma)

escreval("O numero menor é: ",nme)

escreval("")

fimalgoritmo

30. Escreva um programa que leia dois valores reais. Ambos valores deverão ser lidos até que o
usuário digite um número no intervalo de 1 a 100. Apresentar a soma dos dois valores lidos.

algoritmo "Exer_30"

// Função :

// Autor : Majenda

// Data : 25-10-2015

// Seção de Declarações

var

x,y,soma:Real

i:inteiro

inicio
escreval("Digite um numero no intervalo de 1 a 100")

leia(i)

se (i >= 1) e (i <= 100) entao

escreval("Digite dois (2) valores reais")

leia(x,y)

soma <- x+y

escreval(x," + ",y," = ",soma)

senao

escreval(i," nao pertence ao intervalo de 1 a 100")

fimse

fimalgoritmo

31. Escreva um programa que lido um número, calcule e informe o seu fatorial. Ex.: 5! = 5 * 4 * 3 * 2
* 1 = 120.

algoritmo "Exer_31_Fatorial"

// Função :

// Autor :

// Data : 23-10-2015

// Seção de Declarações

var

n,resultado:inteiro

inicio

// fatorar é multiplicar os numeros ate o numero dado

// exemplo: fatorial de 6 = 1 X 2 X 3 X 4 x 5 X 6 = 720

resultado <- 1 // a variavel resultado recebe o valor de 1

escreval("Informe o numero")

leia(n)
enquanto n > 1 faca // neste bloco o programa repetira anquanto a variavel (n) for maior que 1

resultado <- resultado * n // a variavel (resultado) vai ser multiplicado pela variavel (n) ate qua a (n)
seja igual a 1

n <- n - 1 // a variavel n, seu conteudo diminuindo de 1

fimenquanto

escreval("Fatorial é ",resultado) // mostra o resultado na tela

fimalgoritmo

35. Digitados dois números (base e expoente –b), calcule o resultado utilizando apenas
multiplicações;

algoritmo "Expoente"

// Função :

// Autor :

// Data : 26-10-2015

// Seção de Declarações

var

a,res,res2:real

i,b:inteiro

inicio

escreval("Digite a base")

leia(a)

escreval("Digite expoente")

leia(b)

res <- exp(a,b)

escreval(a," com expoente ",b," é igual a = ",res)

// -----------------------------------------------------------------------//

// Assumindo que os dois numeros ja foram informados, o algoritmo acima usando apenas
multiplicações fica:
 res2 <- 1

para i de 1 ate b faca

res2 <- res2 * a

fimpara

escreval(a," com expoente ",b," é igual a = ",res2)

fimalgoritmo