Faça um programa que leia um número indeterminado de valores inteiros.

A leitura
somente será interrompida quando o usuário informar o valor zero. Valores negativos
devem ser ignorados para os cálculos. O programa deve gerar os seguintes resultados
(ignorando valor 0 e negativos): Soma dos números lidos, Média dos números lidos,
Maior valor informado, Menor valor informado, Percentual de números pares e o
Percentual de Números ímpares.

#include <stdio.h>

int main()
{
int num, soma = 0, maior = 0, menor = 0, cont = 0, blok = 0, digit = 0;
float media, pp = 0, pi = 0;
do
{

printf("Digite um numero interio:\n");

scanf("%d", &num);
digit = num != 0 ? digit+1 : digit;
if (num != 0 && num > 0)
{
maior = cont == 0 && maior == 0 ? num : maior;
menor = cont == 0 && menor == 0 ? num : menor;
maior = num > maior ? num : maior;
menor = num < menor ? num : menor;
if (num > 0)
{
soma += num;
cont++;
}
pp = num%2 == 0 ? pp+1 : pp;
pi = num%2 != 0 ? pi+1 : pi;
}
if (num < 0)
blok++;
}
while (num != 0);
if ( blok != digit)
{
media = (float) soma/cont;
pp = (pp*100)/cont;
pi = (pi*100)/cont;
}
printf("A soma dos numeros = %d\nA media dos numeros = %.2f\nMaior valor = %d\
nMenor valor = %d\nPercental de numeros pares = %%%.2f\nPercentual de numeros
impares = %%%.2f\n", soma, media, maior, menor, pp, pi);
return 0;
}

Faça um programa que leia um par de valores inteiros (X,Y), tal que, obrigatoriamente Y >=
X. O programa deve calcular e imprimir o valor da soma de todos os números inteiros do
intervalo X,Y (inclusive). A operação deve ser repetida até que os dois valores (X e Y)
informados sejam negativos. (P.ex.: (7,11)==45; (53,68)==968).
#include <stdio.h>

#include <stdio.h>
int main()
{
int x, y, aux, soma;
do
{
printf("Digite um numero inteiro:\n");
scanf("%d", &x);
printf("Digite um numero inteiro:\n");
scanf("%d", &y);
if (x > y)
{
aux = y;
y = x;
x = aux;
}
soma = x;
aux = x;
if (x > 0 && y > 0)
{
do
{
if (x < y)
{
x++;
soma = soma + x;
}
}
while ( x < y);
}
else
{
do
{
if (x < y)
{
x++;
soma = soma + x;
}
}
 while ( x < y);
}
printf("a soma dos valores de todos os números inteiros do intervalo %d e %d
e = %d\n", aux, y, soma);
}
while(x > 0 && y > 0);
return 0;
}

Utilizando a estrutura condicional Switch-Case, implemente uma calculadora que

recebe um valor inteiro A, um sinal de operação e outro valor inteiro B. Imprima o
resultado da operação correspondente. As operações permitidas são:

#include <stdio.h>

int main()
{
int A, B, cont = 0, pot = 1;
char x;
printf("Digite um numero:\n");
scanf(" %d", &A);
printf("Digite um sinal de operação:(Adição +, subtração -, multiplicação *, divisão /,
resto %%, Exponenciação ^)\n");
scanf(" %c", &x);
printf("Digite um numero:\n");
scanf(" %d", &B);
switch (x)
{
case '+' : printf("%d + %d = %d", A, B, A+B); break;
case '-' : printf("%d - %d = %d", A, B, A-B); break;
case '*' : printf("%d * %d = %d", A, B, A*B); break;
case '/' : printf("%d / %d = %.2f", A, B, (float)A/B); break;
case '%' : printf("%d %% %d = %d", A, B, A%B); break;
case '^' : do
{

if ( B > 0)
{
while (cont < B)
{
cont++;
pot *= A;
}
printf("%d ^ %d = %d", A, B, pot);
}
if ( B < 0)
{
while (cont > B)
 {
cont--;
pot *= A;
}
printf("%d ^ %d = %.2f", A, B, (float) 1/pot);
}

} while( cont < B);

break;
}
return 0;
}

Faça um programa que leia um valor inicial N e uma razão R. Imprima uma sequência
em P.A. contendo 10 valores, e uma sequência em P.G. contendo 10 valores

#include <stdio.h>

int main()
{
float vi, raz, vii;

printf("Digite um valor inicial:\n");

scanf(" %f", &vi);
printf("Digite uma razão:\n");
scanf(" %f", &raz);

printf("P.A\n");
vii = vi;
for(int cont = 0; cont < 10; cont++)
{
printf("%.2f", vi);
vi += raz;
if(cont != 9)
printf(" - ");
else
printf("\n");
}

printf("P.G\n");
for(int cont = 0; cont < 10; cont++)
{
printf("%.2f", vii);
vii *= raz;
if(cont != 9)
printf(" - ");
else
printf("\n");
 }

return 0;
}

Faça um programa que leia um valor inteiro N não-negativo. O programa deve calcular
e imprimir o valor de N!

#include <stdio.h>

int main()
{
int x, fatorial = 1, fat;
printf("Digite um valor inteiro e maior que zero:\n");
scanf(" %d", &x);
x = x < 0 ? x * -1 : x;
fat = x;
for(x=x; x > 0; x--)
fatorial *= x;
printf("O fatorial de %d! = %d\n", fat, fatorial);
return 0;
}

Sabia que a sequência Fibonacci está ligada intimamente à natureza? Os números da

série são facilmente encontrados nos seres vivos e no meio ambiente. Essa série é infinita
e se inicia com os valores: 1, 1, 2, 3, 5, 8, 13, 21, 34, (...), onde o próximo valor sempre
será a soma dos dois valores anteriores. Faça um programa que leia um valor N, e
imprima todos N primeiros termos da série Fibonacci. Após isso, imprima o resultado da
divisão do último termo pelo penúltimo termo. Repita essa mesma operação para
diversos valores de N diferentes, e veja o que acontece de interessante... Dica: Pesquise
na Internet o conceito de “Proporção Áurea" ou “Proporção Divina”.

#include <stdio.h>

int main()
{
int x = 0, y = 1, z = 1, n, cont, parada = 1, ult, penu;
float div;
do
{
printf("Digite 0 para parar e 1 para continuar:\n");
scanf(" %d", &parada);
if(parada != 0)
{
printf("Digite um numero:\n");
scanf(" %d", &n);
n = n < 0 ? n * -1 : n;
 if(n > 0)
{
for(cont = 0; cont < n; cont ++)
{
ult = z;
penu = x;
printf("%d", z);
z = x + y;
x = y;
y = z;
if(cont != n-1)
printf(" - ");
else
printf("\n");
}
div = (float) ult/penu;
printf("%d / %d = %.2f\n", ult, penu, div);
}
else
{
ult = 0, penu = 0;
div = 0;
printf("%d / %d = %.2f\n", ult, penu, div);
}

}
x = 0, y = 1, z = 1;
}
while(parada != 0);
return 0;
}

Faça um programa que receba do usuário o comprimento de três retas. O programa

deve informar ao usuário se é possível ou não formar um triângulo com essas retas.

#include <stdio.h>

int main()
{
int rt1, rt2, rt3, a;
printf("Digite o cumprimento da primeira reta:\n");
scanf(" %d", &rt1);
printf("Digite o cumprimento da segunda reta:\n");
scanf(" %d", &rt2);
printf("Digite o cumprimento da terceira reta:\n");
scanf(" %d", &rt3);

if(rt1 > rt2 && rt1 > rt3)

 {
a = rt3;
rt3 = rt1;
rt1 = a;
if(rt1 > rt2)
{
a = rt2;
rt2= rt1;
rt1 = a;
}
}
if(rt2 > rt1 && rt2 > rt3)
{
a = rt3;
rt3 = rt2;
rt2 = a;
if(rt1 > rt2)
{
a = rt2;
rt2 = rt1;
rt1 = a;
}
}
if(rt3 > rt2 && rt3 > rt1)
{
if(rt1 > rt2)
{
a = rt2;
rt2 = rt1;
rt1 = a;
}
}
if(rt1 + rt2 > rt3)
printf("E possivel formar um trangulo!");
else
printf("Nao e possivel formar um trangulo!");

return 0;
}

Faça um programa que gere um número aleatório entre 0 e K. O programa deve

imprimir o número sorteado e a quantidade de dígitos que ele possui (p.ex.: O número
6958 possui 4 dígitos).

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main()
{
int k, x, y = 0, z = 10, aux, c = 1;

printf("Digite o limite da geração do numero aleatorio:\n");

scanf(" %d", &k);
k++;

srand(time(NULL));
x = rand() % k;

do
{
if ( x >= y && x < z)
break;
else
{
c++;
aux = z;
y = aux;
z *= 10;
}
}
while(1);

printf("\nO número %d possui %d dígito(s)\n", x, c);

return 0;
}

Faça um programa que declare duas variáveis do tipo char, faça a leitura, validando
entrada para que seja lido apenas símbolos numéricos (entre ‘0’ e ‘9’). Após isso,
converta e imprima o valor da multiplicação dos números.

#include <stdio.h>

int main()
{
int parada = 1, conv1, conv2;
char x, y;

do
{
printf("Digite dois simbolos numericos entre 0 e 9:\n");
scanf(" %c", &x);
 printf("Digite um simbolo numerico entre 0 e 9:\n");
scanf(" %c", &y);

if((x >= '0' && x <= '9') && (y >= '0' && y <= '9'))
parada = 0;
else
printf("Aviso: Simbolo incorreto\n");
}
while(parada != 0);

conv1 = x - '0';
conv2 = y - '0';
printf("%c * %c = %d\n", x, y, conv1 * conv2);

return 0;
}

Um determinado material radioativo perde metade de sua massa a cada 50 segundos.

Dada a massa inicial, em gramas, fazer um programa em C que calcule o tempo
necessário para que essa massa se torne menor que 0,5 grama. O programa em C deve
escrever a massa inicial, a massa final e o tempo calculado em horas, minutos e
segundos.

#include <stdio.h>

int main()
{
int seg, min, hor, rest;
float massai, massaf;

printf("Digite em gramas a massa do produto radioativo:\n");

scanf(" %f", &massai);
massaf = massai;

do
{
massaf /= 2;
seg += 50;
}
while( massaf >= 500);
hor = seg / 3600;
rest = seg % 3600;
min = rest / 60;
seg = rest % 60;
 printf("Massa inicial = %.2f\nMassa Final = %.2f\nTempo = %d:%d:%d\n", massai,
massaf, hor, min, seg);

return 0;
}

Faça um programa que imprima na tela um triângulo equilátero formado por símbolos
*. Este triângulo deve ter altura de N linhas (N >= 2 e deve ser informado pelo usuário
no início da execução).

#include <stdio.h>

int main()
{
int n, au, car = 1;
char c = '*';

do
{
printf("Digite a altura desse triangulo em linhas (as linhas deve ser maior ou
igual a 2 ou seja Linhas >=2):\n");
scanf(" %d", &n);
if(n < 2)
printf("Linhas inferior que 2!\n");
}
while(n < 2);
au = n;

for(int i = 0; i < n; i++)

{
for(int i = 1; i <= au; i++)
{
if(i < au)
printf(" ");
if(i == au)
{
for(int i = 0; i <= car; i++)
{
if(i < car)
printf("%c", c);
if(i == car)
printf("\n");
}
au--;
car++;
}
}
 }
return 0;
}

Faça um programa que receba um número informado pelo usuário e imprima a

informação se este é um número primo ou não. O programa deve testar vários números,
até que o usuário digite qualquer valor negativo.

#include <stdio.h>

int main()
{
int x, resto, quant = 0;

do
{
printf("Digite um numero:\n");
scanf(" %d", &x);
if ( x > 1)
{
for(int div = 2; div < x; div++)
{
resto = x % div;
if (resto == 0)
quant++;
}
if(quant == 0)
{
printf("O numero %d é primo!\n", x);
printf("--------------------------\n");
}
else
{
printf("O numero %d não é primo!\n", x);
printf("--------------------------\n");
}
}
else
if (x > 0)
{
printf("Não é primo!\n");
printf("--------------------------\n");
}
quant = 0;
}
while(x > 0);
return 0;
}
Faça um programa que gere N números de matrícula no formato ABCD-V, onde V é um
dígito verificador, no qual:
V=|A–B+C–D|
se V >= 10, então V = d1+d2 (a soma dos dois dígitos).

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main()
{
int n, a, b, c, d, v;

printf("Digite a quantidade de termos de matricula:\n");

scanf(" %d", &n);

srand(time(NULL));

for(int cont = 0; cont < n; cont++)

{
a = rand() % 10;
b = rand() % 10;
c = rand() % 10;
d = rand() % 10;
v = (a - b) + ( c - d);
if(v < 0)
v *= -1;
if(v > 10)
v = a + b;
printf("-----------------\n%d%d%d%d-%d\n", a, b, c, d, v);
}

return 0;
}

Sabendo que o valor de pi pode ser calculado através da série Gregory-Leibniz:

π = (4/1) - (4/3) + (4/5) - (4/7) + (4/9) - (4/11) + (4/13) - (4/15) ...
Faça um algoritmo para calcular e imprimir o valor de pi, com 15 casas decimais, obtido
até o 999.999.999o termo da série. (Resposta correta: 3.141592654588051)

#include <stdio.h>

int main()
{
double pi, n = 1, soma = 0;
for(int i= 1; i <= 999999999; i++)
 {
pi = 4 / n;
n+=2;
if(i%2 == 0)
soma -= pi;
else
soma += pi;
}
printf("%.15f", soma);
return 0;
}

Faça um programa que receba um número e verifique se ele é ou não um número

perfeito. Um número é perfeito quando a soma de todos os seus divisores inteiros –
excluindo ele mesmo – é igual ao próprio
número. Ex: 28 = 1 + 2 + 4 + 7 + 14.

#include <stdio.h>

int main()
{
int num, soma;
printf("Digite um numero:\n");
scanf(" %d", &num);

for(int i = 1; i < num; i ++)

{
if(num % i == 0)
soma += i;
}
if(soma == num)
printf("O numero %d é perfeio!\n", num);
else
printf("O numero %d não é perfeio!\n", num);

return 0;
}

Faça um programa que leia dois valores inteiros X e Y, tal que Y >= X. O programa
deverá sortear N valores no intervalo entre X e Y (inclusive). Obs.: Os números
sorteados no intervalo entre X e Y não podem ser obtidos por tentativa e erro!

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main()
{
int y, x, aux, sorteado, p = 1;
printf("Digite um numero:\n");
scanf(" %d", &x);
printf("Digite um numero:\n");
scanf(" %d", &y);
if(x > y)
{
aux = y;
y = x;
x = aux;
}
srand(time(NULL));

do
{
sorteado = x + (rand() % (1 + (y - x)));
printf("Numero sorteado: %d\n", sorteado);
printf("\n----------------------------------------\n");
printf("Digite 0 para parar o sorteio e 1 par continuar:\n");
scanf(" %d", &p);
printf("\n----------------------------------------\n");
}
while(p != 0);
return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <gconio.h>
#include <time.h>

int main(){

int x;

do
{

textbackground(RED);
clrscr();
sleep(0.3);
textbackground(YELLOW);
clrscr();
sleep(2);
textbackground(GREEN);
clrscr();
sleep(3);
 }
while(1);

return 0;
}