Lista 3 de exercício de repetição em C e Portugol

Prévia do material em texto

Questões erradas: 3,7,20,28
1) Escreva um programa que imprima as vinte primeiras potências de dois.
Linguagem C:
#include<stdio.h>
#include<math.h>
int main (void)
{float numero,i;
for (i=0;i<=19;i++){
numero = pow(2,i);
printf("Potencia de 2...:\t%.0f\n",numero);
}
return 0;
}
Português Estruturado (Portugol):
Algoritmo
Declare numero, i NUMÉRICO
PARA i ← 0 ATÉ 19 faça [passo 1]
INÍCIO
numero = 2i
Escreva "Potência de 2= ",x
Fim
Fim_algoritmo.
2) Escreva um programa que leia “n” números inteiros do teclado e imprima o
produto deles. O programa deverá ficar em um laço até o usuário indicar que não
deseja mais fornecer nenhum novo número.
Linguagem C:
#include<stdio.h>
int main (void)
{
int numero = 1, produto = 1;
while(numero!=0)
{
produto=produto*numero;
printf("Digite um numero inteiro (zero para finalizar).");
scanf("%d",&numero);
}
printf("Valor do produto:%d", produto);
return 0;
}
Português Estruturado (Portugol):
ALGORITMO
DECLARE numero , produto NUMÉRICO
numero ← 1
produto ← 1
ENQUANTO numero ≠ 0 FAÇA
INÍCIO
produto ← produto * numero
ESCREVA "Digite um numero inteiro (zero para finalizar)."
LEIA numero
FIM
ESCREVA "Valor do produto:" , produto
FIM_ALGORITMO
3) Faça um programa para calcular a média dos “n” números inteiros positivos, onde
“n”é um número lido do teclado (a priori).
Linguagem C:
#include<stdio.h>
int main(void)
{
int numero, soma=0,n,i;
float media;
printf("Digite a quantidade de numeros ");
scanf("%d",&n);
for (i=1;i<=n;i++)
{
printf("Digite o numero:");
scanf("%d",&numero);
soma=soma+numero;
}
media=soma/n;
printf("Valor da media:%f ", media);
return 0;
}
Português Estruturado (Portugol):
ALGORITMO
DECLARE numero, soma, n, i, media NUMÉRICO
soma ← 0
ESCREVA "Digite a quantidade de numeros "
LEIA n
PARA i ← 1 ATÉ n FAÇA [passo 1]
INÍCIO
ESCREVA "Digite o numero:"
LEIA numero
soma ← soma+numero
FIM
media ← soma / n
ESCREVA "Valor da media: ", media
FIM_ALGORITMO
4) Escreva um programa que imprima as “n” primeiras potências de dois. Onde “n” é
um número lido do teclado (a priori).
Linguagem C:
#include<stdio.h>
#include<math.h>
int main (void)
{
int contador,n;
float potencia;
contador =0;
printf("Digite a quantidade: ");
scanf("%d",&n);
while (contador <n)
{
potencia=pow(2,contador);
printf("\n Potencia de 2: %.0f", potencia);
contador++;
}
return 0 ;
}
Português Estruturado (Portugol):
AlGORITMO
DEClARE contador,n,potencia NUMÉRICO
contador<-- 0
ESCREVA "Digite a quantidade"
LEIA n
ENQUANTO contador<n Faça
INÍCIO
potencia← 2 contador
ESCREVA "Potencia de 2:" , potencia
contador ← contador+1
FIM
FIM_ALGORITMO
5) Elabore um programa que leia “n” números do teclado e imprima o maior deles. O
programa deverá ficar em um laço até o usuário indicar que não deseja mais fornecer
nenhum novo número.
Linguagem C:
#include<stdio.h>
int main(void)
{
float maior, num=1;
printf("Digite um numero (-1 para finalizar) : ");
scanf("%f",&num);
maior=num;
while(num!=-1)
{
printf("Digite um numero (-1 para finalizar) : ");
scanf("%f",&num);
if(num>maior)
{
maior=num;
}
}
printf("O maior numero e...: %f",maior);
return 0;
}
Português Estruturado (Portugol):
ALGORITMO
DECLARE maior,num NUMÉRICO
num ← 1
ESCREVA "Digite um numero"
LEIA num
maior← num
ENQUANTO num ≠ -1 FAÇA
INÍCIO
ESCREVA "Digite um numero(-1 para finalizar):"
LEIA num
SE num>maior
ENTÃO INÍCIO
maior← num
FIM
FIM
ESCREVA "O maior numero e:",maior
FIM_ALGORITMO
6) Escreva um programa para calcular o fatorial do número N, cujo valor é obtido
através do usuário pelo teclado.
Linguagem C:
#include<stdio.h>
int main (void)
{
int n,a;
a=1;
printf("escolha um numero para receber fatorial \n");
scanf("%d",&n);
while(n!=1)
{
a=a*n;
n--;
}
printf("Seu fatorial e: %d", a);
return 0;
}
Português Estruturado (Portugol):
ALGORITMO
DECLARE n , a NUMÉRICO
a← 1
ESCREVA "Escolha um numero para receber fatorial"
LEIA n
ENQUANTO n ≠ 1 FAÇA
INÍCIO
a← a*n
n← n -1
FIM
ESCREVA "Seu fatorial: ", a
FIM_ALGORITMO
7) O antigo filósofo grego Zeno é, talvez, melhor conhecido pelo paradoxo de Aquiles
e a tartaruga. Aquiles e a tartaruga disputam uma corrida. Aquiles corre dez vezes
mais rápido do que a tartaruga, porém a tartaruga tem 100 metros de vantagem.
Pode-se argumentar que Aquiles nunca ultrapassará a tartaruga, pois, quando ele
atingir o ponto onde a tartaruga estava, ela já estará um pouco à frente. Implementar
um programa para calcular o tempo no qual Aquiles ultrapassará a tartaruga.
Linguagem C:
#include<stdio.h>
int main(void)
{
float v,s,s1,t=0,sa,sb;
printf("Digite a velocidade da tartaruga.");
scanf("%f",&v);
printf("Digite a posicao inicial de aquiles.");
scanf("%f",&s1);
while(sa<=sb)
{
sa=s1+10*v*t;
sb=s1+100+v*t;
t++;
}
printf("\nEspaco Tartaruga:%f\nEspaco Aquiles:%f",sb,sa);
printf("\nTempo:%f",t);
return 0;
}
Português Estruturado (Portugol):
ALGORITMO
DECLARE v,s,s1,t,sa,sb; NUMÉRICO
t ← 0
ESCREVA "Digite a velocidade da tartaruga."
LEIA v
ESCREVA "Digite a posicao inicial de aquiles."
LEIA s1
ENQUANTO sa <= sb FAÇA
INÍCIO
sa← s1+10*v*t
sb← s1+100+v*t
t← t + 1
FIM
ESCREVA "Tempo:" , t
ALGORITMO
8) Um aluno está preocupado em relação a seu desempenho na disciplina de FUP. Em
seu primeiro programa ele cometeu um erro; em seu segundo, dois erros; no terceiro,
quatro erros; assim por diante. Ele está cometendo, por programa, duas vezes o
número de erros que cometeu no programa anterior. A disciplina dura treze semanas,
com dois problemas por semana. Preparar um algoritmo para calcular o número de
erros que este aluno espera cometer em seu programa final.
Linguagem C:
#include<stdio.h>
int main (void)
{
int a=2, b=13,c, i,erro=1;
c=b*a;
for(i=2;i<=c;i++)
{
erro=2*erro;
}
printf("Total de erros: %d", erro);
return 0;
}
Português Estruturado (Portugol):
ALGORITMO
DECLARE a,b,c,i,erro NUMÉRICO
a← 2
b← 13
erro← 1
c← a*b
PARA i← 2 ATÉ c FAÇA [passo 1]
INÍCIO
erro ← 2*erro
FIM
ESCREVA "Total de erros:" , erro
FIM_ALGORIMO
9) Faça um programa para calcular as duas maiores notas e a média das notas na
primeira avaliação parcial de FUP. O número de alunos e as notas devem ser lidos do
teclado.
Linguagem C:
#include<stdio.h>
int main(void)
{
float i,nota,maior,segunda,aluno,soma=0,media;
printf("Digite o numero de alunos ");
scanf("%f",&aluno);
printf("Digite a primeira nota: ");
scanf("%f",&nota);
maior = nota ;
soma=soma+maior;
for(i=1;i<aluno;i++)
{
scanf("%f",&nota);
soma=soma+nota;
if( nota> maior)
{
segunda = maior;
maior = nota;
}
else
{
if ((nota > segunda) || (i==1))
segunda = nota;
}
}
media=soma/aluno;
printf("As maiores notas sao: %f,%f\n",maior,segunda);
printf("Media das notas: %f",media);
return 0;
}
Português Estruturado (Portugol):
ALGORITMO
DECLARE i,nota,maior, segunda, aluno, soma ,media NUMÉRICO
soma← 0
ESCREVA "Digite o numero de alunos"
LEIA aluno
ESCREVA "Digite a primeira nota: "
LEIA nota
maior ← nota
soma← soma+maior
PARA i← 1 ATÉ aluno -1 FAÇA [PASSO 1]
INÍCIO
LEIA nota
soma← soma+nota
SE nota > maior
ENTÃO INICIO
segunda ← maior
maior ← nota
FIM
SENÃO INÍCIO
SE nota > segunda OU i=1
ENTÃO INÍCIO
segunda <-- nota;
FIM
FIM
FIM
media<-- soma/aluno
ESCREVA "As maiores notas sao:", maior,segunda
ESCREVA "Media das notas: ", media
FIM_ALGORITMO
10) Elabore um programa para automatizar as eleições do Centro Acadêmico do
curso de Ciência da Computação. Três alunos estão concorrendo nas eleições: Zé,
Gal e Gil. O programa deve contabilizar os votos da seguinte forma: o usuário deverá
digitar 1 para votar no Zé, 2 para votar na Gal e 3 para votar na Gil. A eleição deve ser
finalizada e o vencedor indicado quando o usuário digitar 0 (Zero).
Linguagem C:
#include<stdio.h>
int main (void)
{
int ze=0,gil=0,gal=0,a=-1;
printf("Digite 1.Ze 2.GIl 3. Gal.\n");
while(a!=0)
{
printf("Digite seu voto. (0 para finalizar)");
scanf("%d",&a);
switch (a)
{
case 1: ze=ze+1;
break;
case 2: gil=gil+1;
break;
case 3: gal=gal+1;
break;
}
}
if(ze>gal && ze>gil) printf("ZE vencedor:%d",ze);
else
{
if(gil>ze && gil>gal) printf("GILvencedor:%d",gil);
else
{
if(gal>ze && gal>gil) printf("GAL vencedor:%d",gal);
else printf("Houve empate.");
}
}
return 0;
}
Português Estruturado (Portugol):
ALGORITMO
DECLARE ze,gil,gal,a NUMÉRICO
ze← 0
gil← 0
a← -1
ESCREVA "Digite 1.Ze 2.GIl 3. Gal.\n"
ENQUANTO a ≠ 0 FAÇA
INÍCIO
ESCREVA "Digite seu voto. (0 para finalizar)"
LEIA a
SE a = 1
ENTÃO INÍCIO
ze← ze+1
FIM
SE a = 2
ENTÃO INÍCIO
gil← gil+1
FIM
SE a = 3
ENTÃO INÍCIO
gal<--gal+1
FIM
FIM
SE ze>gal e ze>gil
ENTÃO INÍCIO
ESCREVA "ZE vencedor: " , ze
FIM
SENÃO INÍCIO
SE gil>ze e gil>gal
ENTÃO INÍCIO
ESCREVA "GIL vencedor: ", gil
FIM
SENÃO INÍCIO
SE gal>ze e gal>gil
ENTÃO INÍCIO
ESCREVA "GAL vencedor:", gal
FIM
SENÃO INÍCIO
ESCREVA "Houve empate."
FIM
FIM
FIM
FIM_ALGORITMO
11) Criar um programa que leia os limites inferior e superior de um intervalo e
imprima todos os números pares no intervalo aberto e seu somatório. Suponha que
os dados digitados são para um intervalo crescente, ou seja, o primeiro valor é menor
que o segundo.
Linguagem C:
#include<stdio.h>
int main (void)
{
int n1,n2,par=0,soma=0,i;
printf("Digite o intervalo de numeros ( n1 < n2 )");
scanf("%d,%d",&n1,&n2);
for(i=n1+1;i<n2;i++)
{
if(i%2==0 && i!=1)
{
par++;
printf("Numero par:%d\n",i);
soma=soma+i;
}
}
printf("Valor da soma dos pares no intervalo: %d",soma);
return 0;
}
Português Estruturado (Portugol):
ALGORITMO
DECLARE n1,n2,par,soma,i NUMÉRICO
par← 0
soma← 0
ESCREVA "Digite o intervalo de numeros ( n1 < n2 )"
LEIA n1,n2
PARA i← n1+1 ATÉ n2-1 FAÇA [ passo 1 ]
INÍCIO
SE i mod 2 = 0 e i ≠ 1
ENTÃO INÍCIO
par← par+1;
ESCREVA "Numero par ",i
soma← soma+i
FIM
FIM
ESCREVA "Valor da soma dos pares no intervalo: ",soma
FIM_ALGORITMO
12) Criar um programa que leia um número (NUM) e então imprima os múltiplos de 3 e
5, ao mesmo tempo, no intervalo fechado de 1 a NUM.
Linguagem C:
#include<stdio.h>
int main(void)
{
int numero,i;
printf("Digite o valor de n\n");
scanf("%d",&numero);
for(i=1;i<=numero;i++)
{
if(i%3==0 && i%5==0)
{
printf("Valor multiplo de 5 e 3 ao mesmo tempo.%d\n",i);
}
}
return 0;
}
Português Estruturado (Portugol):
ALGORITMO
DECLARE numero,i NUMÉRICO
ESCREVA "Digite o valor de n"
LEIA numero
PARA i← 1 ATÉ numero FAÇA [PASSO 1]
INÍCIO
SE i mod 3 = 0 e i mod 5 =0
ENTÃO INÍCIO
ESCREVA "Valor multiplo de 5 e 3 ao mesmo tempo",i
FIM
FIM
FIM_ALGORITMO
13) Escreva um programa que leia “n” números inteiros e imprima quantos são pares
e quantos são ímpares. O número “n” deve ser fornecido pelo usuário.
Linguagem C:
#include<stdio.h>
int main ()
{
int n,p,i;
n=1;
p=0;
i=0;
printf("Digite os numeros(para finalizar aperte -1)");
while (n!=-1)
{
scanf ("%d",&n);
if (n%2==0 && n!=1)
{
p++;
}
else {
if (n%2!=0 && n>=1) {i=i+1;}
}
}
printf("Pares:%d\nImpares:%d",p,i);
return 0;
}
Português Estruturado (Portugol):
ALGORITMO
DECLARE n,p,i NUMÉRICO
n← 1
p← 0
i← 0
ESCREVA "Digite os numeros (para finalizar aperte -1)"
ENQUANTO n ≠ -1 FAÇA
INÍCIO
LEIA n
SE n mod 2=0 e n ≠ 1
ENTÃO INÍCIO
p← p+1
FIM
SENÃO INÍCIO
SE n mod 2 ≠ 0 e n >= 1
ENTÃO INÍCIO
i← i+1
FIM
FIM
FIM
ESCREVA "pares e impares: ",p,i
FIM_ALGORITMO
14) Escreva um programa que realize o produto de A (número real) por B (número
inteiro), ou seja, A * B, através de adições (somas). Esses dois valores são passados
pelo usuário através do teclado.
Linguagem C:
#include<stdio.h>
int main (void)
{
float a, resultado;
int b,i;
resultado=0;
printf("Digite um numero real:\n");
scanf("%f",&a);
printf("Digite um numero inteiro:\n");
scanf("%d",&b);
for (i=b;i>0;i--)
{
resultado=resultado+a;
}
printf("%0.2f", resultado);
return 0;
}
Português Estruturado (Portugol):
ALGORITMO
DECLARE a, resultado, b,i NUMÉRICO
resultado ← 0
ESCREVA "Digite um numero real:\n"
LEIA a
ESCREVA "Digite um numero inteiro:"
LEIA b
PARA i ← b ATÉ i>0 FAÇA [passo -1]
INÍCIO
resultado ← resultado+a
FIM
ESCREVA " resultado: ", resultado
FIM_ALGORITMO
15) Escreva um programa que realize a potência de A (número real) por B (número
inteiro e positivo), ou seja, AB , através de multiplicações sucessivas. Esses dois
valores são passados pelo usuário através do teclado.
LINGUAGEM C:
#include<stdio.h>
int main ()
{
int b, stop;
float a,s;
stop= 0;
s=1;
printf("Escreva os numeros A,B:\n");
scanf("%f,%d",&a,&b);
while (stop!=b)
{
stop++;
s=s*a;
printf("valor de s:%.1f valor de stop:%d\n",s,stop);
}
printf("resultado:%.2f", s);
return 0;
}
Português Estruturado (Portugol):
ALGORITMO
DELCARE b, stop, a, s NUMÉRICO
stop← 0
s← 1
ESCREVA "Escreva os numeros A,B:"
LEIA a,b
ENQUANTO stop ≠ b FAÇA
INÍCIO
stop← stop+1
s← s*a
ESCREVA "conta : ", s, stop
FIM
ESCREVA "resultado: ", s
FIM_ALGORITMO
16) Escreva um programa que calcule o resto da divisão de A por B (número inteiros
e positivos), ou seja, A mod B, através de subtrações sucessivas. Esses dois valores
são passados pelo usuário através do teclado.
Linguagem C:
#include<stdio.h>
int main (void)
{
int a,b,mod;
printf("Digite a e b.");
scanf("%d,%d",&a,&b);
mod=a;
while(mod>=b)
{
mod=mod-b;
}
printf("O resto da divisao : %d ", mod);
return 0;
}
Português Estruturado (Portugol):
ALGORITMO
DECLARE a, b, mod NUMÉRICO
ESCREVA "Digite a e b."
LEIA a, b
mod← a
ENQUANTO mod >= b FAÇA
INÍCIO
mod ← mod - b;
FIM
ESCREVA "O resto da divisao: " , mod
FIM_ALGORITMO
17) Escreva um programa que calcule o quociente da divisão de A por B (número
inteiros e positivos), ou seja, A div B, através de subtrações sucessivas. Esses dois
valores são passados pelo usuário através do teclado.
Linguagem C:
#include<stdio.h>
int main (void)
{
int a,b,q=0;
printf("Digite a > b.");
scanf("%d,%d",&a,&b);
while(a>=b)
{
a=a-b;
q++;
}
printf("O resto da divisao: %d\n",a);
printf("valor de q: %d",q);
return 0;
}
Português Estruturado (Portugol):
ALGORITMO
DECLARE a,b,q NUMÉRICO
q← 0
ESCREVA "Digite a e b."
LEIA a, b
ENQUANTO a >= b FAÇA
INÍCIO
a← a-b
q← q+1
FIM
ESCREVA "O resto da diviso: " , a
ESCREVA "valor de q: " , q
FIM_ALGORITMO
18) Escreva um programa que determine se dois valores inteiros e positivos A e B
são primos entre si (dois números inteiros são ditos primos entre si, caso não exista
divisor comum aos dois números).
LINGUAGEM C:
#include<stdio.h>
int main (void)
{
int a,i,b,cont=0;
printf("Digite A:");
scanf("%d",&a);
printf("Digite B:");
scanf("%d",&b);
if(a>b)
{
for(i=1;i<=b;i++)
{
if(a%i==0 && b%i==0) cont++;
}
if(cont==1) printf("Numeros primos entre si.");
else printf("Numeros nao sao primos entre si");
}
if(a<b)
{
for(i=1;i<=a;i++)
{
if(a%i==0 && b%i==0) cont++;
}
if(cont==1) printf("Numeros primos entre si.");
else printf("Numeros nao sao primos entre si");
}
return 0;
}
Português Estruturado (Portugol):
ALGORITMO
DECLARE a,b ,i ,cont NUMÉRICO
cont← 0
ESCREVA "Digite A: "
LEIA a
ESCREVA " Digite B:"
LEIA b
SE a > b
ENTÃO INÍCIO
PARA i← 1 ATÉ i<= b FAÇA [passo 1]
INÍCIO
SE a mod i =0 e b mod i =0
ENTÃO INÍCIO
cont<-- cont+1
FIM
FIM
SE cont = 1
ENTÃO INÍCIO
ESCREVA "Numeros primos entre si."
FIM
SENÃO INÍCIO
ESCREVA "Numeros nao sao primos entre si"
FIM
FIM
SE a < b
ENTÃO INÍCIO
PARA i<--1 ATÉ a FAÇA [passo 1]
INÍCIO
SE a mod i = 0 e b mod i =0
ENTÃO INÍCIO
cont<--cont +1
FIM
FIM
SE cont = 1
ENTÃO INÍCIO
ESCREVA "Numeros primos entre si."
FIM
SENÃO INÍCIO
ESCREVA "Numeros nao sao primos entre si"
FIM
FIM
FIM_ALGORITMO
19) Escreva programa que determine todos os divisores de um dado número N.
Linguagem C:
#include<stdio.h>
int main(void)
{
int valor,i;
printf("Digite um valor: \n");
scanf("%d", &valor);
for (i = 1; i <= valor+1; i++)
{
if (valor%i==0)
{
printf("N divisores:%d\n",i);
}
}
return 0;
}
Português Estruturado (Portugol):
ALGORITMO
DECLARE valor,i NUMÉRICO
ESCREVA "Digite um valor: "
LEIA valor
PARA i← 1 ATÉ valor+1 FAÇA [passo 1]
INÍCIO
SE valor mod i = 0
ENTÃO INÍCIO
ESCREVA "N divisores: ", i
FIM
FIM_ALGORITMO
20) Escreva um programa que calcule os N-menores números primos. Este número N
deve ser lido do teclado.
LINGUAGEM C:
#include<stdio.h>
int main(void)
{
int N, cont,i,j;
cont=0;
printf ("digiteum numero: ");
scanf ("%d",&N);
for (i=1; i<N; i++)
{ cont=0;
for (j=1;j<=i;j++)
{
if (i%j==0)
{ cont++;}}
if (cont ==2)
{printf("\nValores primos:%d",i);}
}
return 0; }
Português Estruturado (Portugol):
ALGORITMO
DECLARE N, cont,i,j NUMÉRICO
cont ← 0
ESCREVA "digite um numero: "
LEIA n
PARA i← 1 ATÉ n-1 FAÇA [passo 1]
INÍCIO
cont← 0
PARA j← 1 ATÉ i FAÇA [passo 1]
INÍCIO
SE i mod j = 0
ENTÃO INÍCIO
cont← cont+1
FIM
FIM
SE cont =2
ENTÃO INÍCIO
ESCREVA "Valores primos: ",i
FIM
FIM
FIM_ALGORITMO
21) Escreva um programa que calcule o m.d.c. (máximo divisor comum) entre A e B
(número inteiros e positivos). Esses dois valores são passados pelo usuário através
do teclado.
LINGUAGEM C:
#include<stdio.h>
int main (void)
{
int a,b,mdc=1,i;
printf("Digite dois numeros.");
scanf("%d,%d",&a,&b);
if(a<b)
{
for(i=1;i<=a;i++)
{
if(a%i==0 && b%i==0)
{
if(i>mdc) mdc=i;
}
}}
else
{
if (a>b)
{
for(i=1;i<=b;i++)
{
if(a%i==0 && b%i==0)
{
if(i>mdc) mdc=i;
}
}
}
else mdc = a;
}
printf("MDC:%d",mdc);
return 0;
}
Português Estruturado (Portugol):
ALGORITMO
DECLARE a,b,mdc ,i NUMÉRICO
mdc← 1
ESCREVA "Digite dois numeros."
LEIA a,b
SE a < b
ENTÃO INÍCIO
PARA i← 1 ATÉ a FAÇA [passo 1]
INÍCIO
SE a mod i = 0 e b mod i = 0
ENTÃO INÍCIO
SE i > mdc
ENTÃO INÍCIO
mdc← i
FIM
FIM
FIM
FIM
SENÃO INÍCIO
SE a > b
ENTÃO INÍCIO
PARA i ← 1 ATÉ b FAÇA [passo 1]
INÍCIO
SE a mod i = 0 e b mod i = 0
ENTÃO INÍCIO
SE i > mdc
ENTÃO INÍCIO
mdc ← i
FIM
FIM
FIM
FIM
SENÃO INÍCIO
mdc ← a
FIM
FIM
ESCREVA "MDC: ", mdc
FIM_ALGORITMO
22) A série de Fibonacci é formada pela seqüência: 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, ...
Escreva um programa que gere a série de FIBONACCI até o N-ésimo termo. Onde N é
um número fornecido pelo usuário.
LINGUAGEM C:
#include<stdio.h>
int main(void)
{
int a,b,soma,n,i;
a=1;
b=1;
printf("Digite O valor de N.");
scanf("%d",&n);
for(i=1;i<=n;i++)
{
if(i==1) printf("%d ", a);
else
{
if(i==2) printf("%d ", b);
else {
soma=a+b;
printf("%d ", soma);
a=b;
b=soma;
}
}
}
return 0;
}
Português Estruturado (Portugol):
ALGORITMO
DECLARE a,b,soma,n,i NUMÉRICO
a← 1
b← 1
ESCREVA "Digite O valor de N. "
LEIA n
PARA i← 1 ATÉ n FAÇA [passo 1]
INICIO
SE i = 1
ENTÃO INÍCIO
ESCREVA " VALOR " , a
FIM
SENÃO INÍCIO
SE i = 2
ENTÃO INÍCIO
ESCREVA "valor ", b
FIM
SENÃO INÍCIO
soma<-- a+ b
ESCREVA " valor ", soma
a← b
b← soma
FIM
FIM
FIM
FIM_ALGORITMO
23) A série de RICCI difere da série de FIBONACCI porque os dois primeiros termos
são fornecidos pelo usuário. Os demais termos são gerados da mesma forma que a
série de FIBONACCI. Criar um programa que imprima os N primeiros termos da série
de RICCI e a soma dos termos impressos, sabendo-se que para existir esta série
serão necessários pelo menos três termos.
Linguagem C:
#include<stdio.h>
int main(void)
{
int a,b,soma=0,n,i, soma2=0;
printf("Digite O valor de N.");
scanf("%d",&n);
if(n<3)
{
printf("Quantidade invalida de termos ");
}
else
{
printf("Digite o primeiro e o segundo valor ");
scanf("%d,%d",&a,&b);
soma2=soma2+a+b;
for(i=1;i<=n;i++)
{
if(i==1)
{
printf("%d ", a);
}
else
{
if(i==2)
{
printf("%d ", b);
}
else
{
soma = a + b;
soma2 = soma2 + soma;
printf("%d ", soma);
a=b;
b=soma;
}
}
}
printf("\nValor da soma dos termos : %d " ,soma2 );
}
return 0;
}
Português Estruturado (Portugol):
ALGORITMO
DECLARE a, b, soma, n, i, soma2; NUMÉRICO
soma← 0
soma2← 0
ESCREVA "Digite O valor de N."
LEIA n
SE n < 3
ENTÃO INÍCIO
ESCREVA "Quantidade invalida de termos "
FIM
SENÃO INÍCIO
ESCREVA " Digite o primeiro e o segundo valor "
LEIA a,b
soma2 ← soma2 + a + b
PARA i ← 1 ATÉ n FAÇA [passo 1]
INÍCIO
SE i = 1
ENTÃO INÍCIO
ESCREVA " VALOR ", a
FIM
SENÃO INÍCIO
SE i = 2
ENTÃO INÍCIO
ESCREVA "valor ", b
FIM
SENÃO
soma← a +b
soma2← soma2 + soma
ESCREVA "valor ", soma
a← b
b← soma
FIM
FIM
FIM
ESCREVA " Valor da soma dos termos : " ,soma2
FIM
FIM_ALGORITMO
24) A série de FETUCCINE é gerada da seguinte forma: os dois primeiros termos são
fornecidos pelo usuário; a partir daí, os termos são gerados com a soma ou
subtração dos dois termos anteriores, ou seja:
Ai=(Ai−1)+(Ai −2) para i ímpar.
Ai=(Ai−1)−(Ai−2) para i par.
Criar um programa que imprima os N primeiros termos da série de FETUCCINE,
sabendo se que para existir esta série serão necessários pelo menos três termos
Linguagem C:
#include<stdio.h>
int main(void)
{
int a,b,q,i,soma=0;
printf("Digite a quantidade de termos.");
scanf("%d",&q);
if(q<3)
{
printf("Quantidade de termos invalida.");
}
else
{
printf("Digite o primeiro e o segundo termo .");
scanf("%d,%d",&a,&b);
for(i=1;i<=q;i++)
{
if( i == 1 )
{
printf(" %d ", a);
}
if ( i==2 )
{
printf(" %d ", b);
}
else
{
if(i%2==0 && i > 2 )
{
soma=b-a;
printf(" %d ", soma);
a=b;
b=soma;
}
if(i%2!=0 && i>2)
{
soma=a+b;
printf(" %d ", soma);
a=b;
b=soma;
}
}
}
}
return 0;
}
Português Estruturado (Portugol):
ALGORITMO
DELCARE a,b,q,i,soma NUMÉRICO
soma← 0
ESCREVA "Digite a quantidade de termos."
LEIA q
SE q < 3
ENTÃO INÍCIO
ESCREVA "Quantidade de termos invalida."
FIM
SENÃO INÍCIO
ESCREVA " Digite o primeiro e o segundo termo ."
LEIA a,b
PARA i ← 1 ATÉ q FAÇA [passo 1]
INÍCIO
SE i = 1
ENTÃO INÍCIO
ESCREVA " valor ", a
FIM
SE i= 2
ENTÃO INÍCIO
ESCREVA " valor " , b
FIM
SENÃO INÍCIO
SE i mod 2 = 0 e i > 2
ENTÃO INÍCIO
soma ← b-a
ESCREVA " valor ", soma
a ← b
b ← soma
FIM
SE i mod 2 ≠ 0 e i > 2
ENTÃO INÍCIO
soma ← a+b
ESCREVA " valor ", soma
a ← b
b ← soma
FIM
FIM
FIM
FIM
FIM_ALGORITMO
25) Seja a seguinte série: 1, 4, 9, 16, 25, 36, ... Escreva um programa que gere esta
série até o N-ésimo termo. Este N-ésimo termo é digitado pelo usuário.
Linguagem C:
#include<stdio.h>
int main(void)
{
int i,q,produto;
printf("Digite o termo.");
scanf("%d",&q);
for(i=1;i<=q;i++)
{
produto=i*i;
printf("%d ",produto);
}
return 0;
}
Português Estruturado (Portugol):
ALGORITMO
DECLARE i, q , produto NUMÉRICO
ESCREVA "Digite o termo."
LEIA q
PARA i ← 1 ATÉ q FAÇA [passo 1]
INÍCIO
produto ← i*i
ESCREVA " VALOR " , produto
FIM
FIM_ALGORITMO
26) Seja a seguinte série: 1, 4, 4, 2, 5, 5, 3, 6, 6, 4, 7, 7, ... Escreva um programa que
seja capaz de gerar os N termos dessa série. Esse número N deve ser lido do teclado.
Linguagem C:
#include<stdio.h>
int main (void)
{
int n,valor=1,j,controle=1,i;
printf("Digite o valor de N.");
scanf("%d",&n);
for(j=1;j<=n;j++)
{
valor=controle;
printf("%d ", valor);
valor=valor+3;
for (i=0;i<2;i++)
{
printf("%d ",valor);
j=j+1;
}
controle=controle+1;
}
return 0;
}
Português Estruturado (Portugol):
ALGORITMO
DECLARE n, valor, j, controle,i NUMÉRICO
valor ← 1
controle ← 1
ESCREVA "Digite o valor de N."
LEIA n
PARA j ← 1 ATÉ n FAÇA [passo 1]
INÍCIO
valor ← controle
ESCREVA "valor ", valor
valor ← valor + 3
PARA i=0 ATÉ 1 FAÇA [passo 1]
INÍCIO
ESCREVA " valor ",valor
j<- -j+1
FIM
controle← controle+1
FIM
FIM_ALGORITMO
27) Sendo H = 1 +1/2 + 1/3 + 1/4+ ... + 1/N. Elabore um programa para gerar o número
H. O número N deverá ser lido do teclado.
LINGUAGEM C:
#include <stdio.h>
int main(void)
{
float soma,i,n;
printf("Digite o valorde n:");
scanf("%f",&n);
for (i=1;i<=n;i++)
{
soma = 0;
for (i=1;i<=n;i++)
soma=soma+1/i;
}
printf("Valor da soma=%f",soma);
return 0;
}
Português Estruturado (Portugol):
ALGORITMO
DECLARE soma,i,n NUMÉRICO
ESCREVA "Digite o valor de n:"
LEIA n
PARA i ← 1 ATÉ n FAÇA [passo 1]
INÍCIO
soma ← 0
PARA i← 1 ATÉ n FAÇA [passo 1]
INÍCIO
soma ← soma + 1/i
FIM
FIM
ESCREVA "Valor da soma= ",soma
FIM_ALGORITMO
28) Faça um programa que leia um número real X do teclado e, em seguida, calcule e
imprima o seguinte somatório: S = X – X/1! + X/2! – X/3! + ... usando os vinte primeiros
termos da série.
LINGUAGEM C:
#include<stdio.h>
int main (void)
{
float x,s = 0.0f, fator = 1.0f;
int i, posicao;
printf("digite x: ");
scanf("%f", &x);
for ( posicao = 0; posicao < 20 ; posicao++ )
{
for ( i = 1; i<= posicao || (posicao == 0 && i==1); i++)
{
fator=fator*i;
}
if (posicao % 2 != 0)
{
s= s - x/fator;
}
else {
s=s+x/fator;
fator=1;
}}
printf("%f", s);return 0;
}
Português Estruturado (Portugol):
ALGORITMO
DECLARE x , s , posicao , i fator NUMÉRICO
s ← 0
fator ← 1
ESCREVA " digite x:"
LEIA x
PARA i ← 0 ATÉ 19 FAÇA [passo 1]
INÍCIO
PARA i← 1 ATÉ posição ou posicao = 0 e i= 1 FAÇA [passo 1]
INÍCIO
fator← fator*i;
FIM
SE posicao mod 2 ≠ 0
ENTÃO INÍCIO
s ← s - x/fator
FIM
SENÃO INÍCIO
s ← s + x/fator
fator← 1
FIM
FIM
ESCREVA " S ", s
FIM_ALGORITMO
29) Escreva um programa para calcular o valor de S, dado por: S = 1/N + 2/(N-1) +
3/(N-2) + ... + (N-1)/2 + N/1.
linguagem C:
#include<stdio.h>
int main (void)
{
float n, i,j,a;
float soma=0;
printf("Digite um numero.");
scanf("%f",&n);
j=n;
for (i=1;i<=n;i++)
{
a= i/j;
j -- ;
soma=soma+a;
}
printf("O valor da soma: %f ",soma);
return 0;
}
Português Estruturado (Portugol):
ALGORITMO
DECLARE n, i, j,a, soma NUMÉRICO
soma ← 0
ESCREVA "Digite um numero. "
LEIA n
j ← n
PARA i ← 1 ATÉ n FAÇA [passo 1]
INÍCIO
a← i/j
j← j- 1
soma ← soma + a
FIM
ESCREVA "O valor da soma: ", soma
FIM_ALGORITMO
30) Preparar um programa para calcular a soma da seguinte série de 100 termos: 1 –
1/2 + 1/4 – 1/6 + 1/8 – 1/10 + 1/12 - …
LINGUAGEM C:
#include<stdio.h>
int main(void)
{
float soma=0, k=4 , a , b ,j=2;
int i;
for(i=1;i<=99;i++)
{
if(i==1)
{
a=1/j;
j=j+4;
soma=soma-a;
}
if(i%2!=0 && i>1)
{
a=1.0/j;
soma=soma-a;
j=j+4;
}
if(i%2==0)
{
b = 1.0/k;
soma = soma + b;
k = k + 4;
}
}
soma=soma+1;
printf("Valor da soma S: %f" , soma);
return 0;
}
Português Estruturado (Portugol):
ALGORITMO
DECLARE soma, k, a, b, j, i NUMÉRICO
soma ← 0
k ← 4
j ← 2
PARA i← 1 ATÉ 99 FAÇA [passo 1]
INÍCIO
SE i = 1
ENTÃO INÍCIO
a ← 1/j
j ← j+4
soma=soma-a
FIM
SE i mod 2 ≠ 0 e i > 1
ENTÃO INÍCIO
a ← 1/j
soma ← soma - a
j← j+4
FIM
SE i mod 2 = 0
ENTÃO INÍCIO
b ← 1.0/k
soma ← soma + b
k ← k + 4
FIM
FIM
soma ← soma+1;
ESCREVA "Valor da soma S: " , soma
FIM_ALGORITMO
31) Sendo: s= 1+ 1/22 + 1/33 +1 /44 + …+ 1/NN
um somatório de N (definido pelo usuário) termos, escreva um programa para
calcular S para um número determinado N (fornecido pelo usuário).
Linguagem C:
#include<stdio.h>
#include<math.h>
int main (void)
{ float num,i,soma=0,j;
printf("Digite o numero.");
scanf("%f",&num);
j=num;
for(i=1;i<=j;i++)
{
soma=soma+ (1/pow(num,num));
num--;
}
printf("O valor da soma:%f",soma);
return 0;
}
Português Estruturado (Portugol):
ALGORITMO
DECLARE num, i, soma, j NUMÉRICO
soma← 0
ESCREVA "Digite o numero."
LEIA num
j← num
PARA i← 1 ATÉ j FAÇA [passo 1]
INÍCIO
soma ← soma + (1 / numNUM )
num← num-1
FIM
ESCREVA "O valor da soma: ", soma
FIM_ALGORITMO
32) O valor aproximado do número π pode ser calculado usando-se a série sendo π =
raiz cúbica de S × 32 .
s= 1 - 1 / 33 + 1/53 ...
Faça um programa que calcule e imprima o valor de π usando os 51 primeiros
termos da séria acima.
Linguagem C:
#include<stdio.h>
#include<math.h>
int main (void)
{
float p, s= 0, divisor= 1;
int contador=1;
while (contador<=51)
{
if (contador%2==0)
{
s=s-1/pow(divisor,3);
}
else
{
s=s+1/pow(divisor,3);
}
divisor=divisor+2;
contador++;
}
p = cbrt(s*32);
printf("%f", p);
return 0;
}
Português Estruturado (Portugol):
ALGORITMO
DECLARE p , s, divisor, contador NUMÉRICO
s ← 0
divisor ← 1
contador ← 1
ENQUANTO contador <= 51 FAÇA
INÍCIO
SE contador mod 2 = 0
ENTÃO INÍCIO
s ← s - 1 / (divisor ^3)
FIM
SENÃO INÍCIO
s ← s + 1 /( divisor ^ 3)
FIM
divisor ← divisor+2;
contador ← contador + 1
FIM
p ← (s*32)^1/3
ESCREVA " valor de p: ", p
FIM_ALGORITMO
33) Implementar um programa para calcular o sen(X). O valor de X deverá ser digitado
em graus. O valor do seno de X será calculado pela soma dos 15 primeiros termos da
série a seguir:
sex(x)= x - x3 / 3! + x5 /5! - …+ ...
Linguagem C:
#include<stdio.h>
#include<math.h>
#define pi 3.14
int main(void)
{
float ang,denominador,fat,soma,fim,a;
float mult=1;
int cont=0;
soma=0;
printf("Digite o valor do angulo:");
scanf("%f",&ang);
a=ang;
ang=ang*(pi/180);
for(denominador=3;denominador<=31; denominador=denominador+2)
{ mult=1;
for(fat=2;fat<=denominador ;fat++) { mult= mult*fat;
} if(cont%2==0)
{ soma=soma - (pow(ang,denominador)/mult);
} else
{
soma=soma+(pow(ang,denominador)/mult);
}
cont++; } fim=ang+soma;
printf("O valor do seno de %f: %f",a,fim);
return 0; }
Português Estruturado (Portugol):
ALGORITMO
DELCARE ang, denominador, fat, soma, fim, a, mult, cont NUMÉRICO
soma ← 0
mult ← 1
cont ← 0
ESCREVA " Digite o valor do angulo: "
LEIA ang
a ← ang
ang ← (ang*3.14/180)
PARA denominador ← 3 ATÉ 31 FAÇA [passo 2]
INÍCIO
mult ← 1
PARA fat ← 2 ATÉ denominador FAÇA [passo 1]
INÍCIO
mult ← mult * fat
FIM
SE cont mod 2 = 0
ENTÃO INÍCIO
soma ← soma - (ang ^ denominador) / mult)
FIM
SENÃO INÍCIO
soma ← soma + (ang ^ denominador ) / mult )
FIM
cont ← cont + 1
FIM
fim ← ang+soma;
ESCREVA "O valor do seno de : " , a, fim
FIM_ALGORITMO
34) Implementar um programa para calcular o cos(X). O valor de X deverá ser digitado
em graus. O valor do cosseno de X será calculado pela soma dos 15 primeiros termos
da série a seguir:
cos(x)= 1 - x2/ 2! + x4/4! - x6/6! + ...
Linguagem C:
#include<stdio.h>
#include<math.h>
#define pi 3.14
int main()
{
float ang,denominador,fat,soma,fim,a;
float mult=1;
int cont=0;
soma=0;
printf("Digite o valor do angulo:");
scanf("%f",&ang);
a=ang;
ang=ang*(pi/180);
for(denominador=2;denominador<=30; denominador=denominador+2)
{ mult=1;
for(fat=2;fat<=denominador ;fat++) { mult= mult*fat;
} if(cont%2==0)
{ soma=soma - (pow(ang,denominador)/mult);
} else
{
soma=soma+(pow(ang,denominador)/mult);
}
cont++; } fim=1+soma;
printf("O valor do cosseno de %f: %.3f",a,fim);
return 0; }
Português Estruturado (Portugol):
ALGORITMO
DECLARE ang, denominador, fat, soma, fim, a, mult ,cont NUMÉRICO
mult ← 1
cont ← 0
soma ← 0
ESCREVA " Digite o valor do angulo: "
LEIA ang
a ← ang
ang ← (ang*3.14/180)
PARA denominador ← 2 ATÉ denominador 30 FAÇA [passo 2]
INÍCIO
mult<--1
PARA fat ← 2 ATÉ denominador FAÇA [passo 1]
INÍCIO
mult ← mult * fat
FIM
SE cont mod 2 = 0
ENTÃO INÍCIO
soma ← soma - (ang ^ denominador)/mult
FIM
SENÃO INÍCIO
soma ← soma + (ang ^ denominador)/mult)
FIM
cont ← cont + 1
FIM
fim ← 1 + soma
ESCREVA "O valor do cosseno de " ,a,fim
FIM_ALGORITMO
35) Implementar um programa para calcular o valor de eX . O valor de X deverá ser
digitado. O valor de será calculado pela soma dos 15 primeiros termos da série a
seguir: eX = 1+ x + x2 / 2! + x3 / 3! + x4 / 4! + ...
LINGUAGEM C:
#include<stdio.h>
#include<math.h>
int main (void)
{
float fat=1,e=0,x,i;
printf("Digite o valor de X: ");
scanf("%f",&x);
for (i=1;i<=14; i++)
{
fat=fat*i;
e=e+pow(x,i)/fat;
}
e=e+1;
printf("Valor de e elevado a %.1f vale: %f",x,e);
return 0;
}
Português Estruturado (Portugol):
ALGORITMO
DECLARE fat , e , x , i NUMÉRICO
fat ← 1
e ← 0
ESCREVA "Digite o valor de X: "
LEIA x
PARA i ← 1 ATÉ 14 FAÇA [passo 1]
INÍCIO
fat ← fat * i
e ← e + (x ^ i)/ fat
FIM
e ← e+1
ESCREVA "Valor de e elevado a vale:" x , e
FIM_ALGORITMO
36) Criar um programa que leia o valor de N, imprima a seqüência a seguir e o
resultado.
N!/0! - (N-1)!/2! + (N-2)!/4! - (N-3)/6! + …+ 0!/(2N)!
Linguagem C:
#include <stdio.h>
int main(void)
{
float total=0,fat1=1, fat2=1;
int i, j, k, sinal=1 , n, lim_den=0;
printf("Digite um numero.");
scanf("%d", &n);
for(i=n;i>0;i--)
{
for(j=1;j<=i;j++)
{
fat1=fat1*j;
}
printf("\nFatorial: %.2f",fat1);
for(k=1;k<=lim_den;k++)
{
fat2=fat2*k;
}
printf("\nFatorial: %.2f",fat2);
total=total+(fat1/fat2)*sinal;
sinal=sinal*(-1);
lim_den=lim_den+2;
fat1=1;
fat2=1;
}
printf("\n Final: %.2f\n",total);
return 0;
}
Português Estruturado (Portugol):
ALGORITMO
DECLARE total,fat1, fat2, i, j, k, sinal , n, lim_den; NUMÉRICO
total← 0
fat1← 1
fat2← 1
sinal← 1
lim_den← 0
ESCREVA "Digite um numero."
LEIA n
PARA i← n ATÉ 1 FAÇA [passo -1]
INÍCIO
PARA j← 1 ATÉ i FAÇA [passo 1]
INÍCIO
fat1 ← fat1*j
FIM
ESCREVA "Fatorial: ",fat1
PARA k← 1 ATÉ lim_den FAÇA [passo 1]
INÍCIO
fat2 ← fat2*kESCREVA "Fatorial: " , fat2
total ← total+(fat1/fat2)*sinal
sinal← sinal*(-1)
lim_den← lim_den+2
fat1← 1
fat2← 1
FIM
ESCREVA "Final:" ,total
FIM_ALGORITMO
37) Escreva um programa que leia um conjunto de 50 fichas, cada uma contendo, a
altura e o código do sexo de uma pessoa (código = 1 se for masculino e 2 se for
feminino), e calcule e imprima: a maior e a menor altura da turma; a média de altura
das mulheres e a média de altura da turma.
Linguagem C:
#include<stdio.h>
int main(void)
{
float i , nota , maior=0, menor=999 , opcao, soma=0 , media;
float h_homem , h_mulher;
float soma_mulher=0, media_mulher , q_mulher=0;
for(i=1;i<=50;i++)
{
printf("\nDigite 1:Homem 2:Mulher ");
scanf("%f",&opcao);
if(opcao==1)
{
printf("\nDigite a altura do homem: ");
scanf("%f",&h_homem);
soma=soma+h_homem;
if(h_homem > maior)
{
maior = h_homem;
}
if(h_homem < menor)
{
menor=h_homem;
}
}
if(opcao==2)
{
printf("\nDigite a altura da mulher: ");
scanf("%f",&h_mulher);
soma = soma + h_mulher;
soma_mulher = soma_mulher + h_mulher;
q_mulher++;
if(h_mulher > maior)
{
maior = h_mulher;
}
if(h_mulher < menor)
{
menor=h_mulher;
}
}
}
media=soma/50;
media_mulher=soma_mulher/q_mulher;
printf("\nMaior altura da turma: %.2f", maior);
printf("\nMenor altura da turma: %.2f", menor);
printf("\nValor da media das alturas da turma: %.2f",media);
printf("\nValor da media das alturas das mulheres: %.2f",media_mulher);
return 0;
}
Português Estruturado (Portugol):
ALGORITMO
DECLARE i , nota , maior, menor , opcao, soma , media, h_homem , h_mulher,
soma_mulher , media_mulher , q_mulher NUMÉRICO
maior ← 0
menor ← 999
soma ← 0
soma_mulher ← 0
q_mulher ← 0
PARA i← 1 ATÉ 50 FAÇA [passo 1]
INÍCIO
ESCREVA "Digite 1:Homem 2:Mulher"
LEIA opcao
SE opcao = 1
ENTÃO INÍCIO
ESCREVA "Digite a altura do homem:"
LEIA h_homem
soma ← soma + h_homem
SE h_homem > maior
ENTÃO INÍCIO
maior ← h_homem
FIM
SE h_homem < menor
ENTÃO INÍCIO
menor ← h_homem
FIM
FIM
SE opcao = 2
ENTÃO INÍCIO
ESCREVA "Digite a altura da mulher: "
LEIA h_mulher
soma ← soma + h_mulher
soma_mulher ← soma_mulher + h_mulher
q_mulher ← q_mulher + 1
SE h_mulher > maior
ENTÃO INÍCIO
maior ← h_mulher
FIM
SE h_mulher < menor
ENTÃO INÍCIO
menor ← h_mulher
FIM
FIM
FIM
media ← soma / 50
media_mulher ← soma_mulher/q_mulher
ESCREVA "Maior altura da turma:", maior
ESCREVA "Menor altura da turma: " , menor
ESCREVA "Valor da media das alturas da turma: " , media
ESCREVA "Valor da media das alturas das mulheres: " , media_mulher
FIM_ALGORITMO
38) Construa um programa para calcular a média de valores PARES e ÍMPARES, que
serão digitados pelo usuário. Ao final o algoritmo deve mostrar estas duas médias. O
algoritmo deve mostrar também o maior número PAR digitado e o menor número
ÍMPAR digitado. Para finalizar o usuário irá digitar um valor negativo.
Linguagem C:
#include<stdio.h>
int main (void)
{
float media_par, media_impar, menor_impar=99999999;
int numero=0,soma_par=0,par=0, maior_par=0;
int soma_impar=0,impar=0;
printf("Digite valores (-1 para finalizar.)\n");
while(numero!=-1)
{
printf("Digite o valor: ");
scanf("%d",&numero);
if(numero%2==0)
{
soma_par = soma_par + numero;
par++;
if(numero>maior_par)
{
maior_par=numero;
}
}
else
{
if(numero%2!=0 && numero!=-1)
{
soma_impar = soma_impar + numero;
impar++;
if(numero < menor_impar)
{
menor_impar=numero;
}
}
}
}
media_par=soma_par/par;
media_impar=soma_impar/impar;
printf("\nQuantidade de valores pares: %d", par);
printf("\nMedia dos valores pares: %.2f", media_par);
printf("\nMaior valor par: %d", maior_par);
printf("\nQuantidade de valores impares: %d", impar);
printf("\nMedia impar: %.2f", media_impar);
printf("\nMenor numero impar: %.2f", menor_impar);
return 0;
}
Português Estruturado (Portugol):
ALGORITMO
DECLARE
media_par,media_impar,menor_impar,numero,soma_par,par,maior_par,soma_impar,impar
NUMÉRICO
menor_impar ← 99999999
numero ← 0
soma_par← 0
par← 0
maior_par← 0
soma_impar ← 0
impar ← 0
ESCREVA "Digite valores (-1 para finalizar.)"
ENQUANTO numero ≠ -1 FAÇA
INÍCIO
ESCREVA "Digite o valor: "
LEIA numero
SE numero mod 2 = 0
ENTÃO INÍCIO
soma_par← soma_par + numero
par ← par+1
SE numero > maior_par
ENTÃO INÍCIO
maior_par← numero
FIM
FIM
SENÃO INÍCIO
SE numero mod 2 ≠ 0 e numero != -1
ENTÃO INÍCIO
soma_impar ← soma_impar + numero
impar← impar+1
SE numero < menor_impar
ENTÃO INÍCIO
menor_impar← numero
FIM
FIM
FIM
FIM
media_par ← soma_par/par
media_impar ← soma_impar/impar
ESCREVA "Quantidade de valores pares:", par
ESCREVA "Media dos valores pares: ", media_par
ESCREVA "Maior valor par: ", maior_par
ESCREVA "Quantidade de valores impares: ", impar
ESCREVA "Media impar: ", media_impar
ESCREVA "Menor numero impar: ", menor_impar
FIM_ALGORITMO
39) Dado um país A, com 5000000 de habitantes e uma taxa de natalidade de 3% ao
ano, e um país B com 7000000 de habitantes e uma taxa de natalidade de 2% ao ano,
escrever um programa que seja capaz de calcular e imprimir o tempo necessário para
que a população do país A ultrapasse a população do país B.
Linguagem C:
#include<stdio.h>
int main (void)
{
float A = 5000000, B = 7000000 ;
int t=0;
while(B >= A)
{
A=A+(A*0.03);
B=B+(B*0.02);
t=t+1;
}
printf("\nPopulacao A:%.3f\nPopulacao B:%.3f ",A,B);
printf("\nTempo :%d ",t);
return 0;
}
Português Estruturado (Portugol):
ALGORITMO
DECLARE A , B , t NUMÉRICO
A ← 5000000
B ← 7000000
t ← 0
ENQUANTO B > = A FAÇA
INÍCIO
A ← A + A * 0.03
B ← B + B * 0.02
t ← t + 1
FIM_ENQUANTO
ESCREVA"Populacao A, Populacao B: " , A, B
ESCREVA "Tempo: ", t
FIM_ALGORITMO