Exercicios Resolvidos De Programação Visualg.pdf

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 (ac) 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 (bb) e (ba) entao escreval(b,a,c) senao se (ac) e (c
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 rel="nofollow"> 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