Baixe o app para aproveitar ainda mais
Prévia do material em texto
Algoritmos e Laboratório de Programação I Lista I – Solucionário em Portugol Exercícios com * indicam que há outra forma de resolução no final do documento EXERCÍCIO 01: Sendo A= 3, B= 7 e C= 4, informe se as expressões abaixo são verdadeiras ou falsas. a) (A+C) > B F b) B >= (A + 2) V c) C = (B - A) V d) (B + A) <= C F e) (C+A) > B F EXERCÍCIO 02: Sendo A=5, B= 4 e C= 3 e D= 6, informe se as expressões abaixo são verdadeiras ou falsas. a) (A > C) E (C <= D) (5 >3) E (3 <= 6) Verdadeiro E Verdadeiro = Verdadeiro b) (A+B) > 10 OU (A + B ) = (C + D) (5 + 4) > 10 OU (5 + 4) = (3 + 6) Falso OU Verdadeiro = Verdadeiro c) (A>=C) E (D >= C) (5 >=3) E (6 >= 3) Verdadeiro E Verdadeiro = Verdadeiro EXERCÍCIO 03: a) B = A * C E L1 Substituindo os valores de A, B, C e L1, temos: 7 = 2 * 3.5 E falso 7 = 7 E falso verdadeiro E falso O resultado da expressão lógica com o operador E somente será verdadeiro quando ambos os valores de cada lado do operador forem verdadeiros. Então, o resultado dessa expressão lógica é: falso. b) "dia" = S1 OU "frio" != "clima" Substituindo o valor de S1,temos: "dia" = "noite" OU "frio" != "clima" falso OU verdadeiro O resultado da expressão lógica com o operador OU somente será falso quando ambos os valores de cada lado do operador forem falsos. Então, o resultado dessa expressão lógica é: verdadeiro. c) A + C < 5 Substituindo os valores de A e S1, temos: 2 + 3.5 < 5 Falso d) A * C / B > A * B * C Substituindo os valores de A, B e C, temos: 2 * 3.5 / 7 > 2 * 7 * 3.5 7 / 7 > 14 * 3.5 1 > 49 Falso e) NÃO FALSO O operador lógica NÃO denota o oposto do valor lógico seguinte. Então, o resultado dessa expressão lógica é: verdadeiro. EXERCÍCIO 04: Determine o resultado lógico das expressões mencionadas (Verdadeira ou Falsa). Considere para as respostas os seguintes valores: X= 1, A= 3, B= 5, C=8 e D=7. a) NÃO (X > 3) Verdadeiro b) (X < 1) E (NÃO (B > D)) Falso c) NÃO (D < 0) E (C > 5) Verdadeiro d) NÃO ((X > 3) OU (C < 7)) Verdadeiro e) (A > B) OU (C > B) Verdadeiro f) (X >= 2) Falso g) (X < 1) E (B >= D) Falso h) ( D < 0) OU (C > 5) Verdadeiro i) NÃO (D > 3) OU (NÃO (B < 7)) Falso j) (A > B) OU (NÃO (C > B)) Falso EXERCÍCIO 05: //Efetuar a soma dos números 5 e 10 e imprimir o resultado principal { inteiro P1, P2, SOMA; //declaração de 3 variáveis inteiras P1 <- 5; //a 1ª parcela inteira é 5 P2 <- 10; //a 2ª parcela inteira é 10 SOMA <- P1 + P2; //a soma inteira é 5 + 10 imprima("A saída é:”, SAIDA); //impressão do resultado soma } EXERCÍCIO 06: //Efetuar a soma de três números digitados pelo usuário e imprimir o resultado. principal { //declaração de variáveis do tipo real real A,B,C,SOMA; //leitura dos números informados pelo usuário imprima ("Informe o primeiro número: "); leia (A); imprima ("Informe o segundo número: "); leia (A); imprima ("Informe o terceiro número: "); leia (C); //a variável soma recebe a soma de A, B e C SOMA <- A+B+C; //resultado imprima (“A soma é: ”,SOMA); } EXERCÍCIO 07: //Efetuar a multiplicação de dois números digitados pelo usuário e imprimir o resultado. principal { //declaração de variáveis do tipo inteiro (inteiro) inteiro a,b,produto; //leitura dos números informados pelo usuário imprima("Informe o primeiro numero: "); leia(a); imprima("Informe o segundo numero: "); leia(b); //a variável produto recebe o produto de a por b produto ← a*b; //resultado imprima("O produto eh: ",produto); } EXERCÍCIO 08: //Calcular o aumento que será dado a um funcionário, obtendo do usuário as //seguintes informações : salário atual e a porcentagem de aumento. //Apresentar o novo valor do salário e o valor do aumento. principal { //declaração de variáveis do tipo real (real) real salario, aumento, novo_salario; //leitura de dados do funcionário imprima("Informe seu salario atual"); leia(salario); imprima ("Informe a porcentagem de aumento"); leia (aumento); //calculo do aumento salarial aumento ←salario*aumento/100; //calculo novo_salario←salario+aumento; //impressão imprima ("O valor do aumento salarial é", aumento); imprima ("O valor do novo salario é ", novo_salario); } EXERCÍCIO 09: //Converter uma quantidade de horas digitadas pelo usuário em minutos. //Informe o resultado em minutos. principal { //declaração das variáveis inteiras (trata-se de quantidade e não frações) int horas,minutos; //leitura das horas imprima("Horas: "); leia(horas); //conversão horas para minutos (X 60) minutos ← horas*60; //impressão do resultado em minutos imprima("Em minutos, é ",minutos); } EXERCÍCIO 10: // Leitura: salário bruto e número de horas extras //Cálculo: //salário líquido = (salário bruto + valor das horas extras) - 8% do total de INSS //Mostrar: salário líquido principal { // Declaração de Variáveis: //horas: quantidade de horas extras (inteiro) //bruto: salario bruto (real) //valor_extra: valor de cada hora extra (real) //liquido: salário líquido a ser calculado (real) inteiro horas; real bruto,valor_extra,liquido; //Leitura das Informações imprima("Digite o valor do salário bruto do funcionário: "); leia(bruto); imprima("Digite o valor das horas extras: "); leia(valor_extra); imprima("Digite a quantidade de horas extras trabalhadas pelo funcionário: "); leia(horas); // O cálculo do salário líquido é: // 1) Extra = horas * valor_extra (valor extra total recebido) // 2) Salario Parcial = Salário Bruto + Extra (sem desconto) // 3) INSS = 8% do Salario Parcial, ou seja, 0.8 * Salario Parcial // 4) Salario Liquido = Salario Parcial - INSS = (1 - 0.8)* Salario Parcial= 0.92 * Salario Parcial liquido = 0.92 * (bruto + horas * valor_extra); //Impressão do Salário Líquido: imprima("O salário líquido do funcionário é de: ", liquido); } EXERCÍCIO 11: //Leitura do nº de Kw consumido //Preço: 0.12 por kw //Calcular valor a ser pago: 0.12 * qtd_de_kw + 18% do ICMS principal { // Declaração de Variáveis // KW é a quantidade de kW consumido e VALOR é o valor a pagar real KW, VALOR; imprima("Informe a quantidade de Kw consumidos:"); leia(KW); //1º cálculo: valor será 0.12 por Kw VALOR <- KW * 0,12; //2º cálculo: pagará 100% do valor + 18% deste, ou seja, 118%. Ou //seja: VALOR <- VALOR * 1,18; //Impressão do valor: imprima("Valor total a ser pago: “, VALOR); } EXERCÍCIO 12: //Calcular a média de combustível gasto pelo usuário, sendo informado a //quantidade de quilômetros rodados e a quantidade de combustível //consumido. principal { //declaração das variáveis reais real km,comb,media; //leitura da quantidade de km rodados imprima("Quantidade de KM rodados: "); leia(km); //leitura da quantidade de combustivel consumido imprima("Quantidade de Combustivel consumido: "); leia(comb); //cálculo da média (resultado real) media ← comb/km; //impressão da media imprima("A media de combustivel por km é: ",media); } EXERCÍCIO 13: //Efetuar a leitura de uma nota e, se o valor for maior ou igual a 60, imprimir na tela "APROVADO". principal { //declaração da variavel nota inteiro nota; //leitura da nota imprima("Nota do aluno(a): "); leia(nota); //comparação e impressão da mensagem se (nota > 60) então imprima("APROVADO"); } EXERCÍCIO 14: //Leia uma nota //nota >= 60 -> APROVADO //nota < 60 -> REPROVADO principal { //Declaraçãoda variável nota real nota; //Leitura da Nota imprima(“Digite a nota: ”); leia (nota); //Verificar se nota é maior ou igual a 60 se (nota > 60) entao//verifica se a nota é maior ou igual a 60 { imprima (“Aprovado”); //caso a condição em se for verdadeira } senão { imprima (“Reprovado”); //caso a condição em se for falsa } } EXERCÍCIO 15: //Efetuar a leitura de uma nota e, se o valor for maior ou igual a 60, imprimir na tela "APROVADO", se for menor, imprimir reprovado. Testar ainda se o valor lido foi maior do que 100 ou menor do que zero. Neste caso, imprimir "NOTA INVÁLIDA". principal { //declaração da variavel nota //Motivo de ser real: suponhamos que a nota é 100.1 //Deve ser nota inválida //se fosse inteiro, ele pegaria a parte inteira de //100.1 que é 100 e diria que está aprovado. //Como real ele não comete este erro. real nota; //leitura da nota imprima ("Nota do aluno(a): "); leia (nota); //comparação e impressão da mensagem se ((nota<0) OU (nota>100))entao imprima (“NOTA INVÁLIDA"); senão se (nota<60)entao imprima ("REPROVADO"); senão imprima ("APROVADO"); } EXERCÍCIO 16: //Ler um número inteiro e informar se o número lido é par ou impar. principal { inteiro NUM; //Declaração de variável inteira. imprima(“Informe um número: ”); leia(NUM); //Leitura do número se(NUM mod 2 = 0)entao //Se o resto da divisão por 2 é zero... { imprima(“PAR”); //imprime “par” } senão //senão... { imprima(“ÍMPAR”); //imprime “ímpar” } } EXERCÍCIO 17: //Ler um número inteiro //Testar se termina com 0 (divisível por 10) //-> Se sim, exiba METADE do numero //-> Se não, exiba "O número digitado não termina com 0" principal { inteiro NUM; //Declaração de variável inteira NUM imprima(“Digite um número: ”); leia(NUM); //Leitura do número se(NUM mod 10 = 0)entao //Testando se NUM é divisível por 10 { //Se sim, imprime metade de NUM. Observe que poderíamos criar outra variável conta ← num div 2 e imprimir ela imprima(“A metade deste numero é: ”, NUM div 2); } senão { //Se não, imprime a mensagem imprima(“O número digitado não termina com 0”); } } EXERCÍCIO 18: // Ler um número e informar se ele é positivo, negativo ou neutro (zero). principal { //declaração de variáveis do tipo inteiro inteiro num; //leitura e armazenamento do valor imprima("Digite um numero"); leia(num); //compara e avalia se o valor é positivo, //negativo ou neutro e imprime o resultado se (num=0) entao imprima ("O valor lido é neutro"); senão se (num>0) entao imprima ("O valor lido é positivo"); senão imprima ("O valor lido é negativo"); } EXERCÍCIO 19: //Faça a leitura do salário atual e do tempo de serviço de um funcionário. A seguir, calcule o seu salário reajustado. Funcionários com até 1 ano de empresa, receberão aumento de 10%. Funcionários com mais de um ano de tempo de serviço, receberão aumento de 20%. principal { //Declaração de variáveis: todos são número reais. real SALARIO, TEMPO, NOVO; //Leitura do salário imprima (“Informe o salário:”); leia (SALARIO); //Leitura do Tempo de serviço imprima (“Informe o tempo de servico em anos:”); leia (TEMPO); // 1ª parte do se // se o tempo é de até um ano, o reajuste é 10%, ou seja, o novo salario é 110% do antigo, ou seja, é o salário antigo multiplicado por 1.1; // 2ª parte do se // reajuste de 20%, novo salário é 120%, salário antigo multiplicado por 1.2. se (TEMPO ≤ 1)entao { NOVO ← SALARIO * 1.1; imprima (“O novo salario e: “, NOVO); } senão { NOVO ← SALARIO * 1.2; imprima (“O novo salario e: “, NOVO); } } EXERCÍCIO 20: //Leitura: Ano atual, ano de nascimento //Exibir: sua idade e classificação //-> 0 a 3 anos: Bebê //-> 4 a 10 anos: Criança //-> 11 a 18 anos: Adolescente //-> 19 a 50 anos: Adulta //-> 51 ou mais: Idoso principal { //Declaração de Variáveis (dois anos e uma idade inteiros) inteiro ano_atual,ano_nasc,idade; //Leitura de ambos imprima("Informe o ano atual: "); leia(ano_atual); imprima("Informe o ano de nascimento: "); leia(ano_nasc); //Cálculo da idade idade ← ano_atual - ano_nasc; //Exibir idade imprima("Sua idade é:",idade); //Exibir Classificação se(idade<0)entao { imprima("Idade Inválida"); //não existe idade negativa } senao { se((0<=idade) E (idade<=3))entao { imprima("Bebê"); //comparei como >=0 e <=3 } senao { se((4<=idade) E (idade<=10))entao { imprima("Criança"); //comparei como >=4 e <=10 } senao { se((10<idade) E (idade<19))entao { imprima("Adolescente"); //comparei como >10 e <19, que é 11 a 18 } senao { se((18<idade) E (idade<51))entao { imprima("Adulto "); //19 a 50 } senao { imprima("Idoso "); //o quê restou foi 51 ou mais } } } } } } EXERCÍCIO 21: //Informar o número do mês do ano e mostrar o nome do mês por extenso. //Caso o número do mês não exista, exibir a mensagem "Mês inválido". principal { //declaração da variável mes que será de 1 a 12 inteiro mes; //leitura do numero do mes imprima ("Informe o numero do mes: "); leia (mes); //comando escolha com 12 casos + senão //de 1 a 12, irá imprimir o mes correspondente //o senão informa que o numero é inválido, ou seja, //se não estar em [1,12], é inválido escolha (mes) { caso 1: imprima ("Janeiro"); caso 2: imprima ("Fevereiro"); caso 3: imprima ("Marco"); caso 4: imprima("Abril"); caso 5: imprima ("Maio"); caso 6: imprima ("Junho"); caso 7: imprima ("Julho"); caso 8: imprima ("Agosto"); caso 9: imprima ("Setembro"); caso 10: imprima ("Outubro"); caso 11: imprima("Novembro"); caso 12: imprima("Dezembro"); senão: imprima ("Mes Invalido"); } } EXERCÍCIO 22: //Faça um algoritmo que receba o valor do salário de uma pessoa e o valor de um financiamento pretendido. Caso o financiamento seja menor ou igual a 5 vezes o salário da pessoa, o algoritmo deverá escrever "Financiamento Concedido"; senão, ele deverá escrever "Financiamento Negado". principal { //Declaração das variáveis real SALÁRIO, FINANC; real RAZÃO; //razão entre financiamento e salário //Leitura do salário e financiamento imprima(“Digite o salário e o valor do financiamento: ”); leia(SALÁRIO, FINANC); //Cálculo da razão “financiamento/salário RAZÃO ← FINANC / SALÁRIO; se(RAZÃO > 5)entao //Se razão > 5... { //O financiamento será negado imprima(“Financiamento Negado”); } senão //Senão... { //O financiamento será concedido imprima(“Financiamento Concedido”); } } EXERCÍCIO 23: //Calcular e mostrar o salário semanal de uma pessoa: //-> número de horas trabalhadas < 40, a pessoa recebe R$15,00 por hora //-> senão recebe R$600,00 + R$21,00 para cada hora a mais de 40 horas //Leia o número de horas trabalhadas e informe o salário. principal { //Declaração de variáveis: horas é um numero inteiro e o salário é real. inteiro HORAS; real SALARIO; //Leitura da quantidade de horas. imprima (“Informe o numero de horas trabalhadas:”); leia (HORAS); //Cálculo do Salário se (HORAS<40) //Se o número de horas é menor que 40, o salario é R$15.00 por hora. { salario ← HORAS * 15; } //Caso contrário, o salário será 600 + R$21.00 por hora excedente senão { SALARIO ← 600 + 21 * (HORAS - 40); // hora excedente = HORAS - 40. } //Impressao imprima ("O salário semanal desta pessoa é:", SALARIO); } EXERCÍCIO 24: //A taxa de juro depende do tempo. Num banco: //1) 5 anos =< tempo ---> 0.95 //2) 4 anos =< tempo < 5 anos ---> 0.9 //3)3 anos =< tempo < 4 anos ---> 0.85 //4) 2 anos =< tempo < 3 anos ---> 0.75 //5) 1 ano =< tempo < 2 anos ---> 0.65 //6) tempo < 1 ano ---> 0.55 //Receba o tempo em que os fundos foram mantidos em depósito e informe a taxa de //juros correspondente. principal { // Declaração de Variáveis: // Perceba que é complicado fornecer frações de anos. É mais fácil informar o // tempo em meses. A partir daí, dividimos por 12 e sabemos a fração de ano // correspondente. // Por isso, duas variáveis: meses (inteiro) e anos (real). inteiro MESES; real ANOS; imprima("Informe o tempo(meses) em que os fundos foram mantidos em deposito:"); leia(MESES); ANOS <- MESES/12; // Cálculo da fração de ano correspondente // Impressão dos valores correspondentes // Esta é outra maneira de encadear SE's. Repare que no último SENÃO, ainda // colocamos uma condição SE. Se não o tivéssemos feito, anos negativos // poderiam ser considerados se(ANOS>=5)entao imprima("Taxa de juros de 0,55"); senão se(ANOS < 5 E ANOS>=4) entao imprima("Taxa de juros de 0,65"); senão se(ANOS < 4 E ANOS>=3) entao imprima("Taxa de juros de 0,75"); senão se(ANOS < 3 E ANOS>=2) então imprima("Taxa de juros de 0,85"); senão se(ANOS < 2 E ANOS>=1) então imprima("Taxa de juros de 0,9"); senão se(ANOS < 1 E ANOS>=0) imprima("Taxa de juros de 0,95"); } EXERCÍCIO 25: /*Classifica-se a classe de peso e taxa de registro de um carro pelo seu ano e peso. 1) Ano <= 1970: a) peso < 1200 ---> Classe 1 / Taxa de 16.50 b) 1200 =< peso <= 1700 ---> Classe 2 / Taxa de 25.50 c) 1700 < peso ---> Classe 3 / Taxa de 46.50 2) 1971 <= Ano <= 1979: a) peso < 1200 ---> Classe 4 / Taxa de 27.00 b) 1200 =< peso <= 1700 ---> Classe 5 / Taxa de 30.50 c) 1700 < peso ---> Classe 6 / Taxa de 52.50 3) Ano >= 1980: a) peso < 3600 ---> Classe 7 / Taxa de 19.50 b) 3600 <= peso ---> Classe 8 / Taxa de 52.50 Programa recebe peso e ano -> informa classe e taxa*/ principal { inteiro ANO; //Declaração de variável inteira real PESO; //Declaração de variável real //Leitura do ano do carro imprima(“Informe o ano do carro: ”); leia(ANO); //Leitura do peso do carro imprima(“Informe o peso do carro: ”); leia(PESO); //1º caso se(ANO < 1970)entao { se(PESO < 1200)entao imprima(“Classe: 1 Taxa de Registro: R$ 16,50”); senão { se(PESO > 1200 E PESO < 1700)entao imprima(“Classe: 2 Taxa de Registro: R$ 25,50”); senão //senão > 1700 (situação que restou) imprima(“Classe: 3 Taxa de Registro: R$ 46,50”); } } senão { se(ano > 1970 e ano < 1980)entao { se(PESO < 1200)entao imprima(“Classe: 4 Taxa de Registro: R$ 27,00”); senão { se(PESO > 1200 E PESO < 1700)entao imprima(“Classe: 5 Taxa de Registro: R$ 30,50”); senão imprima(“Classe: 6 Taxa de Registro: R$ 52,50”); } } senão //este “senão” é relativo ao ano restante ( > 1980) { se(peso < 3600)entao imprima(“Classe: 7 Taxa de Registro: R$19,50”); senão imprima(“Classe: 8 Taxa de Registro: R$52,50”); } } } EXERCÍCIO 26: //Ler as informações de um aluno: //-> notas em 2 provas (entre 0 e 10) //-> nota de um trabalho (entre 0 e 10) //-> sua frequência (número de ausências) //Condições: //-> reprovado se faltou mais de 15 aulas //-> aprovado se não for reprovado por falta e média >= 6,0 //-> Prova final se média < 6,0 //Média: //-> peso 3 para a 1ª prova //-> peso 5 para a 2ª prova //-> peso 2 para o trabalho principal { //Declaração de Variáveis: // P1, P2: notas das provas // TRAB: nota do trabalho // MEDIA: média final do aluno: 3*p1 + 5*p2 + 2*TRAB // Essa soma dividida por 10 é a média // FREQ: total de ausências real P1, P2, TRAB, MEDIA; inteiro FREQ; //Leitura dos Dados imprima("Informe a nota da 1ª prova: "); leia(P1); imprima("Informe a nota da 2ª prova: "); leia(P2); imprima("Informe a nota do trabalho "); leia(TRAB); imprima("Informe a freqüência /total de ausências/:"); leia(FREQ); //Cálculo da Média MEDIA <- (3 * P1 + 5 * P2 + 2 * TRAB)/10; //1º Teste: freqüência se(FREQ>15)entao imprima("Reprovado"); senão//não foi reprovado por freqüência. Agora é a média que qualifica { se (MEDIA>=6)entao imprima("Aprovado"); senão imprima("Reprovado"); } } EXERCÍCIO 27: //Leia um código e apresente o cargo correspondente //Se não existir o código, diga "código inválido" //Código Cargo //101 - Vendedor //102 - Atendente //103 - Auxiliar Técnico //104 - Assistente //105 - Coordenador de Grupo //106 - Gerente principal { //Declaração de variáveis inteiro CODIGO; //Leitura do Código imprima ("Digite o código do cargo do funcionário: "); leia (CODIGO); //Múltipla escolha escolha (CODIGO) { //Se a variável for igual a 101 caso 101: imprima ("Cargo: Vendedor"); //Se a variável for igual a 102 – e assim por diante. caso 102: imprima ("Cargo: Atendente"); caso 103: imprima ("Cargo: Auxiliar Técnico"); caso 104: imprima ("Cargo: Assistente"); caso 105: imprima ("Cargo: Coordenador de Grupo"); caso 106: imprima ("Cargo: Gerente"); // Caso a variável não assuma os valores acima, o senão é executado. senão: imprima ("Código Inválido."); } } EXERCÍCIO 28: //Código de 1 a 4, que indica o tipo seguinte: //Código Tipo da unidade //1 CD-ROM (700MB) //2 DVD-ROM (4.7GB) //3 DVD-9 (8.54 GB) //4 Blu-Ray (25 GB) //Receba o código e informe o tipo correto de unidade de disco. principal { inteiro CODIGO; // variável CODIGO que será usado na múltipla escolha //Leitura do Código imprima ("Informe o código: "); leia (CODIGO); //múltipla escolha entre 4 casos específicos e um senão escolha (CÓDIGO) { caso 1: imprima ("CD-ROM (700MB)"); caso 2: imprima ("DVD-ROM (4.7GB)"); caso 3: imprima ("DVD-9 (8.54 GB)"); caso 4: imprima ("Blu-Ray (25 GB)"); senão: imprima ("Código Inválido"); // caso Codigo difente 1,2,3,4 } } EXERCÍCIO 29: /*Escreva um programa que receba dois números reais e um código de seleção do usuário. Se o código digitado for 1, faça o programa adicionar os dois números previamente digitados e mostrar o resultado; se o código de seleção for 2, os números devem ser multiplicados; se o código de seleção for 3, o primeiro número deve ser dividido pelo segundo. Se nenhuma das opções acima for escolhida, mostrar "Código inválido".*/ principal { //declaração dos dois números reais e resultado da operação realizada real A,B,RESULT; //declaração do código de seleção inteiro COD; //leitura dos dois números imprima ("Insira dois números reais : "); leia (A,B); //leitura do código imprima ("Insira o código: "); leia (COD); //Opções disponíveis: // COD = 1 : somar // COD = 2 : multiplicar // COD = 3 : dividir // outro COD = inválido escolha (COD) { caso 1: { RESULT ← A + B; imprima ("A soma é: ",RESULT); } caso 2: { RESULT ← A * B; imprima ("O produto é: ",RESULT); } caso 3: { se(b != 0) então { RESULT ← A div B; imprima ("O quociente é: ",RESULT); } senão imprima ("impossível realizar divisão”); } senão : imprima ("Código Inválido"); } } EXERCÍCIO 30: //Transforma a nota de um aluno em conceito. As notas //10 e 9 receberão conceito A, as notas 8 e 7 receberão conceito B, as notas 6 //e 5 receberão conceito C e abaixo de 5 conceito D. principal { //declaração de variáveis inteiro NOTA; //leitura da nota do aluno imprima ("Informe o valor da nota "); leia (NOTA); //compara a nota e atribui o conceito correspondente se ((NOTA<0) OU (NOTA>10))entao imprima ("Nota inválida"); senão se ((NOTA = 9) OU (NOTA= 10))entao imprima ("Conceito A"); senão se ((NOTA = 8) OU (NOTA = 7))entao imprima ("Conceito B"); senão se ((NOTA = 6) OU (NOTA = 5))entao imprima ("Conceito C"); senão imprima ("Conceito D"); } EXERCÍCIO 31: //Dados 2 valores inteiros positivos entre 1 e 10 //se soma < 8, informe média //se soma = 8, informe produto //se soma > 8, informe quociente do maior pelo menor principal { //declaração de variáveis inteiro n1, n2, soma, produto, aux; real media, quociente; //leitura faça { imprima("Digite dois inteiros entre 1 e 10: "); leia (n1,n2); //n1,n2 entre [1,10] }enquanto((n1<1) OU (n1>10) OU (n2<1) OU (n2>10)); //calcula a soma soma ← n1+n2; //se soma<8 se (soma<8)entao { media ← (n1+n2)/2; imprima("A média é",media); } senão { se(soma=8) entao { produto ← n1*n2; imprima("O produto é ", produto); } senão { se (n1<n2)entao { aux ← n1; n1 ← n2; n2 ← aux; } quociente ← n1/n2; imprima("O quociente é ",quociente); } } } EXERCÍCIO 32: //Escrever um algoritmo que lê 10 valores e conte quantos destes valores são //negativos, escrevendo esta informação. principal { // Declaração de Variáveis // numero: numero digitado, que é real // i: variável que será usado no para-faça como variável de controle // cont: contador de números negativos. Começa com 0, pois não // existe nenhum negativo inicialmente real numero; inteiro i, cont; cont ← 0; para(i ← 1;i < 10; i ← i + 1) faça // i começa com 1 e vai até 10 aumentando de 1 em 1 // Ou seja, iremos realizar os comandos abaixo 10X, para 10 números { //Leitura do numero (ocorrerá 10X) imprima(“Digite o ", i, “º numero: ”); leia(numero); se (numero < 0)entao cont ← cont + 1; //se o numero lido for negativo, cont recebe +1 // aqui o i recebe +1. Se ele continuar < 10, repete mais uma vez. // Se não, sai do para-faça } //ao chegar aqui, cont terá recebido a quantidade de negativos entre os 10 numeros //Impressão da quantidade imprima("A quantidade de numeros negativos são ",cont); } EXERCÍCIO 33: //Escreva um algoritmo que leia 20 valores e encontre o maior e o menor //deles. Mostre o resultado. principal { //Declaração das Variáveis //maior: armazenará o maior valor //menor: armazenará o menor valor //cont: contador que limitará o programa (vale 1 a 20) //valor: valor lido inteiro maior, menor, valor, cont; cont 1; //Leitura do 1º Valor imprima("Digite o valor 1: "); leia(valor); //armazena na variável valor maiorvalor; //inicializa maior com o primeiro valor digitado menorvalor; //inicializa menor com o primeiro valor digitado //Perceba que o 1º valor digitado é o maior e o menor até agora contcont + 1; //incrementa contador. faça //faça uma vez primeiro... { //Leitura dos novos valores imprima("Digite o valor",cont); leia(valor); //Vamos comparar com a variável maior //que armazena o maior valor até aqui se(valor > maior)entao //se o valor é maior que o maior valor, então maiorvalor; //a variável maior armazena o novo valor se(valor < menor) entao//de forma análoga para o menor menorvalor; contcont + 1;//Vamos ler o próximo numero //... e continuaremos repetindo tudo até que cont ultrapasse 20 }enquanto(cont ≤ 20); //Poderíamos ter usado somente enquanto aqui. //Seria enquanto(cont ≤ 20){...} imprima("Maior: ",maior, "Menor: ", menor); //impressão dos valores finais } EXERCÍCIO 34: //Faça um algoritmo que lê um valor N inteiro e positivo e que calcula e //escreve o fatorial de N (N!). //Lembre-se: Não existe fatorial de número negativo e o exercício não permite de zero principal { // Declaração de Variáveis // N foi iniciado com 0 para que entre no 1º enquanto // res é o resultado. Ele receberá ele mesmo multiplicado pela próxima // parcela do fatorial. Para não modificar o produto final, ele // deve ser neutro. Logo, começa com 1 que é o fator neutro da // multiplicação. inteiro N, res; N ← 0; res ← 1; //Comando Enquanto: //enquanto N≤0, vai ficar solicitando um numero positivo //irá fazer a verificação se este N é > 0. Aí vai parar. enquanto(N≤0) { imprima("Informe N: "); leia(N); } //Imprimir a mensagem abaixo imprima("O fatorial de ",N, " é: "); //Código (explicação no final): enquanto(N≥1) { res ← res * N; se(N≠1)entao imprima(N); senão imprima( N); N ← N - 1; } imprima(res); } // Código: // 1) Vamos imprimir cada componente do fatorial e um sinal // 2) o fatorial será calculado pegando N * (N-1) * (N-2) * ... * 1 = res EXERCÍCIO 35: /*A prefeitura de uma cidade fez uma pesquisa entre seus habitantes, coletando dados sobre o salário e número de filhos. A prefeitura deseja saber: a) média do salário da população; b) média do número de filhos; c) maior salário; d) percentual de pessoas com salário até R$100,00; O final da leitura de dados se dará com a entrada de um salário negativo.*/ principal { /*Declaração de Variáveis: filhos: quantidade de filhos salario: recebe o salario informado pelo usuario contp: contador de população -> cada novo salario é mais um na população mediaF: média de filhos. Primeiramente somaremos todos os filhos aqui. Depois, dividiremos este valor pela população (contp) armazenando nesta mesma variável mediaF mediaS: média de salário. Análogo à mediaF. maior: maior salário. Inicialmente será 0. Não existe salário negativo, logo o menor possível é zero. perc: percentual de pessoas com salario < 100. Será uma espécie de contador primeiramente. Depois usaremos regra de três. Assim, perc=(perc*100)/contp*/ inteiro filhos, contp; real salario, mediaF, mediaS, maior, perc; contp0; mediaF0; mediaS0; maior0; perc0; //Leitura do 1º salário imprima("Informe o salário: "); leia(salario); enquanto (salario > 0)faça { contp ← contp + 1; mediaS ← mediaS + salario; //se o salario é maior que o maior anteriormente registrado, maior recebe ele se (salario > maior) entao { maior ← salario; } //Ver se enquadra na parte menor de 100 se(salário < 100)entao { perc ← perc + 1; } //Leitura do numero de filhos imprima("Numero de Filhos: "); leia(filhos); //somaremos os filhos aqui (mediaF = mediaF + filhos) mediaF ← mediaF + filhos; //Leitura do 1º salário imprima("Informe o salário: "); leia(salario); } //aqui já temos todos os salários registrados //Cálculo da média do salário da população mediaS ← mediaS/contp; //Cálculo da média do número de filhos mediaF ← mediaF/contp; //percentual de pessoas com salário até R$100,00 perc ← (perc*100)/contp; //Impresssão de Informações //contp pode ser 0 se o 1º salario for negativo. Logo não tem que informar nada se (contp ≠ 0)entao { imprima("Média de Salário: ",mediaS); imprima("Média de Filhos: ",mediaF); imprima("Maior salário: ",maior); imprima("Percentual de pessoas com salário até 100: ", perc); } } EXERCÍCIO 36: //Chico tem 1,50 metro e cresce 2 centímetros por ano, enquanto Zé tem 1,30 //metro e cresce 3 centímetros por ano. Construa um algoritmo que calcule e //imprima quantos anos serão necessários para que Zé seja maior que Chico. principal { //declaração de variáveis inteiro anos←0; //quantidade de anos que se passam até zé ficar maior real chico←1.5,ze ←1.3; //altura de cada um enquanto(chico >=ze) //enquanto chico maior que ze, ambos aumentam e passa 1 ano por loop { chico←chico+0.02; //chico cresce 0.02 zé ← zé + 0.03; //ze cresce 0.03 -> Repare que ze+=0.03; é a mesma coisa que ze=ze+0.03; anos ← anos + 1;//passou 1 ano } // só saiu do enquanto quando ze ficou maior. anos irá valer a quantidade de anos necessários para isso imprima("Anos:",anos); //imprime-se a quantidade de anos } EXERCÍCIO 37: //Construir um algoritmo que calcule a média aritmética de vários valores //inteiros positivos, lidos externamente. O final da leitura acontecerá quando //for lido um valor negativo. principal { //declaração de variáveis //NUM: numero digitado //CONT: quantos numeros foram (inicialmente é zero) //SOMA: a soma de todos (inicialmente é zero) inteiro NUM, CONT,SOMA; real MEDIA; CONT <- 0; SOMA <- 0; //Iremos ler o 1º numero e ficar repetindo enquanto NUM>= 0 //(quando NUM<0, interrompe) faça{ imprima("Informe um numero inteiro e positivo: "); leia(NUM); //leitura de NUM se(NUM > = 0){ SOMA <- SOMA + NUM; CONT<-CONT +1; } //iremos ficar repetindo até que NUM torne-se negativo }enquanto (NUM >= 0); //Agora, n foi negativo. //Já somamos todos os anteriores e contamos quantos foram se(CONT > 0) //se cont for igual a 0, quer dizer que não houve numero nenhum. //O negativo foi o 1º { MEDIA<- SOMA/CONT; imprima("A media aritmética é:”,MEDIA); } } EXERCÍCIO 38: //- 1,2,3,4 = voto para os respectivos candidatos; //- 5 = voto nulo; //- 6 = voto em branco; //Leia o código, calcule e escreva as seguintes informações: //- total de votos para cada candidato; //- total de votos nulos; //- total de votos em branco; //Como finalizador do conjunto de votos, utilize o valor 0. principal { //Declaraçãode Variáveis // CODIGO: código de votação // C1,C2,C3,C4,NULO,BRANCO: contadores para os candidatos 1,2,3 e 4 e para nulo e branco inteiro CODIGO,C1,C2,C3,C4,NULO,BRANCO; C1 <- 0; C2 <- 0; C3 <- 0; C4 <- 0; NULO <- 0; BRANCO <- 0; //Leitura do código imprima ("Informe o código: "); leia (CODIGO); //se CODIGO é diferente de zero, faça: enquanto (CODIGO != 0)faça { escolha (CODIGO) //múltipla escolha { caso 1: C1 <- C1 + 1; //+1 voto para o 1 caso 2: C2 <- C2 + 1; //+1 voto para o 2 caso 3: C3 <- C3 + 1; //+1 voto para o 3 caso 4: C4 <- C4 + 1; //+1 voto para o 4 caso 5: NULO <- NULO + 1; //+1 voto nulo caso 6: BRANCO <- BRANCO + 1; //+1 voto branco senão: imprima (" Código Inválido "); //códigos negativos e maiores que 6 } //Leitura do código imprima ("Informe o código: "); leia (CODIGO); } //impressão imprima ("Total de votos para o candidato 1: ",C1); imprima ("Total de votos para o candidato 2: ",C2); imprima ("Total de votos para o candidato 3: ",C3); imprima ("Total de votos para o candidato 4: ",C4); imprima ("Total de votos nulos: ",NULO); imprima ("Total de votos brancos: ",BRANCO); } EXERCÍCIO 39: //Escrever um algoritmo que leia uma variável n e calcule a tabuada de 1 até n. //Mostre a tabuada na forma: //1 x n = n //2 x n = 2n //3 x n = 3n //............... //n x n = n2 principal { //declaração de variáveis (N é o número e I é usado no para...faça) inteiro N, I; //leitura do n imprima("Informe n"); leia(N); // PARA..FAÇA: iremos imprimir n linhas. // Repare que o 1º número começa em 1 e vai até n (1<=i<=n) // Então usaremos I pra "correr" de 1 a N // O 2º número é sempre o N // O 3º número é I*N (multiplicação) // IMPRIMA: 3 números inteiros impressos: I, N e o resultado I*N para(I = 1; I < N; I ++) faça imprima( i, "X", n, "=", i*n); } EXERCÍCIO 40: // Lê os valores n1 e n2 e imprime o intervalo fechado entre esses dois valores. */ principal { //declaração de variaveis inteiro n1, n2, aux; //leitura dos inteiros imprima("Digite dois valores inteiros"); leia (n1,n2); //compara n1 e n2 e atribui o menor valor à variavel n1 se (n1>n2)entao { aux←n2; n2←n1; n1←aux; } imprima ("Intervalo fechado entre", n1, n2); // A cada loop o valor de n1 aumenta uma unidade e é impresso. //Quando n1 for maior que n2 sai do loop e realiza o proximo comando enquanto (n1<=n2) { imprima (n1); n1++; //n1=n1+1; } } EXERCÍCIO 41: //Escrever um algoritmo que leia um número n que indica quantos valores //devem ser lidos a seguir. Para cada número lido, mostre uma tabela //(1 linha e duas colunas) contendo o valor lido e o fatorial deste valor. //(Ver questão 34) principal { // Declaração de Variáveis // n: quantidade de valores a calcular o fatorial // numero: numero a ser fatorado // result: é o resultado. Ele receberá ele mesmo multiplicado pela próxima parcela do fatorial. Para não modificar o produto final, ele deve ser neutro. Logo, começa com 1 que é o fator neutro da multiplicação. result será modificado constantemente para cada numero // fator: é a parcela que irei multiplicar com o resultado anterior até que o // fatorial esteja calculado. Começará com 1 e irá até numero // repetir: número de repetições do cálculo do fatorial. Começa com 1 e vai até n inteiro n, result, fator, numero, repetir; repetir 1; //Leitura da qtd de valores imprima ("Quantidade de Valores: "); leia (n); faça { //faça uma vez... //"resetando" o resultado e a fator para cada numero Result ← 0; //Leia o numero a ser fatorado imprima ("Valor: "); leia (numero); se (numero = 0 ou numero = 1) //fatoriais de 0 e 1 é 1 { Result ← 1; //resultado direto } senão //caso seja 2 pra frente... { enquanto (fator < numero) faça { //...result ← result * fator até fator igual numero result ← result * fator; fator ← fator + 1; } } imprima (“Numero: ”, numero ,“Fatorial: ”,fator); repetir ← repetir + 1; }enquanto (repetir < n); //chegando aqui, todos os n valores tiveram seu fatorial calculado e impresso } EXERCÍCIO 42: //Escrever um algoritmo que leia um número não determinado de valores e //calcule a média aritmética dos valores lidos, a quantidade de valores //positivos, a quantidade de valores negativos e o percentual de valores //negativos e positivos. Mostre os resultados. //ATENÇÃO: o enunciado não deixa claro mas será usado o valor 0 para //simbolizar o fim da entrada de dados principal { // Declaração de Variáveis // NUM: numero inteiro lido // CONT: quantidade total de números lidos (inteiro) // MEDIA: no 1º momento, será a soma de todos os números // no 2º momento, MEDIA <- MEDIA div CONT. // Assim, media será a média aritmética dos números (soma/qtd) // C1 e C2: no 1º momento, eles se comportarão como inteiros. // Eles serão os contadores de números positivos e // negativos respectivamente. // no 2º momento, C1 <- (C1*100) div CONT, ou seja, // C1 será o PERCENTUAL de valores positivos em (CONT) // números lidos. Aqui ele será real. Por isso, foi declarado como real inteiro NUM,CONT; real MEDIA,C1,C2; CONT <- 0; MEDIA <- 0; C1 <- 0; C2 <- 0; imprima ("Digite um numero: "); leia (NUM); enquanto (NUM !=0) faça { MEDIA <- MEDIA + NUM; CONT <- CONT + 1; se (NUM>0) { C1 <- C1 + 1; } senão C2 <- C2 + 1; imprima ("Digite um numero: "); leia (NUM); } //Cálculo media MEDIA <- MEDIA div CONT; //impressão imprima ("Média Aritmética: ",MEDIA); imprima ("Quantidade de Valores Positivos: ",C1); imprima ("Quantidade de Valores Negativos: ",C2); C1 <- (C1*100) div CONT; C2 <- (C2*100) div CONT; imprima ("Percentual de Valores Positivos: ",C1); imprima ("Percentual de Valores Negativos: ",C2); } EXERCÍCIO 43: /*Escrever um algoritmo que leia uma quantidade desconhecida de números e conte quantos deles estão nos seguintes intervalos: [0,25], [26,50], [51,75] e [76,100] . A entrada de dados deve terminar quando forlido um número negativo.*/ principal { //Declaração de Variáveis // numero: numero lido // c1,c2,c3,c4: contadores de cada intervalo inteiro numero, c1, c2, c3, c4; numero ← 1; c1← 0; c2← 0; c3← 0; c4← 0; enquanto (numero > 0) faça{ //... enquanto numero > 0 //Leia o numero imprima("Numero: "); leia(numero); se (numero > 0 E numero < 25)entao { c1 ← c1 + 1; }//intervalo 1 senao { se (numero > 26 E numero < 50) entao { c2 ← c2 + 1; //intervalo 2 } senão { se (numero > 51 E numero < 75) entao { c3 ← c3 + 1; //intervalo 3 } senão { se (numero > 76 E numero < 100) entao { c4 ← c4 + 1; //intervalo 4 } } } } } //Impressão dos resultados imprima("No intervalo [0,25] tem “, c1, “ numeros lidos"); imprima("No intervalo [26,50] tem “, c2, “ numeros lidos"); imprima("No intervalo [51,75] tem “, c3, “ numeros lidos"); imprima("No intervalo [76,100] tem “, c4, “ numeros lidos"); } EXERCÍCIO 44: /*Faça um algoritmo que leia uma quantidade não determinada de números positivos. Calcule a quantidade de números pares e ímpares, a média de valores pares e a média geral dos números lidos. O número que encerrará a leitura será zero.*/ principal { //Declaração de variáveis // n: numero // contp: contador de pares // conti: contador de ímpares // somap: soma dos pares // somat: soma total //As médias serão a soma dividido pelos contadores, que podem ser real // mediap: média dos pares // mediat: média total (Observe que a quantidade total é contp + conti) inteiro n, contp, conti, somap, somat; real mediap, mediat; contp←0; conti←0; somap←0; somat←0; imprima ("Informe n positivo: "); leia (n); //leitura do 1º n enquanto (n>0) faça //Se n for positivo realiza-se as contas { somat←somat + n; //some o n na soma total se (n mod 2 = 0)entao //se n for par { contp←contp + 1; //iremos acrescentar +1 no contador de pares somap←somap+n; //iremos somar o n par ao somap } senão conti←conti + 1; //se n for ímpar, somente some +1 no conti imprima ("Informe n positivo: "); leia (n); //leitura do 1º n } //Cálculo médias Mediap somap / contp; mediat somat / (contp + conti); //Impressão imprima ("Quantidade de Pares: ",contp); imprima ("Quantidade de Ímpares: ",conti); imprima ("Média dos Pares: ",mediap); imprima ("Média Total: ",mediat); } EXERCÍCIO 45: //Uma empresa deseja aumentar seus preços em 20%. Faça um algoritmo que //leia o código e o preço de custo de cada produto e calcule o preço novo. //Calcule também, a média dos preços com e sem aumento. Mostre o código e //o preço novo de cada produto e, no final, as médias. A entrada de dados //deve terminar quando for lido um código de produto negativo. principal { // Declaração de Variáveis inteiras inteiro CODIGO, CONT ← 0; // Declaração das Variáveis reais real PREÇO, MEDIA1 ← 0, MEDIA2 ← 0; imprima(“Código: ”); leia(CODIGO); enquanto(CODIGO > 0)faça //Códigos negativos são inválidos { CONT ← CONT + 1; //Temos mais um produto //Leitura do preço atual imprima(“Preço Atual: ”); leia(PREÇO); //soma dos preços SEM aumento MEDIA1 ← MEDIA1 + PREÇO; //calcula o novo preço, com aumento PREÇO ← 1,2 * PREÇO; //Leitura do código // soma dos preços, agora COM aumento MEDIA2 ← MEDIA2 + PREÇO; //imprime código e novo preço imprima(“Código: Preço Novo:”, CODIGO, PREÇO); imprima(“Código: ”); leia(CODIGO); } se(CONT ≠ 0)entao //evitaremos o 0/0 { //cálculo da média dos preços antigos MEDIA1 ← MEDIA1 / CONT; //cálculo dos preços novos MEDIA2 ← MEDIA2 / CONT; //imprime média antiga imprima(“Média dos preços antigos: ”, MEDIA1); //imprime média nova imprima(“Média dos preços novos: ”, MEDIA2); } } EXERCÍCIO 46: //Escreva um algoritmo que gere o números de 1000 a 1999 e escreva aqueles //que dividido por 11 dão resto igual a 5. principal { //Declaração da variável (N será o número que vai de 1000 a 1999) inteiro N; para(N ← 1000; N < 1999; N ← N + 1)faça //1000 < N < 1999 e N vai aumentando de 1 a cada loop { se(N mod 11 = 5)entao //Lembre-se que em pseudolinguagem o resto da divisão é “mod”. //Se o resto for 5, entra no loop (em C, resto da divisão é “%”) //Iremos imprimir o número N específico onde “N mod 11 = 5” imprima(N); } } EXERCÍCIO 47: //Escreva um algoritmo que lê um valor n inteiro e positivo e que calcula a //seguinte soma: //S := 1 + 1/2 + 1/3 + 1/4 + ... + 1/n //O algoritmo deve escrever cada termo gerado e o valor final de S. principal { // Declaração de Variáveis // N: número positivo // I: denominador que varia de 2 a N // S: soma das frações. Será um float. Começa com 1.0, pois não pode // ser 1 ou um numero maior que 1. Em todos, S irá valer pelo menos 1 inteiro N, I; real S; S ← 1.0; // Leitura do numero N, que deve ser positivo. //Se N for menor ou igual a 0, continua-se pedindo faça { imprima ("Informe N positivo: "); leia (N); }enquanto (N ≤ 0); // 1º CASO: n=1 // Irei imprimir: // “S = 1 (cada termo gerado) // S = 1” (valor final de S) se (N = 1)entao { imprima ("S=1", “S=1”); } //2º CASO: explicação no final senão { imprima ("S = 1 + "); para (I ← 2; I ≤ N; I ← I + 1) faça { S ←S + 1 / I; se (I ≠ N)entao { imprima ("1/ ",I ,“+”); } senão { imprima("1/ ", I); } imprima (S); } } } // 2º CASO: n é diferente de 1 // Primeiro imprime o 1º termo gerado S = 1 + // A partir daqui, o denominador i varia de 2 até o numero N // S será o somatório dos termos 1/i, sendo que seu valor inicial é 1 // Se o I for diferente de N (não é o último termo), imprime 1/i e o sinal + // Caso contrário (i=n, ou seja, é o último termo), só coloca 1/i // Depois de tudo isso, os termos já foram impressos // Agora imprime o valor final de S. EXERCÍCIO 48: //Escrever um algoritmo que lê 10 valores, um de cada vez, e conte quantos //deles estão no intervalo [10,20] e quantos deles estão fora do intervalo, //escrevendo estas informações. principal { //Declaração de Variáveis //numero: numero lido //i: variável de controle do comando de repetição para...faça //cont1: contador de quantos numeros estão no intervalo [10,20] //cont2: contados de quantos estão fora inteiro numero, i, cont1,cont2; cont10; cont20; //Código que repetirá os comandos 10x para (i 1; i < 10 ; i i + 1) faça //i valerá de 1 a 10 { //Leitura do numero imprima ("Numero: "); leia (numero); //Teste do intervalo se (numero > 10 E numero < 20)entao cont1cont1 + 1; //se está no intervalo, cont1 recebe +1 senão cont2cont2 +1; //senão cont2 recebe +1 } //Impressão do resultado imprima (cont1,“ numeros estão no intervalo [10,20]”); imprima (cont2,“ numeros estão fora do intervalo [10,20]”); } EXERCÍCIO 49: //Escrever um algoritmo que gere e escreva os 5 primeiros números perfeitos. //Um número perfeito é aquele que é igual a soma dos seus divisores EXCLUINDO //ELE MESMO. (Ex.: 6 = 1+2+3; 28= 1+2+4+7+14 etc). principal { // Decalaração de Variáveis // numero: será os números de 1 a infinito // iremos testar cada numero até achar os 5 primeiros perfeitos // cont: contador de quantos números perfeitos foram encontrados // i: valor de controle do for // será utilizado para se determinar os divisores do numero // irá valer de 1 até o numero-1, já que o próprio número é desconsiderado // soma: somatório dos divisores // como i irá se alterar constantemente, precisamos somar os divisores // encontrados. No final, se esse somatório for igual ao numero, // temos nosso numero perfeito inteiro numero,cont,soma,i;numero←1; cont←0; faça { soma←0; //resetei a soma para cada numero a ser experimentado //i irá correr todos os prováveis divisores de numero exceto ele mesmo para(i←1;i<numero;i ← i + 1)faça //não precisa de { }, pois há só um comando, o se //se o numero for divisível por i, achamos um divisor se(numero mod i=0) entao soma+=i; //soma dos divisores recebe o divisor i //aqui a soma de todos os divisores já foi feita se (soma=numero) entao //se a soma for igual ao numero, achamos um perfeito { imprima(numero); //impressão do perfeito cont ← cont + 1; //achamos um perfeito } numero ← numero + 1; //Vamos verificar o próximo número }enquanto(cont<4); //até que cont torne-se 4 } //ATENÇÃO: // O exercício pediu os 5 primeiros. O correto seria enquanto(cont<5)faça // No entanto, os números perfeitos são: // {6,28,496,8.128,33.550.336} // O 5º número é enorme e o computador demora tempo demais para processar // Por comodidade, acharemos os 4 primeiros EXERCÍCIO 50: // Escrever um algoritmo que leia um valor N inteiro e positivo e que calcula o // valor de E. Imprime o resultado de E ao final. // E = 1 + 1 / 1! + 1 / 2! + 1 / 3! + 1 / N! principal { // declaração de variáveis // N: numero // CONT: será o numero cujo fatorial é o denominador, varia de 1 a N // AUX: é o resultado de cada fatorial // E: é a soma acima, começando com 1 inteiro N,CONT, AUX; real E; CONT ← 1; AUX ← 1; E ← 1; //leitura do numero até ser maior do que 0 faça { imprima ("Informe N positivo: "); leia (N); }enquanto (N ≤ 0); //explicação no final enquanto (CONT ≤ N) faça { AUX ←AUX * CONT ; E ←E +1.0/AUX; CONT ←CONT + 1; } //imprimindo o valor de E imprima (E); } // O cont vai variar de 1 a N. // aux é o valor do fatorial de cont, ou seja, aux = cont ! // Suponhamos que o N tenha sido 3. // 1º loop) cont vale 1 // aux deve ser 1! -> aux ←aux * cont, ou seja, aux ←1 * 1 = 1 = 1! // E vai somar-se à divisão de 1/1 // cont←cont + 1 faz cont virar 2 // 2º loop) cont vale 2 // aux deve ser 2! -> aux ←aux * cont, ou seja, aux ← 1 * 2 = 2 = 2! // E vai somar-se à divisão float 1/2 // cont←cont + 1 -> cont = 3 // 3º loop) cont vale 3 = N -> último loop // aux deve ser 3! -> aux←aux * cont, ou seja, aux ←2 * 3 = 6 = 3! // E vai somar-se à divisão 1/6 // cont←cont + 1 ->cont = 4, saindo do while
Compartilhar