Cálculos com sequências de números

1. Dada uma seqüência de números inteiros não-nulos, seguida por 0, imprimir seus quadrados.
#include <stdio.h>
int main() {
int numero, /* usada para leitura da sequencia */
quadrado; /* guarda o quadrado do numero lido */
printf("\n\tCalculo dos quadrados de uma sequencia de numeros\n");
printf("\nEntre com uma sequencia de numeros inteiros nao-nulos, seguida por 0:\n");
scanf("%d", &numero);
while (numero != 0) {
quadrado = numero * numero;
printf("O quadrado do numero %d e' %d\n", numero, quadrado);
scanf("%d", &numero);
return 0;
2. Dado um número inteiro positivo n, calcular a soma dos n primeiros números inteiros
positivos.
#include <stdio.h>
int main() {
int n, /* guarda o numero dado */
i, /* contador */
soma; /* guarda as somas parcias */
printf("\n\tCalculo da soma dos n primeiros inteiros positivos\n");
/* Inicializacoes */
printf("\nDigite o valor de n: ");
scanf("%d", &n);
soma = 0;
i = 1;
/* Calculo da soma */
while (i <= n) {
soma = soma + i;
i = i + 1;
/* Escreve a resposta */
printf("A soma dos %d primeiros inteiros positivos e' %d\n", n, soma);
return 0;
/*
* SOLUCAO 2
*/
#include <stdio.h>
int main() {
soma; /* guarda as somas parcias */
printf("\n\tCalculo da soma dos n primeiros inteiros positivos\n");
scanf("%d", &n);
/* Calcula a soma */
soma = (n * (n + 1)) / 2;
/* Escreve a resposta */
printf("A soma dos %d primeiros inteiros positivos e' %d\n", n, soma);

return 0;
Dado um número inteiro positivo n, imprimir os n primeiros naturais ímpares.
Exemplo: Para n=4 a saída deverá ser 1,3,5,7
#include <stdio.h>
int main() {
int n, /* guardara o numero dado */
i, /* contador = quantidade de impares ja' impressos */
impar; /* usado para gerar a sequencia de numeros impares */
printf("\n\tGerador de numeros impares\n");
scanf("%d", &n);
i = 0;
impar = 1;
printf("Os %d primeiros impares sao:\n", n);
while (i < n) {
printf ("%d\n", impar);
impar = impar + 2; /* vai para o proximo impar */
i = i + 1;
return 0;
4. Dados um inteiro x e um inteiro não-negativo n, calcular x n.
#include <stdio.h>
int main() {
int x, /* base */
n, /* expoente */
potencia, /* guarda as potencias parciais */
contador;
printf("\n\tCalculo de potencias\n");
printf("\nDigite um numero inteiro: ");
scanf("%d", &x);
printf("Digite um numero um inteiro nao-negativo: ");
scanf("%d", &n);
potencia = 1;
contador = 0;
/* Calculo da potencia */
while (contador != n) {
potencia = potencia * x;
contador = contador + 1;
printf("\nO valor de %d elevado a %d: %d\n", x, n, potencia);
return 0;
Dados o número n de alunos de uma turma de Introdução aos Autômatos a Pilha (MAC 414)
e suas notas da primeira prova, determinar a maior e a menor nota obtidas por
essa turma (Nota máxima = 100 e nota mínima = 0).
#include <stdio.h>
int main() {
int n, /* guarda o numero de alunos */
nota, /* usada para a leitura das notas */
contador, /* numero de notas ja' lidas */
notamaior, /* guarda a maior nota */

notamenor; /* gurada a menor nota */
printf("\n\tCalculo de maior e menor nota de uma turma\n");
printf("\nDigite o numero de alunos: ");
scanf("%d", &n);
/* inicializacoes */
contador = 0;
notamaior = 0;
notamenor = 100;
while (contador < n) {
printf("Digite uma nota (0 a 100): ");
scanf("%d", ¬a);
if (notamaior < nota)
notamaior = nota;
if (notamenor > nota)
notamenor = nota;
printf("A maior nota obtida foi: %d\n", notamaior);
printf("A menor nota obtida foi: %d\n", notamenor);
return 0;
Dado um inteiro não-negativo n, determinar n!
#include <stdio.h>
int main() {
contador,
fatorial;
printf("\n\tCalculo do fatorial de um numero\n");
printf("\nDigite um inteiro nao-negativo: ");
scanf("%d", &n);
fatorial = 1;
contador = 2;
while (contador <= n) {
fatorial = fatorial * contador;
printf("O valor de %d!: %d\n", n, fatorial);
return 0;
/*
* SOLUCAO 2: usa o comando for e calcula 1*2*3*...*(n-1)*n
* nessa ordem.
*/
#include <stdio.h>
int main()
i,
nfat;
scanf("%d", &n);
nfat = 1;
for (i = 2; i <= n; i++)
{ /* as chave sao superfluas */
nfat = nfat * i;
printf("O valor de %d!= %d\n", n, nfat);
return 0;
/*
* SOLUCAO 3: usa o comando for e calcula 1*n*(n-1)*(n-2)...*2,
* nessa ordem.
*/
#include <stdio.h>
int main()
i,
nfat;
scanf("%d", &n);
nfat = 1;
for (i = n; i > 1; i--)
{ /* as chave sao superfluas */

nfat = nfat * i;
printf("O valor de %d!= %d\n", n, nfat);
return 0;
Dados n e dois números inteiros positivos i e j diferentes de 0, imprimir em ordem crescente os

n primeiros naturais que são múltiplos de i ou de j e ou de ambos.
Exemplo: Para n = 6 , i = 2 e j = 3 a saída deverá ser : 0,2,3,4,6,8.
#include <stdio.h>
int main()
int i, j, n, /* dados de entrada */
mult, /* candidato a multiplo */
cont; /* conta quantos multiplos foram impressos */
printf("\n\tCalculo dos n primeiros multiplos de i ou de j\n");
printf("\nDigite o numero de multiplos a serem impressos: ");
scanf("%d", &n);
printf("Digite os dois numeros: ");
scanf("%d %d", &i, &j);
mult = 0;
cont = 0;
printf("Os %d primeiros multiplos de %d ou de %d sao:", n, i, j);
while (cont < n)
/* verifica se mult e' multiplo de i ou j */
if (mult%i == 0 || mult%j == 0)
{
printf(" %d", mult);
cont = cont + 1;;
/* vamos para o proximo candidato */
mult = mult + 1; /* Hmmm, podia ter escrito mult++; */
printf("\n"); /* tire esta linha e veja a diferenca na saida*/
return 0;
Dizemos que um número natural é triangular se ele é produto de três números naturais
consecutivos.
Exemplo: 120 é triangular, pois 4.5.6 = 120.
Dado um inteiro não-negativo n, verificar se n é triangular.
#include <stdio.h>
int main() {
int i, n;
printf("Digite o valor de n: ");
scanf("%d",&n);
/* for com comando vazio! */
for (i = 1; i*(i+1)*(i+2) < n; i++)
if (i*(i+1)*(i+2) == n)
printf("%d e' o produto %d*%d*%d\n", n, i, i+1, i+2);
else
printf("%d nao e' triangular\n", n);
return 0;
}
Dado um inteiro positivo n, verificar se n é primo
#include <stdio.h>
int main()
int n; /* candidato a primo */
int divisor; /* candidato a divisor de n */
int cont; /* conta o numero de divisores positivos de n */
printf("\n\tTeste de primalidade\n");
printf("\nDigite um inteiro: ");
scanf("%d", &n);
printf ("Candidato a primo = %d\n", n);
cont = 0;
/* os candidatos a divisores positivos de n sao 1,2,...,n */
for (divisor = 1; divisor <= n; divisor++)
if (n % divisor == 0)
cont++;
printf("O inteiro %d ", n);
if (cont == 2)
{ /* este par de chaves e' superfluo, mas ha' que goste ;-) */
printf("e' primo\n");
else
printf("nao e' primo\n");

}
return 0;
Dados dois números inteiros positivos, determinar o máximo divisor comum entre eles usando o
algoritmo de Euclides.#include <stdio.h>
int main() {
int anterior,
atual,
resto;
printf("Digite os dois inteiros positivos: ");
scanf("%d %d" , &anterior, &atual);
printf("MDC(%d,%d) = ", anterior, atual);
resto = atual % anterior; /* Por que nao 'resto = anterior % atual;'? */
while (resto != 0) {
resto = anterior % atual;
anterior = atual;
atual = resto;
printf("%d\n", anterior);
return 0;
Dizemos que um inteiro positivo n é perfeito se for igual à soma de seus divisores positivos
diferentes de n.
Exemplo: 6 é perfeito, pois 1+2+3 = 6.
Dado um inteiro positivo n, verificar se n é perfeito.
#include <stdio.h>
int main() {
int n, /* numero a ser verificado */

soma, /* soma dos valores dos divisores de n */
divisor; /* candidato a divisor de n */
printf("Digite um numero inteiro positivo: ");
scanf("%d", &n);
soma = 0;
for (divisor = 1; divisor < n; divisor++){
if (n % divisor == 0)
soma = soma + divisor;
if (n == soma)
printf("O numero %d e' perfeito\n", n);
else
printf("O numero %d nao e' perfeito\n", n);
return 0;
14. Um matemático italiano da idade média conseguiu modelar o ritmo de crescimento
da população de coelhos (1) através de uma seqüência de números naturais que passou
a ser conhecida como seqüência de Fibonacci (2).
O n-ésimo número da seqüência de Fibonacci Fn é dado pela seguinte fórmula
de recorrência:Faça um programa que, dado n, calcula Fn.
#include <stdio.h>
int main() {
int n,
fant, fatual, fprox, /* numeros de Fibonacci */
contador; /* indica qual número de Fibonacci esta' em fatual */
printf("Digite um numero n: ");

scanf("%d", &n);
fant = 0;
fatual = 1;
contador = 1;
while (contador < n) {
fprox = fatual + fant; /* proximo numero de Fibonacci */
fant = fatual;
fatual = fprox;
printf("Numero %d de Finobacci = %d\n", n, fatual);
return 0;
Dizemos que um número i é congruente módulo m a j se i % m = j % m.
Exemplo: 35 é congruente módulo 4 a 39, pois
35 % 4 = 3 = 39 % 4.
Dados inteiros positivos n, j e m, imprimir os n primeiros naturais congruentes a j módulo m.
#include <stdio.h>
int main() {
int n, m, j, /* dados de entrada */
i; /* percorre os naturais */
printf("Digite os valores de n, j e m: ");
scanf("%d %d %d", &n, &j, &m);
printf ("Os %d primeiros naturais congruentes a %d modulo %d sao: ",n, j, m);
for (i = 0; n != 0; i++){
if (i % m == j % m) {
printf("%d ", i);
n = n - 1;
printf("\n");
return 0;
/*
* SOLUCAO 2.
*/
#include <stdio.h>
int main() {
int n, m, j, /* dados de entrada */
c, /* numero congruente a j modulo m */
i; /* contador de números impressos */
printf("Digite os valores de n, j e m: ");
scanf("%d %d %d", &n, &j, &m);
printf ("Os %d primeiros naturais congruentes a %d modulo %d sao: ",n, j, m);
c = j;
for (i = 0; i < n; i++) {
printf("%d ", c);
c = c + m; /* passa para o proximo numero congruente a j modulo m */
printf("\n");
return 0;
16. Dado um número natural na base binária, transformá-lo para a base decimal.
Exemplo:
Dado 10010 a saída será 18, pois 1. 2 4 + 0. 2 3 + 0. 2 2 + 1. 2 1 + 0. 2 0 = 18.
/* Programa para converter da base 2 para a base 10 */
#include <stdio.h>
int main() {
int num, /* numero dado (na base 2) */
pot2, /* guardara uma potencia de 2 */
final; /* numero dado convertido para base 10 */
printf("Digite o numero a ser transformado da base 2 para a base 10: ");
scanf("%d", &num);
final = 0;
pot2 = 1;
printf("%d na base 10 e': ", num);
while (num != 0){
final = final + num % 10 * pot2; /* processa um digito binario */
num = num / 10;
pot2 = pot2 * 2;
printf("%d\n", final);
return 0;
}
17. Dado um número natural na base decimal, transformá-lo para a base binária.
Exemplo: Dado 18 a saída deverá ser 10010.
/* Programa para converter da base 10 para a base 2 */
#include <stdio.h>
int main() {
int num, /* numero dado (na base decimal) */
bin, /* numero dado convertido para base 2 */
aux, /* auxiliar */
dig, /* guardara cada um dos digitos binarios */
pot; /* potencia de 10 */
printf("Digite um numero natural: ");
scanf("%d", &num);
aux = num;
bin = 0;
pot = 1;
while (aux > 0) {
dig = aux % 2; /* proximo digito binario menos significativo */
aux = aux / 2; /* remove esse digito do que resta */
bin = bin + dig * pot; /* adiciona o digito como o mais significativo */
pot = pot * 10;
printf("O numero %d escrito na base binaria: %d\n", num, bin);
return 0;
Dados três números naturais, verificar se eles formam os lados de um triângulo retângulo./*
Programa que testa se tres numeros sao os lados de um triangulo retangulo */
#include <stdio.h>
int main() {
int a, b, c, /* dados de entrada */
aux; /* auxiliar para fazer a troca */
printf("Digite tres numeros naturais: ");
scanf("%d", &a);
scanf("%d", &b);
scanf("%d", &c);
/* coloca o maior dos numeros dados no a */
if (b > a){
aux = a;
a = b;
b = aux;
if (c > a){
aux = a;
a = c;
c = aux;
/* verifica se b e c sao catetos de um triangulo com a de hipotenusa */
if (a * a == b * b + c * c)
printf("O triangulo é retangulo\n");
else
printf("O triangulo não é retangulo\n");
return 0;
Dados três números, imprimi-los em ordem crescente.
#include <stdio.h>
int main()
int n1, n2, n3; /* dados de entrada */
printf("Digite tres numeros: ");
scanf("%d %d %d", &n1, &n2, &n3);
/* Existem 6 possiveis ordens para imprimior os numeros lidos */
if (n1 <= n2 && n2 <= n3)
printf("A ordem crescente: %d %d %d\n", n1, n2, n3);
else if (n1 <= n3 && n3 <= n2)
else if (n2 <= n1 && n1 <= n3)
else if (n2 <= n3 && n3 <= n1)
else if (n3 <= n1 && n1 <= n2)
else /* n3 <= n2 && n2 < n1 */
}
return 0;
/*
* SOLUCAO 2.
*/
#include <stdio.h>
int main() {
scanf("%d", &n1);
scanf("%d", &n2);
scanf("%d", &n3);
if (n3 > n1)
if (n1 > n2)
else if (n2 < n3)
if (n1 > n2)
if (n2 > n3)
else if (n3 < n1)
if (n1 < n2)
if (n3 < n1)
else if (n3 < n2)

return 0;
/*
* SOLUCAO 3. Igual a solucao 2 com alguns parenteses superfluos que
* devem ajudar a leitura do programa (evitar ambiguida).
*/
#include <stdio.h>
int main()
scanf("%d", &n1);
scanf("%d", &n2);
scanf("%d", &n3);
if (n3 > n1)
if (n1 > n2)
else
if (n2 < n3)
}
if (n1 > n2)
if (n2 > n3)
else
if (n3 < n1)
if (n1 < n2)
if (n3 < n1)
else
if (n3 < n2)
return 0;
/*
* SOLUCAO 4. Parecida com a solucao 1. Usa condicoes simples,
* ou seja, sem && e ||.
*/
#include <stdio.h>
int main()
scanf("%d %d %d", &n1, &n2, &n3);
/* Existem 6 possiveis ordens para imprimior os numeros lidos */
if (n1 <= n2)
{ /* n1 <= n2 */
if (n2 <= n3)
{ /* n1 <= n2 e n2 <= n3 */
else
{ /* n1 <= n2 e n3 < n2 */
if (n1 <= n3)
{ /* n1 <= n3 e n3 < n2 */
else
{ /* n3 < n1 e n1 <= n2 */
else
{ /* n2 < n1 */
if (n1 <= n3)
{ /* n2 < n1 e n1 <= n3 */
else
{ /* n2 < n1 e n3 < n1 */
if (n2 <= n3)
{ /* n2 <= n3 e n3 < n1 */
else
{ /* n3 < n2 e n2 < n1 */
return 0;
Dados n e uma seqüência de n números inteiros, determinar quantos segmentos de números

iguais consecutivos compõem essa seqüência.
Exemplo: A seguinte seqüência é formada por 5 segmentos de números iguais: 5, 2, 2, 3, 4,

4, 4, 4, 1, 1
/* Programa que conta segmentos de numeros iguais */
#include <stdio.h>
int main() {
int n, /* comprimento da sequencia */
i, /* contador de numeros da sequencia lidos */

atual, /* ultimo numero da sequencia lido */
anterior, /* numero anterior da sequencia */
cont; /* quantidade de segmentos de numeros iguais na sequencia */
printf("Digite o numero de elementos da sequencia: ");
scanf("%d",&n);
printf("Digite uma sequencia com %d numeros inteiros: ", n);
scanf("%d", &anterior); /* anterior comeca com o primeiro da sequencia */
cont = 1; /* inicialmente temos um segmento */
for (i = 2; i <= n; i++) {
scanf("%d", &atual); /* proximo da sequencia */
if (atual != anterior){
cont = cont + 1; /* comecou um novo segmento de numeros iguais */
anterior = atual;
printf("Quantidade de segmentos de numeros iguais da sequencia = %d\n", cont);
return 0;
22. (POLI 89) Dados n e uma seqüência de n números inteiros, determinar o comprimento de
um segmento crescente de comprimento máximo.
Exemplos:
Na seqüência 5, 10, 3, 2, 4, 7, 9, 8, 5 o comprimento do segmento crescente máximo é 4.
Na seqüência 10, 8, 7, 5, 2 o comprimento de um segmento crescente máximo é 1.
/* Programa que conta o numero de segmentos crescentes */
#include <stdio.h>
int main() {
int n, /* comprimento da sequencia */
num, /* um numero da sequencia */
ant, /* numero anterior da sequencia */
comp, /* comprimento do segmento sendo analisado */
compmax, /* comprimento do segmento crescente maximo */
i; /* quantidade de números da sequencia lidos */
printf("Digite o numero de elementos da sequencia: ");
scanf("%d", &n);
printf("Digite uma sequencia com %d numeros inteiros: ", n);
scanf("%d", &ant); /* ant comeca com o primeiro da sequencia */
comp = 1;
compmax = 1;
for (i = 1; i < n; i++) {
scanf("%d", &num);
if (num > ant) {
comp = comp + 1;
if (compmax < comp)
compmax = comp;
else
comp = 1; /* comecou um novo segmento crescente */
ant = num;
printf("O comprimento do segmento crescente maximo: %d\n", compmax);
return 0;
Dizemos que um número natural n é palíndromo (3) se
o 1º algarismo de n é igual ao seu último algarismo,

o 2º algarismo de n é igual ao penúltimo algarismo,
e assim sucessivamente.
Exemplos:
567765 e 32423 são palíndromos.
567675 não é palíndromo.
Dado um número natural n > 10 , verificar se n é palíndrome.
/* Programa que verifica se um numero é palindrome */
#include <stdio.h>
int main() {
int num, /* numero dado */
aux, /* guarda o pedaco do numero que resta inverter */
reverso; /* guarda o numero de tras para frente */
printf("Digite um natural: ");
scanf("%d", &num);
aux = num;
reverso = 0;
while (aux != 0) {
reverso = reverso * 10 + aux % 10; /* acrescenta mais um digito a direita */
aux = aux / 10; /* joga fora esse digito */
if (reverso == num)
printf("%d e' palindrome\n", num);
else
printf("%d nao e' palindrome\n", num);
return 0;
}
2. Dado um número inteiro positivo n, determinar todos os inteiros entre 1 e n que são
comprimento da hipotenusa de um triângulo retângulo com catetos inteiros.
#include <stdio.h>
#define VERDADEIRO 1
#define FALSO 0
int main() {
int n, cateto1, cateto2, hipotenusa;
int achou;
printf("Digite o comprimento maximo da hipotenusa: ");
scanf("%d" , &n);
for (hipotenusa = 1; hipotenusa <= n; hipotenusa++) {
achou = FALSO;
/* testa todos os candidatos a cateto */
for (cateto1 = 1; cateto1 < hipotenusa && !achou; cateto1++) {
cateto2 = cateto1; /* cateto1 e' o menor cateto */
while (cateto1*cateto1 + cateto2*cateto2 < hipotenusa*hipotenusa)
cateto2++;
if (cateto1*cateto1 + cateto2*cateto2 == hipotenusa*hipotenusa){
printf("hipotenusa = %d, catetos %d e %d\n", hipotenusa, cateto1, cateto2);
achou = VERDADEIRO;
return 0;
ados dois naturais m e n determinar, entre todos os pares de números naturais (x,y) tais que x <
m e y < n, um par para
o qual o valor da expressão xy - x2 + y seja máximo e calcular também esse máximo.

#include <stdio.h>
int main()
int n, m; /* determinam o intervalo da funcao */
int x, y; /* usados para o calculo do maximo */
int valor; /* guarda x*y - x*x + y */
int xmax, ymax; /* argumentos que maximizam a funcao */
int valormax; /* guarda xmax*ymax - xmax*xmax + ymax */
printf("Maximizo x*y - x*x + y, onde 0 <= x <= n e 0 <= y <= m.\n");
/* leia os limitantes do intervalo */
printf("Entre com n e m: ");
scanf ("%d %d", &n, &m);
xmax = ymax = 0;
valormax = 0; /* valormax == xmax*ymax - xmax*xmax + ymax */
/* testa tos os possiveis valores da funcao */
for (x = 0; x <= n; x++)
for (y = 0; y <= m; y++)
valor = x*y - x*x + y;
if (valor > valormax)
valormax = valor;
xmax = x;
ymax = y;
}
printf("Valor maximo da funcao = %d foi alcancado com x = %d e y = %d\n",
valormax, xmax, ymax);
return 0;
5. Sabe-se que um número da forma n3 é igual a soma de n ímpares consecutivos.
Exemplo: 13= 1, 23= 3+5, 33= 7+9+11, 43= 13+15+17+19,...
Dado m, determine os ímpares consecutivos cuja soma é igual a n3 para n assumindo valores de
1 a m.
#include <stdio.h>
int main() {
int n, m, i, inicio, soma;
printf("Digite o valor de m: ");
scanf("%d", &m);
for (n = 1; n <= m; n++) {
soma = 0;
for (inicio = 1; soma != n * n * n; inicio = inicio + 2) {
soma = 0;
for (i = 0; i < n; i++)
soma = soma + inicio + 2 * i;
inicio = inicio - 2;
printf("%d*%d*%d = %d", n, n, n, inicio);
for (i = 1; i < n; i++)
printf("+%d", inicio+2*i);
printf("\n");
return 0;
}
/*
* SOLUCAO 2
*/
#include <stdio.h>
int main() {
int m, /* dado de entrada */
n, i,
inicio; /* primeiro dos impares de uma sequencia que soma n^3 */
printf("Digite o valor de m: ");
scanf("%d", &m);
inicio = 1;
for (n = 1; n <= m; n++) {
printf("%d*%d*%d = %d", n, n, n, inicio);
for (i = 1; i < n; i++)
printf("+%d", inicio + 2 * i);
inicio = inicio + 2 * n; /* inicio da proxima sequencia */
printf("\n");
return 0;
Dado um número inteiro positivo, determine a sua decomposição
em fatores primos calculando também a multiplicidade de cada fator.
#include <stdio.h>
int main()
int n; /* numero dado */

int fator; /* candidato a fator do numero dado */
int mult; /* multiplicidade de fator */
printf("Decomponho um numero dado em fatores primos.\n");
printf("Entre com o numero (> 1) a ser decomposto: ");
scanf("%d", &n);
printf("Decomposicao de %d em fatores primos:\n", n);
fator = 2;
while (n > 1)
mult = 0;
while (n % fator == 0)
mult ++;
n = n / fator;
if (mult != 0)
printf(" fator %d multiplicidade %d\n", fator, mult);
fator++;
return 0;
Dados um inteiro positivo n e uma seqüência de n inteiros positivos, determinar o máximo

divisor comum a todos eles.
SOLUCAO 1: o programa usa a igualdade mdc(a,b,c) == mdc(mdc(a,b),c).
* Em cada iteracao o mdc de dois numeros, digamos num1 e num2,
* e' encontrado examinando-se os numero
* 1, 2, 3, ..., min(num1,num2)
* nessa ordem.
*/
#include <stdio.h>
int main()
int n; /* no. de elementos na sequencia */
int i; /* contador de numeros lidos */
int mdc; /* maximo divisor comum dos numeros lidos */
int numero; /* guarda um numero da sequencia */
int novo_mdc; /* candidato a novo mdc */
int divisor; /* usado para encontrar o novo mdc */
printf("Determino mdc de n (>0) numeros positivos.\n");
/* leia o tamanho da sequecia */
printf("Entre com n: ");
scanf ("%d", &n);
/* leia o 1o. numero da sequencia */
printf("Entre com o 1o. numero da sequencia: ");
scanf ("%d", &mdc);
i = 1;
while (i < n)
printf("Entre com o %do. numero da sequencia: ", i+1);
scanf ("%d", &numero);
i = i + 1; /* mais um numero foi lido */
/* calcule o max divisor comum de mdc e numero */
divisor = 1;
while (divisor <= mdc && divisor <= numero)
{
if (mdc % divisor == 0 && numero % divisor == 0)
novo_mdc = divisor;
divisor = divisor + 1;
/* atualize o mdc dos numeros lidos */
mdc = novo_mdc;
printf("MDC = %d\n", mdc);
return 0;
/*
* SOLUCAO 2: identica a anterior, apenas troca os while's por for's.
*/
#include <stdio.h>
int main()

scanf ("%d", &n);
scanf ("%d", &mdc);
for (i = 1; i < n; i++)
for (divisor = 1; divisor <= mdc && divisor <= numero; divisor++)
novo_mdc = divisor;
mdc = novo_mdc;
return 0;
/*
* SOLUCAO 3: identica a solucao anterior. Usa a variavel pcomo contador
* de numero a serem lidos.
*
*/
#include <stdio.h>
int main()
int divisor; /* usado para encontra o novo mdc */
scanf ("%d", &n);
printf("Entre com um numero da sequencia: ");
scanf ("%d", &mdc);
n = n - 1;
while (n > 0)
printf("Entre com um numero da sequencia: ");
n = n - 1; /* mais um numero foi lido */
divisor = 1;
while (divisor <= mdc && divisor <= numero)

{
novo_mdc = divisor;
divisor = divisor + 1;
mdc = novo_mdc;
return 0;
#include <stdio.h>
int main()
scanf ("%d", &n);
scanf ("%d", &mdc);
for (i = 1; i < n; i++)

{
for (divisor = mdc; mdc % divisor != 0 || numero % divisor != 0; divisor--);
mdc = divisor;
return 0;
Dizemos que uma seqüência de inteiros positivos é k-alternante se for composta
alternadamente por segmentos de números pares de tamanho k e segmentos de números

ímpares de tamanho k.
Exemplos:s
A seqüência 1 3 6 8 9 11 2 4 1 7 6 8 é 2-alternante.
A seqüência 2 1 4 7 8 9 12 é 1-alternante.
A seqüência 4 2 3 1 6 4 2 9 3 não é alternante.
A seqüência 1 3 5 é 3-alternante.
Dado n > 1 e uma seqüência com n inteiros, verificar se existe um inteiro k > 1 tal que a
seqüência
é k-alternante. Dê como saída também o valor de k caso a seqüência seja alternante.
#include <stdio.h>
#define FALSE 0
#define TRUE 1
int main()
{
int numero; /* usado para ler a sequencia */
int paridade; /* indica a paridade do segmento (0 = par, 1 = impar) */
int k; /* candidado a grau da alternacia */
int kaux; /* tamanho do segmento corrente */
int k_alternante; /* indica se a sequencia e' ou nao k-alternate */
printf("Determino se uma sequencia de n (>0) inteiros e k-alternante.\n");
scanf ("%d", &n);
/* determina candidato a k e paridade do primeiro 1o. segmento */
paridade = numero % 2;
k = 1;
i = 1;
while (i < n && numero % 2 == paridade)
if (numero % 2 == paridade)
k = k + 1;
/* neste ponto vale que k e' o comprimento do 1o. segmento de
* mesma paridade.
*/
printf("candidato a k = %d\n", k);
/* a sequencia e' k-alternante ate que se prove o contrario */
k_alternante = TRUE;
while (i < n)
/* ajuste a alternancia da paridade */
paridade = (paridade + 1) % 2;
kaux = 1;
while (i < n && numero % 2 == paridade)
if (numero % 2 == paridade)
kaux = kaux + 1;
if (kaux != k)
k_alternante = FALSE;
/* o ultimo elemento merece um cuidado especial... */
if (numero % 2 != paridade && k != 1)
k_alternante = FALSE;
}
if (k_alternante == TRUE)
printf("A sequencia e %d-alternante\n", k);
else
printf("A sequencia nao e' k-alternante\n");
return 0;
Exercícios com Reais
1. Uma pessoa aplicou um capital de x complexos (1) a juros mensais

de z durante 1 ano. Determinar o montante de cada mês durante este
período
#include <stdio.h>
int main() {
float
inicial, /* capital aplicado */
juros, /* taxa de juros */
fator, /* taxa de correcao */
capital; /* capital corrente */
int
mes; /* contador de meses */
printf("Digite o valor do capital aplicado: ");

scanf("%f", &inicial);
printf("Digite o valor dos juros (em %%): ");

scanf("%f", &juros);
fator = 1 + juros / 100;
capital = inicial;
printf("\nValor aplicado: R$%.2f\n", inicial);

for (mes = 1; mes <= 12; mes++){
capital *= fator;
printf("Valor ao final do mes %2d: R$%.2f\n", mes, capital);
}
return 0;
}
2. Dado um natural n, determine o número harmônico Hn definido por:
/* Programa para calcular o numero harmonico de uma certa ordem */
#include <stdio.h>
int main() {
float Hn; /* numero harmonico de ordem n */
int n, k;

scanf("%d", &n);
Hn = 0;
for (k = 1; k <= n; k++)

Hn += (float)1/k;
printf("Valor de H_%d: %f\n", n, Hn);
return 0;
}
3. Os pontos (x,y) que pertencem à figura H (abaixo) são tais

que x > 0, x > 0 e x2 + y2 < 1.
Dados n pontos reais (x,y), verifique se cada ponto pertence ou não a H.
/* Programa que verifica a pertinencia de um ponto a uma certa regiao

*/
#include <stdio.h>
int main() {
int i, n;
float x, y;
printf("Digite o numero de pontos: ");

scanf("%d", &n);
for (i = 0; i < n; i++){

printf("Digite as coordenadas de um ponto: ");
scanf("%f %f", &x, &y);
if (x >= 0 && y >= 0 && x*x + y*y <= 1)
printf("O ponto (%f,%f) pertence a regiao.\n", x, y);
else
printf("O ponto (%f,%f) nao pertence a regiao.\n", x, y);
}
return 0;
}
5. Dados números reais a, b e c, calcular as raízes de uma equação do 2o grau

da forma ax2 + bx + c = 0. Imprimir a solução em uma das seguintes formas:
a.DUPLA b.REAIS DISTINTAS c.COMPLEXAS
raiz raiz 1 parte real
raiz 2 parte imaginária
Observação: Em C, para extrair raiz quadrada use a

função sqrt (coloque #include <math.h> antes do main).
#include <stdio.h>
#include <math.h>
int main() {
float
a, b, c, /* coeficientes da equacao */
delta, rdelta,
parte_real, /* parte real das raizes */
parte_imaginaria, /* parte imaginaria das raizes */
raiz1, raiz2; /* raizes, caso sejam reais */
int
raizes; /* indica de que tipo sao as raizes */
printf("\n\tCalculo das raizes da equacao ax^2+bx+c=0\n");

printf("\nDigite os numeros a, b e c: ");
scanf("%f %f %f",&a, &b, &c);
/* calculo do delta da equacao */

delta = b*b-4*a*c;
if (delta > 0) {
/* a equacao tem raizes reais */
rdelta = sqrt(delta);
raiz1 = (-b+rdelta)/(2*a);
raiz2 = (-b-rdelta)/(2*a);
printf("Raizes reais\n");
printf("Raiz 1: %f\n", raiz1);
printf("Raiz 2: %f\n", raiz2);
}
else if (delta < 0) {
/* a equacao tem raizes complexas */
rdelta = sqrt(-delta);
parte_real = -b/(2*a);
parte_imaginaria = delta/(2*a);
printf("Raizes complexas\n");
printf("Parte real: %f\n", parte_real);
printf("Parte imaginaria: %f\n", parte_imaginaria);
}
else {
/* a equacao tem raiz dupla */
printf("Raiz dupla: %f\n", -b/(2*a));
}
return 0;
}
8. Para n alunos de uma determinada classe são dadas as 3 notas das provas.
Calcular a média aritmética das provas de cada aluno, a média da classe, o
número de aprovados e o número de reprovados (critério de aprovação:
média maior ou igual a cinco).
#include <stdio.h>
int main() {
int n, i, Aprovados, Reprovados;
float Nota1, Nota2, Nota3, Media, MediaDaClasse;
printf("Digite o numero de alunos: ");

scanf("%d", &n);
Aprovados = 0;
Reprovados = 0;
MediaDaClasse = 0.0;
for (i = 1; i <= n; i++) {

printf("Digite as 3 notas do aluno %d: ", i);
scanf("%f", &Nota1);
Media = (Nota1 + Nota2 + Nota3) / 3;
printf("A media do aluno %d foi %f\n", i, Media);
MediaDaClasse = MediaDaClasse + Media;
if (Media >= 5.0)
Aprovados = Aprovados + 1;
else
Reprovados = Reprovados + 1;
}
MediaDaClasse = MediaDaClasse / n;
printf("O numero de alunos aprovados foi %d\n", Aprovados);
printf("O numero de alunos reprovados foi %d\n", Reprovados);
printf("A media da classe foi %f\n", MediaDaClasse);
return 0;
}
Dado um inteiro positivo n, calcular e imprimir o valor da seguinte soma:
#include <stdio.h>
int main() {
float somaerrada, soma;
int i, n;

scanf ("%d", &n);
somaerrada = 0;
soma = 0;
for (i = 0; i < n; i++){
somaerrada = somaerrada + (1+i)/(n-i);
soma = soma + (float)(1+i)/(n-i);
}
printf("Valor da soma = %f\n", soma);

printf("Valor errado, fazendo como soma de inteiros = %f\n",
somaerrada);
return 0;
}
12. Faça um programa que calcula a soma

pelas seguintes maneiras:
 adição dos termos da direita para a esquerda;

 adição dos termos da esquerda para a direita;
 adição separada dos termos positivos e dos termos negativos da
esquerda para a direita;
 adição separada dos termos positivos e dos termos negativos da direita
para a esquerda.
#include <stdio.h>
#define TAMANHO 1000
int main() {
float soma1, soma2, soma3, soma4;
float negativos, positivos;
int i, sinal;
/* Soma da direita para a esquerda */

soma1 = 0;
sinal = -1;
for (i = TAMANHO; i > 0; i--){
soma1 = soma1 + (float) sinal/i;
sinal = -sinal;
}
/* Soma da esquerda para a direita */

soma2 = 0;
sinal = 1;
for (i = 1; i <= TAMANHO; i++){
soma2 = soma2 + (float) sinal/i;
sinal = -sinal;
}
/* adição separada dos termos positivos e dos */

/* termos negativos da esquerda para a direita */
negativos = 0;
positivos = 0;
for (i = 1; i <= TAMANHO; i++)

if (i % 2 == 1)
positivos += (float) 1/i;
else
negativos += (float) 1/i;
soma3 = positivos - negativos;
/* Adição separada dos termos positivos e dos */

/* termos negativos da direita para a esquerda */
negativos = 0;
positivos = 0;
for (i = TAMANHO; i > 0; i--)

if (i % 2 == 1)
positivos += (float) 1/i;
else
negativos += (float) 1/i;
soma4 = positivos - negativos;
printf("Primeira soma = %.20g\n", soma1);
printf("Segunda soma = %.20g\n", soma2);
printf("Terceira soma = %.20g\n", soma3);
printf("Quarta soma = %.20g\n", soma4);
return 0;
}
Exercícios com Vetores

1. Dada uma seqüência de n números, imprimi-la na ordem inversa à da
leitura.
#include <stdio.h>
#define MAX 100
int main() {
int n, i, v[MAX];
printf("Digite o comprimento da seqüência: ");

scanf("%d", &n);
printf("Digite uma seqüência com %d números inteiros: ", n);

for (i = 0; i < n; i++)
scanf("%d", &v[i]);
for (i = n-1; i >= 0; i--)
printf("%d ", v[i]);
printf("\n");
return 0;
}
2. Deseja-se publicar o número de acertos de cada aluno em uma prova em

forma de testes. A prova consta de 30 questões, cada uma com cinco
alternativas identificadas por A, B, C, D e E. Para isso são dados:
o cartão gabarito;
o número de alunos da turma;
o cartão de respostas para cada aluno, contendo o seu número e suas
respostas.
#include <stdio.h>
int main() {
int n, /* numero de alunos na turma */
i,
aluno, /* indica o aluno corrente */
pontos; /* numero de pontos do aluno corrente */
char gabarito[30], /* gabarito da prova */
resp[30]; /* respostas do aluno corrente */
printf("Digite o numero de alunos: ");

scanf("%d", &n);
printf("Digite o gabarito da prova: ");

for (i = 0; i < 30; i++)
scanf(" %c", &gabarito[i]);
/* O espaco em branco antes do %c e' importante.
Ele evita que o return digitado depois do n seja
interpretado como a primeira "letra" do gabarito */
for (aluno = 1; aluno <= n; aluno++) {
pontos = 0;
printf("Digite as respostas do aluno %d: ", aluno);
for (i = 0; i < 30; i++) {
scanf(" %c", &resp[i]); /* atencao para o espaco em branco */
if (resp[i] == gabarito[i])
pontos = pontos + 1;
}
printf("O aluno %d fez %d pontos\n", aluno, pontos);
}
return 0;
}
Dados dois vetores x e y, ambos com n elementos, determinar o produto

escalar (1) desses vetores.
#include <stdio.h>
#define MAX 10
int main() {
int i, n;
float prod, x[MAX], y[MAX];
printf("Digite o tamanho dos vetores: ");

scanf("%d", &n);
printf("Digite os componentes do vetor x: ");
for (i = 0; i < n; i++)
scanf("%f", &x[i]);
printf("Digite os componentes do vetor y: ");
for (i = 0; i < n; i++)
scanf("%f", &y[i]);
prod = 0;
for (i = 0; i < n; i++)
prod = prod + x[i] * y[i];
printf("Produto escalar desses vetores: %f\n", prod);
return 0;
}
Dada uma seqüência de n números reais, determinar os números que

compõem a seqüência e o número de vezes que cada um deles ocorre na
mesma.
Exemplo: n = 8
Seqüência: -1.7, 3.0, 0.0, 1.5, 0.0, -1.7, 2.3, -1,7
Saída: -1.7 ocorre 3 vezes
3.0 ocorre 1 vez
0.0 ocorre 2 vezes
1.5 ocorre 1 vez
2.3 ocorre 1 vez
#include <stdio.h>
#define MAX 100
int main() {
int n, /* numero de elementos da sequencia */
i, j,
comp, /* comprimento corrente do vetor seq */
conta, vezes;
float seq[MAX];
printf("\nDigite o numero de elementos da sequencia: ");

scanf("%d", &n);
printf("Digite uma sequencia de %d numeros reais: ", n);
for (i = 0; i < n; i++)
scanf("%f", &seq[i]);
for (i = 0; i < n; i++) {
/* conta o numero de vezes que seq[i] aparece no vetor a partir da
posição i */
vezes = 1;
j = i + 1;
while (j < n)
if (seq[j] != seq[i])
j++;
else {
vezes++;
/* quando repete, remove */
n--;
seq[j] = seq[n];
}
printf("%f ocorre %d vezes\n", seq[i], vezes);
}
return 0;
}
/*
* SOLUCAO 2
*/
#include <stdio.h>
#define MAX 100
int main() {
int n, /* comprimento da sequencia de entrada

*/
i, j,
conta[MAX], /* contador de repeticoes de cada numero da
sequencia */
comp = 0; /* comprimento do vetor conta
*/
float seq[MAX]; /* sequencia de entrada sem repeticoes
*/
printf("\nDigite o comprimento da sequencia: ");

scanf("%d", &n);
printf("Digite uma sequencia de %d numeros reais: ", n);

for (i = 0; i < n; i++) {
scanf("%f", &seq[comp]);
/* procura esse numero no vetor seq a partir do inicio */
for (j = 0; seq[j] != seq[comp]; j++); /* comando vazio! */
if (j == comp) {
/* se o numero nunca tinha aparecido */
conta[comp] = 1;
comp++;
}
else
conta[j]++;
}
/* imprime o resultado */
for (j = 0; j < comp; j++)
printf("O numero %f aparece %d vezes na sequencia.\n", seq[j],
conta[j]);
return 0;
}
Dada uma seqüência x1, x2, ..., xk de números inteiros, verifique se existem
dois segmentos consecutivos iguais nesta seqüência, isto é, se
existem i e m tais que:
xi, xi+1,..., xi+m-1 = xi+m, xi+m+1,..., xi+2m-1
Imprima, caso existam, os valores de i e m.
Exemplo: Na seqüência 7, 9, 5, 4, 5, 4, 8, 6 existem i=3 e m=2.

#include <stdio.h>
#define MAX 100

#define FALSE 0
#define TRUE 1
int main() {
int n, /* comprimento da sequencia dada */

i, j,
m, /* comprimento do segmento repetido */
seq[MAX],
achou;
printf("Digite o comprimento da sequencia: ");

scanf("%d", &n);
printf("Digite uma sequencia de %d inteiros: ", n);
for (i = 0; i < n; i++)
scanf("%d", &seq[i]);
achou = FALSE;
for (m = 1; !achou && m <= n/2; m++) {

/* procura dois segmentos iguais de comprimento m consecutivos */
for (i = 0; !achou && i <= n-2*m; i++) {
/* i indica o inicio do primeiro segmento */
/* testa se os dois segmentos sao de fato iguais */
achou = TRUE;
for (j = 0; achou && j < m; j++)
if (seq[i+j] != seq[i+m+j])
achou = FALSE;
}
}
if (achou) {
printf("Sim, existem dois segmentos iguais consecutivos.\n");
printf("Tome, por exemplo, i = %d e m = %d.\n", i-1, m-1);
}
else
printf("Nao, nao existem dois segmentos iguais consecutivos.\n");
return 0;
}
Dadas duas matrizes reais Amxn e Bnxp, calcular o produto de A por B.
#include <stdio.h>
#define MAX 100
int main() {
int m, n, /* dimensoes da matriz A */
nb, p, /* dimensoes da matriz B */
i, j, k;
float A[MAX][MAX], B[MAX][MAX], C[MAX][MAX];
printf("Digite as dimensoes (mXn) da matriz A: ");

scanf("%d", &m);
scanf("%d", &n);
printf("Digite a matriz A:\n");
for (i = 0; i < m; i++)
for (j = 0; j < n; j++)
scanf("%f", &A[i][j]);
printf("Digite as dimensoes (nXp) da matriz B: ");

scanf("%d", &nb);
scanf("%d", &p);
if (nb != n)
printf("Nao existe o produto da matriz A por B!!");
else {
printf("Digite a matriz B:\n");
for (i = 0; i < n; i++)
for (j = 0; j < p; j++)
scanf("%f", &B[i][j]);
/* calculo do produto */
for (i = 0; i < m; i++)
for (j = 0; j < p; j++){
C[i][j] = 0;
for (k = 0; k < n; k++)
C[i][j] = C[i][j] + A[i][k] * B[k][j];
}
/* impressao do resultado */
printf("Matriz A X B: \n");
for (i = 0; i < m; i++) {
for (j = 0; j < p; j++)
printf("%f ", C[i][j]);
printf("\n");
}
}
return 0;
}
9. (MAT 89) Um jogo de palavras cruzadas pode ser representado por uma
matriz Amxn onde cada posição da matriz corresponde a um quadrado do jogo,
sendo que 0 indica um quadrado branco e -1 indica um quadrado preto.
Indicar na matriz as posições que são início de palavras horizontais e/ou
verticais nos quadrados correspondentes (substituindo os zeros), considerando
que uma palavra deve ter pelo menos duas letras. Para isso, numere
consecutivamente tais posições.
Exemplo: Dada a matriz

A saída deverá ser
#include <stdio.h>
#define MAX 102 /* Tamanho maximo do jogo + 2 para a moldura */

#define VERD 1
#define FALSO 0
int inicio(int A[][MAX], int i, int j);

/* prototipo da funcao inicio, declarada no fim do arquivo */
int main() {
int A[MAX][MAX], m, n;
int i, j, cont;
printf("Digite dimensoes do jogo: ");

scanf("%d %d", &m, &n);
/* Leitura da matriz */
printf("Digite a matriz linha por linha\n");
for (i = 1; i <= m; i++)
for (j = 1; j <= n; j++)
scanf("%d",&A[i][j]);
/* Preparacao de uma moldura para facilitar as contas */

for (j = 0; j <= n+1; j++){
A[0][j] = -1;
A[m+1][j]= -1;
}
for (i = 1; i <= m; i++){
A[i][0] = -1;
A[i][n+1] = -1;
}
/* Maos a obra */
cont=0;
for (i = 1; i <= m; i++)
for (j = 1; j <= n; j++)
if (inicio(A,i,j) == VERD){
cont++;
A[i][j] = cont;
}
/* Impressao do resultado */
printf("Matriz resultante:\n");
for (i = 1; i <= m; i++){
for (j = 1; j <= n; j++)
printf("%3d",A[i][j]);
printf("\n");
}
return 0;
}
int inicio(int A[][MAX], int i, int j) {
if (A[i][j] != -1 && ((A[i-1][j] == -1 && A[i+1][j] != -1) ||

(A[i][j-1] == -1 && A[i][j+1] != -1)))
return VERD;
else
return FALSO;
}
Exercícios com Funções - Parte I
1. Um número a é dito permutação de um número b se os dígitos

de a formam uma permutação dos dígitos de b.
Exemplo: 5412434 é uma permutação de 4321445, mas não é uma

permutação de 4312455.
Obs.: Considere que o dígito 0 (zero) não aparece nos números.
(a) Faça uma função contadígitos que dados um inteiro n e um inteiro d, 0 <
d < 9, devolve quantas vezes o dígito d aparece em n.
(b) Usando a função do item anterior, faça um programa que lê dois inteiros
positivos a e b e responda se a é permutação de b.
#include <stdio.h>
/* Parte (a) */
int contadigitos(int n, int d) {
int conta, resto;
conta = 0;
while (n != 0) {
resto = n % 10;
n = n/10;
if (resto == d)
conta++;
}
return conta;
}
/* Parte (b) */
int main() {
int a, b, d;
int perm; /* indicador de passagem: se perm == 1 e' permutacao */
printf("Digite dois inteiros: ");
scanf("%d %d",&a,&b);
perm = 1;
for (d = 1; d <= 9; d++)

if (contadigitos(a,d) != contadigitos(b,d))
perm = 0;
if (perm == 1)
printf("%d e' permutacao de %d\n",a,b);
else
printf("%d nao e' permutacao de %d\n",a,b);
return 0;
}
2. (a) Construa uma função encaixa que dados dois inteiros

positivos a e b verifica se b corresponde aos últimos dígitos de a.
Ex.:
a b
567890 890 => encaixa
1243 1243 => encaixa
2457 245 => não encaixa
457 2457 => não encaixa
(b) Usando a função do item anterior, faça um programa que lê dois inteiros
positivos a e b e verifica se o menor deles é segmento do outro.
Exemplo:
a b
567890 678 => b é segmento de a
1243 2212435 => a é segmento de b
235 236 => um não é segmento do outro
#include <stdio.h>
#define TRUE 1
#define FALSE 0
int encaixa(int a, int b) {
while (b != 0 && a % 10 == b % 10) {

a = a/10;
b = b/10;
}
if (b == 0)
return TRUE;
else
return FALSE;
}
int main() {
int a, b, subseq, maior, menor;
printf("Digite dois inteiros positivos: ");

scanf("%d %d", &a, &b);
if (a > b) {
maior = a;
menor = b;
}
else {
maior = b;
menor = a;
}
subseq = FALSE;
while (maior >= menor) {
if (encaixa(maior,menor) == TRUE)
subseq = TRUE;
maior = maior/10;
}
if (subseq == TRUE)
printf("%d e' segmento de %d\n",b,a);
else
printf("%d nao e' segmento de %d\n",b,a);
return 0;
}
Faça uma função arctan que recebe o número real x [0,1] e devolve uma
aproximação do arco tangente de x (em radianos) através da série incluindo
todos os termos da série
incluindo todos os termos da série até
(b) Faça uma função angulo que recebe um ponto de coordenadas cartesianas
reais (x,y), com x > 0 e y > 0 e devolve o ângulo formado pelo vetor (x,y) e o
eixo horizontal.
Exemplos: Observe a figura abaixo e verifique que os ângulos

correspondentes aos pontos marcados é aproximadamente
(0,1) 90 graus
(2,2) 45 graus
(1,4) 75 graus
(5,1) 11 graus
Use a função do item anterior mesmo que você não a tenha feito. Note que a
função só calcula o arco tangente de números entre 0 e 1, e o valor devolvido
é o ângulo em radianos (use o valor = 3.14 radianos = 180 graus).
Para calcular o valor do ângulo pedido, use a seguinte fórmula:
(c) Faça um programa que, dados n pontos do primeiro quadrante (x > 0

e y > 0) através de suas coordenadas cartesianas, determina o ponto que forma
o menor ângulo com o eixo horizontal. Use a função do item anterior, mesmo
que você não a tenha feito.
#include <stdio.h>
#define PI 3.14
/* Item (a) */
float arctan(float x) {
int k;
float termo, soma, eps;
eps = 0.0001;
termo = x;
soma = x;
k = 1;
while (termo*termo > eps*eps){
k = k+2;
termo = -termo*x*x*(k-2)/k;
soma = soma + termo;
}
return soma;
}
/* Item (b) */
/* Funcao extra: transforma angulo de radianos para graus */
float graus(float x) {
return 180*x/PI;
}
float angulo(float x, float y) {
float resp;
if (x == 0 && y == 0) /* ERRO??? */
return -1;
if (x >= y)
if (x != 0)
resp = graus(arctan(y/x));
else
resp = 90;
else
if (y != 0)
resp = graus(PI/2 - arctan(x/y));
else
resp = 0;
return resp;
}
int main() {
int i, n;
float x, y, xmin, ymin, angmin, ang;
printf("Digite quantidade de pontos: ");

scanf("%d", &n);
angmin = 900;
xmin = 0;
ymin = 0;
for (i = 0; i < n; i++){

printf("Digite as coordenados de um ponto: ");
scanf("%f %f", &x, &y);
ang = angulo(x,y);
if (ang == -1)
printf("Ponto na origem, sera' desconsiderado\n");
else
if (ang < angmin){
angmin = ang;
xmin = x;
ymin = y;
}
}
printf("O ponto de menor angulo: (%f,%f)\n", xmin, ymin);

printf("Menor angulo: %f graus\n", angmin);
return 0;
}
1. O
coração
humano bate
em média
uma vez por
segundo.
Desenvolver
um
algoritmo
para
calcular e
escrever
quantas
vezes o
coração de
uma pessoa
baterá se
viver X
anos.
#include<stdio.h>
#include<math.h>
#define batano 365.25
#define batdia 24
#define bathora 60
#define batminuto 60
int main()
{
int idade;
float battotal;
scanf("%d",&idade);
battotal= batano * batdia * bathora * batminuto * idade;
printf("O CORACAO BATEU %.2f VEZES\n",battotal);
return 0;
}
02. Um fabricante de latas deseja desenvolver um algoritmo para

calcular o custo de uma lata cilíndrica de alumínio, sabendo-se que
o custo do alumínio por m² é R$ 100,00.
#include<stdio.h>
#include<math.h>
#define pi 3.1415
#define valormetro 100
int main()
{
float raio,altura,arealata,valortotal;
scanf("%f",&raio);
scanf("%f",&altura);
arealata=(pi * pow(raio,2) * 2) + (2 * pi * raio * altura);

valortotal= arealata * valormetro;
printf("O VALOR DO CUSTO E = %.2f\n",valortotal);
}
03. Teorema de Pitágoras: H² = L1² + L2² . Tem uma infinidade de

números com essa combinação. Dado dois números inteiros positivos, M
e N, onde M>N, desenvolver um algoritmo para entrar com dois números
positivos e fornecer os valores dos lados e da Hipotenusa do
triângulo gerados combinando M e N.
#include<stdio.h>
#include<math.h>
int main()
{
float l1,l2,M,N,hipotenusa;
scanf("%f",&M);
scanf("%f",&N);
l1= pow(M,2)- pow(N,2);

l2= 2 * M * N;
hipotenusa= pow(M,2) + pow(N,2);
printf("L1 = %.2f\n",l1);
printf("L2 = %.2f\n",l2);
printf("HIPOTENUSA = %.2f\n",hipotenusa);
}
04. Muitos países estão passando a utilizar o sistema métrico. Fazer

um algoritmo para executar as seguintes conversões:
? Ler uma temperatura em Fahrenheit e imprimir o equivalente em
Celsius C=(5F-160)/9.
? Ler uma quantidade de chuva dada em polegadas e imprimir o
equivalente em milímetros (1 polegada = 25,4 mm).
#include<stdio.h>
#include<math.h>
#define milimetro_pol 25.4
int main ()
{
float celsius,fahrenheit,chuvapolegada,chuvamilimetro;
scanf("%f",&fahrenheit);
scanf("%f",&chuvapolegada);
celsius=(5 * fahrenheit - 160)/9;

chuvamilimetro=chuvapolegada * milimetro_pol;
printf("O VALOR EM CELSIUS = %.2f\n",celsius);

printf("A QUANTIDADE DE CHUVA E = %.2f\n",chuvamilimetro);
return 0;
}
05. Fazer um programa para ler os valores dos coeficientes A, B e C

de uma equação quadrática e calcular e imprimir o valor do
discriminante (delta).
#include<stdio.h>
#include<math.h>
int main ()
{
float A,B,C,delta;
scanf("%f",&A);
scanf("%f",&B);
scanf("%f",&C);
delta= pow(B,2) - 4 * A * C;
printf("O VALOR DE DELTA E = %.2f\n",delta);

return 0;
}
06. O custo ao consumidor de um carro novo é a soma do custo de

fábrica com a porcentagem do distribuidor e dos impostos (aplicados
ao custo de fábrica). Supondo que a porcentagem do distribuidor seja
de 12% do preço de fábrica e os impostos de 30% do preço de fábrica,
fazer um programa para ler o custo de fábrica de um carro e imprimir
o custo ao consumidor.
#include<stdio.h>
#include<math.h>
int main ()
{
float custocarro,custototal;
scanf("%f",&custocarro);
custototal=(0.12 * custocarro) + (0.30 * custocarro) +

custocarro;
printf("O VALOR DO CARRO E = %.2f\n",custototal);

return 0;
}
07. Desenvolver um algoritmo para ler os comprimentos dos três lados

de um triângulo (L1, L2 e L3) e calcular a área do triângulo.
#include<stdio.h>
#include<math.h>
int main()
{
float L1,L2,L3,areatriangulo,T;
scanf("%f",&L1);
scanf("%f",&L2);
scanf("%f",&L3);
T =(L1 + L2 + L3) / 2;
areatriangulo = sqrt( T * (T - L1) * (T - L2) * (T - L3));
printf("A AREA DO TRIANGULO E = %.2f\n",areatriangulo);

return 0;
}
08. Desenvolver um algoritmo para ler o nome, idade e peso de três
pessoas. Calcular e imprimir idade e o peso médio das três pessoas.
#include<stdio.h>
#include<math.h>
int main()
{
char nome1,nome2,nome3;
int idade1, idade2, idade3;
float peso1, peso2, peso3, pesomedio;
scanf("%s",&nome1);
scanf("%d",&idade1);
scanf("%f",&peso1);
scanf("%s",&nome2);
scanf("%f",&peso2);
scanf("%s",&nome3);
scanf("%f",&peso3);
pesomedio = (peso1 + peso2 + peso3) / 3;
printf("IDADE 1 = %d\n",idade1);
printf("O PESO MEDIO E = %.2f\n",pesomedio);
return 0;
}
09. Dados dois pontos A e B, cujas coordenadas A(x1, y1) e B(x2, y2)
serão informadas via teclado, desenvolver um algoritmo que calcule a
distância entre A e B.
#include<stdio.h>
#include<math.h>
int main()
{
float X1, X2, Y1, Y2, distancia;
scanf("%f",&X1);
scanf("%f",&Y1);
scanf("%f",&X2);
scanf("%f",&Y2);
distancia = sqrt( (pow(X2 - X1,2))+ (pow(Y2 - Y1,2)));
printf("A DISTANCIA ENTRE A e B = %.2f\n",distancia);
return 0;
}
10. Dado um número de três algarismos, construir outro número de

quatro algarismos de acordo com a seguinte regra:
Os três primeiros algarismos, contados da esquerda para a direita
são iguais ao número dado.
O quarto algarismo é um digito de controle calculado da seguinte
forma: primeiro número + segundo número * 3 + terceiro número * 5. O
dígito de controle é igual ao resto da divisão dessa soma por 7.
#include<stdio.h>
#include<math.h>
int main()
{
int N1,N2,N3,N4,AUX,tresdigitos,quatrodigitos;
scanf("%d",&tresdigitos);
N3 = tresdigitos % 10;
AUX = tresdigitos / 10;
N2 = AUX % 10;
AUX = AUX / 10;
N1 = AUX % 10;
AUX = N1 + ( N2 * 3 ) + ( N3 * 5 );
N4 = AUX % 7;
quatrodigitos = tresdigitos * 10 + N4;
printf("O NOVO NUMERO E = %d\n",quatrodigitos);

return 0;
}
11. Fazer um algoritmo que dados os 4 elementos de uma matriz 2 x 2.
Calcule e escreva o valor do determinante desta matriz.
#include<stdio.h>
#include<math.h>
int main()
{
float A,B,C,D,det;
scanf("%f",&A);
scanf("%f",&B);
scanf("%f",&C);
scanf("%f",&D);
det = (A * D) - (B * C);
printf("O VALOR DO DETERMINANTE E = %.2f\n",det);
return 0;
}
12. Dada a base e a altura de uma pirâmide. Fazer um algoritmo que

calcule e escreva o volume desta.
#include<stdio.h>
#include<math.h>
int main()
{
float base,altura,volume;
scanf("%f",&base);
volume = 1 / 3.0 * (base * altura);
printf("O VOLUME DA PIRAMIDE E = %.2f\n",volume);
return 0;
}
13. Fazer um algoritmo que obtenha o raio e a altura de um cilindro.
Calcular e escrever o volume e a área deste cilindro.
*#include<stdio.h>
#include<math.h>
#define pi 3.1415
int main()
{
float raio, altura, volume, area;
scanf("%f",&raio);
area = 2 * pi * raio * (altura + raio);

volume = pi * pow(raio,2) * altura;
printf("O VALOR DA AREA E = %.2f\n",area);

printf("O VALOR DO VOLUME E = %.2f\n",volume);
return 0;
14. Uma locadora de charretes cobra R$ 10,00 de taxa para cada 3

horas de uso destas e R$5,00 para cada 1 hora abaixo destas 3 horas.
Fazer um algoritmo que dado a quantidade de horas que a charrete foi
usada calcular e escrever quanto o cliente tem de pagar.
#include<stdio.h>
#include<math.h>
int main()
{
int horas;
float valor1, valor2, restante, total;
scanf("%d",&horas);
valor1 = (horas / 3 ) * 10;

restante = (horas % 3);
valor2 = restante * 5;
total = valor1 + valor2;
printf("O VALOR A PAGAR E = %.2f\n",total);

return 0;
15. Fazer um algoritmo que leia três números inteiros positivos (A,
B e C) e calcular e imprmir o valor de D.
#include<stdio.h>
#include<math.h>
int main()
{
float A,B,C,D,R,S;
scanf("%f",&A);
scanf("%f",&B);
scanf("%f",&C);
R = pow(A + B,2);
S = pow(B + C,2);
D = (R + S) / 2;
printf("O VALOR DE D = %.2f\n",D);
return 0;
16. Fazer um algoritmo que leia a idade de uma pessoa expressa em

anos, meses e dias e mostre-a apenas em dias.
#include<stdio.h>
#include<math.h>
#define diasanos 365
#define diameses 30
int main()
{
int idadedias, anos, meses, dias;
scanf("%d",&anos);
scanf("%d",&meses);
scanf("%d",&dias);
idadedias = (diasanos * anos ) + ( diameses * meses ) + dias;
printf("O VALOR EM DIAS E = %d\n",idadedias);

return 0;
17. Fazer um algoritmo que leia a idade de uma pessoa expressa em

dias e mostre-a expressa em anos,
meses e dias.
#include<stdio.h>
#include<math.h>
#define valorano 365
#define valormes 30
int main()
{
int dias, anos , meses, qntdias, aux;
scanf("%d",&qntdias);
anos = qntdias / valorano;

aux = qntdias % valorano;
meses = aux / valormes;
dias = aux % valormes;
printf("%d ANOS %d MESES %d DIAS\n",anos,meses,dias);
return 0;
18. Fazer um algoritmo que leia o tempo de duração de um evento

expresso em segundos e mostre-o expresso em horas, minutos e
segundos.
#include<stdio.h>
#include<math.h>
#define valorhora 3600
#define valorminuto 60
int main()
{
int segundostotal, horas, minutos, segundos, aux;
scanf("%d",&segundostotal);
horas = segundostotal / valorhora;

aux = segundostotal % valorhora;
minutos = aux / valorminuto;
segundos = aux % valorminuto;
printf("%d HORAS %d MINUTOS %d

SEGUNDOS\n",horas,minutos,segundos);
return 0;
19. Um sistema de equações lineares do tipo:

ax + bx = c
dx + ex = f
pode ser resolvido segundo mostrado abaixo:
x = ce – bf e y = af – cd
ae – bd ae – bd
Escreva um algoritmo que lê os coeficientes a, b, c, d, e, f.
Calcule e mostre os valores de x e y.
#include<stdio.h>
#include<math.h>
int main()
{
float A, B , C, D , E, F, X, Y;
scanf("%f",&A);
scanf("%f",&B);
scanf("%f",&C);
scanf("%f",&D);
scanf("%f",&E);
scanf("%f",&F);
X = (( C * E ) - ( B * F )) / (( A * E ) - ( B * D ));
Y = (( A * F ) - ( C * D )) / (( A * E ) - ( B * D ));
printf("O VALOR DE X E = %.2f\n",X);

printf("O VALOR DE Y E = %.2f\n",Y);
return 0;
20. Escreva um algoritmo que lê um valor em reais e calcula qual o

menor número possível de notas de $100, $50, $10 e $1 em que o valor
lido pode ser decomposto. Escrever o valor lido e a relação de notas
necessárias.
#include<stdio.h>
#include<math.h>
int main()
{
int valorreais, nota100, nota50, nota10, nota1, aux;
scanf("%d",&valorreais);
nota100 = valorreais / 100;

aux = valorreais % 100;
nota50 = aux / 50;
aux = aux % 50;
nota10 = aux / 10;
nota1 = aux % 10;
printf("NOTAS DE 100 = %d\n",nota100);

return 0;
21. Escrever um algoritmo que lê:

? a porcentagem do IPI a ser acrescido no valor das peças;
? o código da peça 1, valor unitário da peça 1, quantidade de
peças 1;
? o código da peça 2, valor unitário da peça 2, quantidade de
peças 2;
O algoritmo deve calcular o valor total a ser pago e apresentar
o resultado.
#include<stdio.h>
#include<math.h>
int main()
{
float valor1, quant1, cod1, valor2, quant2, cod2,
formula,ipi;
scanf("%f",&ipi);
scanf("%f",&cod1);
scanf("%f",&valor1);
scanf("%f",&quant1);
scanf("%f",&cod2);
scanf("%f",&valor2);
scanf("%f",&quant2);
formula = (valor1 * quant1 + valor2 * quant2) * (ipi / 100 +

1);
printf("O VALOR TOTAL A SER PAGO = %.2f\n",formula);
return 0;
}
22. Escreva um algoritmo para calcular o consumo médio de um

automóvel (medido em Km/l), dado que são conhecidos a distância
total percorrida e o volume de combustível consumido para percorrê-
la (medido em litros).
#include<stdio.h>
#include<math.h>
int main()
{
float distancia, volumelitros, media;
scanf("%f",&distancia);
scanf("%f",&volumelitros);
media = distancia / volumelitros;
printf("O CONSUMO MEDIO = %.2fKM/L\n",media);
return 0;
}
23. Escrever um algoritmo que lê o número de funcionário, seu
número de horas trabalhadas, o valor que recebe por hora, o número
de filhos com idade menor que 14 anos e o valor do salário família
(pago por filho com menos de 14 anos). Calcular o salário total
deste funcionário e escrever o seu número e o seu salário total.
#include<stdio.h>
#include<math.h>
int main()
{
int numfunc, horas, numfilhos;
float valorhora, valorfamilia,saltotal;
scanf("%d",&numfunc);
scanf("%d",&horas);
scanf("%f",&valorhora);
scanf("%d",&numfilhos);
scanf("%f",&valorfamilia);
saltotal = (horas * valorhora) + (numfilhos * valorfamilia);
printf("NUMERO DO FUNCIONARIO = %d\n",numfunc);

printf("SALARIO TOTAL = %.2f\n",saltotal);
return 0;
}
24. Escrever um algoritmo que lê o valor de uma compra em

dólares, a taxa do dólar no dia da compra, o percentual de ICMS e o
percentual de lucro da empresa, e calcular e escrever o valor a ser
pago em reais, sabendo-se que o percentual de lucro e o percentual
de ICMS incidem sobre o valor em reais.
#include<stdio.h>
#include<math.h>
int main()
{
float compradolar, taxadolar, icms, lucroempresa,
valorpagar, comprareais;
scanf("%f",&compradolar);
scanf("%f",&taxadolar);
scanf("%f",&icms);
scanf("%f",&lucroempresa);
comprareais = compradolar * taxadolar;
comprareais = (comprareais * icms/100) + (comprareais *
lucroempresa /100) + comprareais;
printf("O VALOR PAGO EM REAIS = %.2f\n",comprareais);
return 0;
}
25. Um hotel com 42 apartamentos resolveu fazer promoções para

os fins de semana fora da alta temporada, isto é, nos meses de
abril, maio, junho, agosto, setembro, outubro e novembro. A taxa da
promoção é de 22% da diária normal. A ocupação média do hotel sem
promoção é de 40%. A expectativa é aumentar a taxa de ocupação para
70%. Supondo que as expectativas se confirmem,
escrever um algoritmo que lê a diária normal e calcula e escreve
as seguintes informações:
? O valor da diária no período da promoção.
? O valor médio arrecadado sem a promoção, durante um mês
(apenas finais de semana).
? O valor médio arrecadado com a promoção, durante um mês
(apenas finais de semana).
? O lucro ou prejuízo mensal com a promoção.
#include<stdio.h>
#include<math.h>
int main()
{
float diariapromo, mediapromo, mediasempromo, diarianormal,
lucroouprej;
scanf("%f",&diarianormal);
diariapromo = 0.22 * diarianormal;

mediasempromo = ( 42 * 0.4) * 8 * diarianormal;
mediapromo = (42 * 0.7) * 8 * diariapromo;
lucroouprej = mediapromo - mediasempromo;
printf("O VALOR DA DIARIA NO PERIODO DA PROMOCAO =

%.2f\n",diariapromo);
printf("O VALOR MEDIO ARRECADADO SEM A PROMOCAO =
%.2f\n",mediasempromo);
printf("O VALOR MEDIO ARRECADADO COM A PROMOCAO =
%.2f\n",mediapromo);
printf("LUCRO OU PREJUIZO = %.2f\n",lucroouprej);
return 0;
}
26. Escrever um algoritmo que lê um número de 3 dígitos e o

inverta, escrevendo o número invertido.
#include<stdio.h>
#include<math.h>
int main()
{
int N1, N2, N3, numero, aux;
scanf("%d",&numero);
N1 = numero / 100;
aux = numero % 100;
N2 = aux / 10;
N3 = aux % 10;
numero = (N3 * 100) + (N2 * 10) + N1;
printf("O NUMERO INVERTIDO = %d\n",numero);

return 0;
}
27. Em uma padaria, o padeiro quer saber qual o custo de

fabricação do pão francês de forma a saber por quanto terá que
vender o pão, tendo um lucro de 30%. Sabendo-se que a receita do pão
leva farinha, água e fermento, escreva um algoritmo que lê a
quantidade de quilos de farinha, o valor do quilo de farinha, a
quantidade de litros de água, o valor do litro de água, a quantidade
de quilowatts
de hora de luz, o valor do quilowatts hora e o percentual do
imposto que o padeiro para pelo pão e calcular e imprimir o preço de
custo e de venda.
#include<stdio.h>
#include<math.h>
int main()
{
float quilofarinha, v_quilofarinha, qnt_litroagua,
v_litroagua, qnt_watshoraluz, v_qntwatshora, precocusto, precovenda,
lucro,imposto;
scanf("%f",&quilofarinha);
scanf("%f",&v_quilofarinha);
scanf("%f",&qnt_litroagua);
scanf("%f",&v_litroagua);
scanf("%f",&qnt_watshoraluz);
scanf("%f",&v_qntwatshora);
scanf("%f",&imposto);
precocusto = (quilofarinha * v_quilofarinha) +

(qnt_litroagua * v_litroagua) + ( qnt_watshoraluz * v_qntwatshora);
precocusto = (precocusto * (imposto/100)) + precocusto;
lucro = precocusto * 0.3;
precovenda = (precocusto + lucro);
//precovenda = ((imposto/100) * precovenda) + precovenda;
printf("PRECO DE CUSTO = %.2f\n",precocusto);

printf("PRECO DE VENDA = %.2f\n",precovenda);
return 0;
28. Escrever um algoritmo que lê a massa (toneladas) de um

avião, sua aceleração (m/s²) e o tempo (s) que levou do repouso até
a decolagem. Calcular e escrever a velocidade atingida (Km/h), o
comprimento da pista (m) e o trabalho mecânico realizado (J) no
momento da decolagem.
#include<stdio.h>
#include<math.h>
#include<stdlib.h>
int main()
{
float massa, aceleracao, tempo , velocidade,
velo_final,massa2;
double comp_pista,trabalho;
scanf("%f",&massa);
scanf("%f",&aceleracao);
scanf("%f",&tempo);
massa2 = massa * 1000;

velocidade = aceleracao * tempo;
trabalho = massa2 * pow(velocidade,2) /2;
velocidade = aceleracao * tempo * 3.6;
comp_pista = (aceleracao * pow(tempo,2)) /2;
printf("VELOCIDADE = %.2f\n",velocidade);
printf("ESPACO PERCORRIDO = %.2f\n",comp_pista);
printf("TRABALHO REALIZADO = %.2f\n",trabalho);
return 0;
}
29. Escrever um algoritmo que lê o público total de futebol e

fornecer a renda do jogo, sabendo-se que havia 4 tipos de ingressos
assim distribuídos: popular 10% a R$1,00, geral 50% a R$5,00,
arquibancada 30% a R$10,00 e cadeiras 10% a R$ 20,00.
#include<stdio.h>
#include<math.h>
int main()
{
int publicototal;
float rendajogo, ing_pop, ing_geral, ing_arq, ing_cadeira;
scanf("%d",&publicototal);
ing_pop = 0.1 * publicototal;

ing_geral = 0.5 * publicototal;
ing_arq = 0.3 * publicototal;
ing_cadeira = 0.1 * publicototal;
rendajogo = (ing_pop * 1) + (ing_geral * 5) + (ing_arq * 10)
+ (ing_cadeira * 20);
printf("A RENDA DO JOGO = %.2f\n",rendajogo);
return 0;
}
30. Uma autolocadora aluga seus carros com uma taxa fixa por
dia, uma taxa por Km rodado e desconto de 10% na taxa fixa de
aluguel por dia. Escrever um algoritmo que lê a taxa fixa por dia, a
taxa por Km rodado, o número de dias, o número de quilômetro rodado
e calcular e escrever o valor total do aluguel, o valor do desconto,
o numero de dias, e a quilometragem rodada.
#include<stdio.h>
#include<math.h>
#include<stdlib.h>
int main()
{
int dias, kmrodado;
float taxadia, desconto, totalaluguel, taxakm;
scanf("%f",&taxadia);
scanf("%f",&taxakm);
scanf("%d",&dias);
scanf("%d",&kmrodado);
totalaluguel = ((taxadia - (taxadia * 0.1)) * dias) +

(taxakm * kmrodado);
desconto = (taxadia * 0.1) * dias;
printf("VALOR TOTAL DO ALUGUEL = %.2f\n",totalaluguel);

printf("VALOR DO DESCONTO = %.2f\n",desconto);
printf("NUMERO DE DIAS = %d\n",dias);
printf("QUILOMETRAGEM RODADA = %d\n",kmrodado);
return 0;
}
31. Escrever um algoritmo que lê a taxa de consumo de potência

elétrica de um refrigerador, o tempo em horas que permaneceu ligado
e o valor do quilowatt hora e calcular e escrever a energia total
gasta pelo refrigerador, bem como, o valor a ser pago á companhia de
Energia Elétrica.
#include<stdio.h>
#include<math.h>
int main()
{
int tempohoras;
float taxaconsumo, valorwatt, energiatotal, valortotal;
scanf("%f",&taxaconsumo);
scanf("%d",&tempohoras);
scanf("%f",&valorwatt);
energiatotal = taxaconsumo * tempohoras;

valortotal = energiatotal * valorwatt;
printf("ENERGIA TOTAL GASTA = %.2f\n",energiatotal);

printf("VALOR A SER PAGO = %.2f\n",valortotal);
return 0;
}
33. Desenvolver um algoritmo que leia um número inteiro e

verifique se o número é divisível por 5 e
por 3 ao mesmo tempo.
#include<stdio.h>
#include<math.h>
int main()
{
int numero;
if (((numero % 5)==0) && ((numero % 3)==0)){

printf("O NUMERO E DIVISIVEL\n");
}
else{
printf("O NUMERO NAO E DIVISIVEL\n");
}
return 0;
}
34. Dados quatro números distintos, desenvolver um algoritmo que

determine e imprima a soma dos três menores.
#include<stdio.h>
#include<math.h>
int main()
{
int numero1, numero2, numero3, numero4, soma;
scanf("%d",&numero1);
if(numero1 > numero2 && numero1 > numero3 && numero1 >
numero4)
{
soma = (numero2 + numero3 + numero4);
printf("%d\n",soma);
}
else if(numero2 > numero1 && numero2 > numero3 && numero2 >
numero4)
{
soma = numero1 + numero3 + numero4;
}
numero4)
{
}
numero3)
{
}
return 0;
35. Desenvolver um algoritmo que leia os coeficientes (a , b e

c) de uma equação do segundo grau e calcule suas raízes. O programa
deve mostrar, quando possível, o valor das raízes calculadas e a
classificação das raízes.
#include<stdio.h>
#include<math.h>
int main()
{
float a, b, c, delta, X1, X2;
scanf("%f",&a);
scanf("%f",&b);
scanf("%f",&c);
delta = (pow(b,2) - 4 * a * c);

X1 = (-b + sqrt(delta))/(2 * a);
X2 = (-b - sqrt(delta))/ (2 * a);
if (delta == 0)
{
printf("RAIZ UNICA\n");
printf("X1 = %.2f\n",X1);
}
else if (delta < 0 )

{
printf("RAIZES IMAGINARIAS\n");
}
else if (delta > 0 )

{
printf("RAIZES DISTINTAS\n");
}
return 0;
36. Desenvolver um algoritmo para ler um número “x” e calcular e

imprimir o valor de “y” de acordo com as condições abaixo:
y = x , se x < 1;
y = 0 , se x = 1;
y = x² , se x > 1;
#include<stdio.h>
#include<math.h>
int main()
{
int x, y;
scanf("%d",&x);
if(x < 1)
{
y = x;
printf("Y = %d\n",y);
}
else if(x == 1)
{
y = 0;
}
else if(x > 1)

{
y = pow(x,2);
}
return 0;
}
37. Desenvolver um algoritmo para pedir um mês e ano e exibir o
número de dias do mês / ano digitados.
*#include<stdio.h>
#include<math.h>
#include<string.h>
int main()
{
int ano, anobissexto, mesfevereirobissexto;
char mes[15];
scanf("%s",mes);
scanf("%d",&ano);
if (ano % 4==0 ) {
anobissexto = 366;
mesfevereirobissexto = 29;
}
else {
anobissexto = 365;
mesfevereirobissexto = 28;
}
if (strcmp(mes,"JANEIRO") == 0){
printf("DIAS = 31\n");
printf("DIAS NO ANO = %d\n",anobissexto);
}
else if (strcmp(mes,"FEVEREIRO") == 0){

printf("DIAS = %d\n",mesfevereirobissexto);
}
else if (strcmp(mes,"MARCO") == 0){

}
else if (strcmp(mes,"ABRIL") == 0){

}
else if (strcmp(mes,"MAIO") == 0){

}
else if (strcmp(mes,"JUNHO") == 0){

}
else if (strcmp(mes,"JULHO") == 0){
}
else if (strcmp(mes,"AGOSTO") == 0){

}
else if (strcmp(mes,"SETEMBRO") == 0){

}
else if (strcmp(mes,"OUTUBRO") == 0){

}
else if (strcmp(mes,"NOVEMBRO") == 0){
}
else if (strcmp(mes,"DEZEMBRO") == 0){
}
return 0;
38. Desenvolver um algoritmo para ler o número de uma sala de

aula, sua capacidade e o total de alunos matriculados na mesma e
imprimir uma linha mostrando o número da sala, sua capacidade, o
número de cadeiras ocupadas e sua disponibilidade indicando se a
sala está lotada ou não.
#include<stdio.h>
#include<math.h>
int main()
{
int numerosala, capacidade, alunosmatriculados;
scanf("%d",&numerosala);
scanf("%d",&capacidade);
scanf("%d",&alunosmatriculados);
if (alunosmatriculados >= capacidade)
{
printf("SALA = %d\n",numerosala);
printf("CAPACIDADE = %d\n",capacidade);
printf("CADEIRAS OCUPADAS = %d\n",alunosmatriculados);
printf("SALA LOTADA\n");
}
else if (alunosmatriculados < capacidade)

{
printf("SALA = %d\n",numerosala);
printf("CAPACIDADE = %d\n",capacidade);
printf("CADEIRAS OCUPADAS = %d\n",alunosmatriculados);
printf("SALA NAO LOTADA\n");
}
return 0;
}
39. Desenvolver um algoritmo que determine o imposto de renda

cobrado de um funcionário pelo governo. Seu programa deverá ler o
valor do salário mínimo, o n° de dependentes, o salário do
funcionário e o taxa de imposto normal que já foi paga pelo
funcionário. O imposto bruto é:
• 20% do salário do funcionário se o funcionário ganha mais de

12 salários mínimos;
• 8% do salário do funcionário se o funcionário ganha mais de 5
salários mínimos e
• Quem ganha menos ou igual de 5 salários mínimos não é cobrado
o imposto de renda.
Obs.: Sabe-se que o governo cobra 4% de taxa adicional sobre o
IMPOSTO BRUTO.
#include<stdio.h>
#include<math.h>
#include<string.h>
int main()
{
int numerodependentes;
float salariominimo, salariofunc, taxaimposto,
taxaimpostosalario, impostoderenda, impostobruto, impostoliquido,
salariomaximo12, salariomaximo5, calcdependentes;
scanf("%f",&salariominimo);
scanf("%d",&numerodependentes);
scanf("%f",&salariofunc);
scanf("%f",&taxaimposto);
salariomaximo12 = salariominimo * 12;

salariomaximo5 = salariominimo * 5;
calcdependentes = numerodependentes * 300.00;
taxaimpostosalario = (taxaimposto / 100) * salariofunc;
if ( salariofunc > salariomaximo12){

impostobruto = 0.2 * salariofunc;
impostobruto = 0.04 * impostobruto + impostobruto;
}
else if (salariofunc > salariomaximo5){

impostobruto = 0.08 * salariofunc;
impostobruto = 0.04 * impostobruto + impostobruto;
}
else if (salariofunc <= salariomaximo5){

impostobruto = 0;
}
impostoliquido = impostobruto - calcdependentes ;

impostoderenda = impostoliquido - taxaimpostosalario;
if (impostoderenda == 0){
printf("IMPOSTO BRUTO = %.2f\n",impostobruto);
printf("IMPOSTO LIQUIDO = %.2f\n",impostoliquido);
printf("RESULTADO = %.2f\n",impostoderenda);
printf("IMPOSTO QUITADO\n");
}
else if (impostoderenda < 0){

printf("IMPOSTO A RECEBER\n");
}
else if (impostoderenda > 0){

printf("IMPOSTO A PAGAR\n");
}
return 0;
}
40. Desenvolver um algoritmo para calcular a conta de água para
a SANEAGO. O custo da água varia dependendo se o consumidor é
residencial, comercial ou industrial. A regra para calcular a conta
é:
? Residencial: R$5,00 de taxa mais R$0,05 por m³ gastos;

? Comercial: R$500,00 para os primeiros 80 m³ gastos mais R$0,25
por m³ gastos;
? Industrial: R$800,00 para os primeiros 100 m³ gastos mais
R$0,04 por m³ gastos;
O programa deverá ler a conta do cliente, consumo de água por
metros cúbicos e o tipo de consumidor ( residencial, comercial e
industrial ). Como resultado, imprima a conta do cliente e o valor
real a ser pago pelo mesmo.
#include<stdio.h>
#include<math.h>
#include<string.h>
int main()
{
int contacliente, consumoagua;
float formula;
char tipoconsumidor[15];
scanf("%d",&contacliente);
scanf("%d",&consumoagua);
scanf("%s",tipoconsumidor);
if (strcmp(tipoconsumidor,"RESIDENCIAL") == 0){
formula = 5.00 + (0.05 * consumoagua);
printf("CONTA = %d\n",contacliente);
printf("VALOR DA CONTA = %.2f\n",formula);
}
if (strcmp(tipoconsumidor,"COMERCIAL") == 0 && consumoagua

<= 80 ){
formula = 500.00;
}
else if (strcmp(tipoconsumidor,"COMERCIAL") == 0 &&

consumoagua > 80 ){
formula = 500.00 + ((consumoagua - 80) * 0.25);
}
if (strcmp(tipoconsumidor,"INDUSTRIAL") == 0 && consumoagua

<= 100){
formula = 800.00;
printf("VALOR DA CONTA = %.2f",formula);
}
else if (strcmp(tipoconsumidor,"INDUSTRIAL") == 0 &&
consumoagua > 100){
formula = 800.00 + ((consumoagua - 100 )* 0.04);
}
return 0;
41. Uma locadora de filmes tem a seguinte regra para aluguel de

fitas.
? As segundas, terças e quintas (2, 3 e 5): um desconto de 40%
em cima do preço normal;
? As quartas, sextas, sábados e domingos (4, 6, 7 e 1): preço
normal;
? Aluguel de fitas comuns: preço normal e aluguel de
lançamentos: acréscimo de 15% em cima do preço normal.
#include<stdio.h>
#include<math.h>
#include<string.h>
int main()
{
float preconormal, descontopromo, precototal;
char dia[15], categoria[15];
scanf("%f",&preconormal);
scanf("%s",dia);
scanf("%s",categoria);
if (strcmp(dia,"SEGUNDA") ==0 || strcmp(dia,"TERCA") ==0 ||

strcmp(dia,"QUINTA") == 0){
descontopromo = preconormal - (0.4 * preconormal) ;
}
else if (strcmp(dia,"QUARTA") == 0|| strcmp(dia,"SEXTA") ==
0|| strcmp(dia,"SABADO") ==0|| strcmp(dia,"DOMINGO")==0){
descontopromo = 0;
}
if (strcmp(categoria,"LANCAMENTO") == 0){
preconormal = (preconormal * 0.15);
}
else if (strcmp(categoria,"COMUM") == 0){

preconormal = preconormal;
}
precototal = descontopromo + preconormal;

printf("PRECO FINAL = %.2f\n",precototal);
return 0;
42. Desenvolver um algoritmo com as opções de calcular e

imprimir o volume e a área da superfície de um cone reto, um
cilindro ou uma esfera. O algoritmo deverá ler a opção da figura
desejada (cone / cilindro / esfera) e de acordo com a opção
escolhida calcular o volume e a área da superfície da figura pedida.
Fórmulas:
#include<stdio.h>
#include<math.h>
#include<string.h>
#define pi 3.1415
int main()
{
float raio, altura, volume, area;

char tipo[10];
scanf("%f",&raio);
scanf("%s",tipo);
if (strcmp(tipo,"CONE")==0){
volume = ((pi * pow(raio,2)) * altura) / 3;
area = (pi * raio) * sqrt(pow(raio,2) + pow(altura,2));
printf("VOLUME = %.2f\n",volume);
printf("AREA = %.2f\n",area);
}
else if (strcmp(tipo,"CILINDRO")==0){
volume = ((pi * pow(raio,2)) * altura);
area = (2 * pi) * (raio * altura);
}
else if (strcmp(tipo,"ESFERA")==0){
volume = (pi * 4 * pow(raio,3)) / 3;
area = (4 * (pi * pow(raio,2)));
}
return 0;
}
43. Um certo aço é classificado de acordo com o resultado de três

testes abaixo, que devem determinar se o mesmo satisfaz as
especificações:
1. Conteúdo de Carbono abaixo de 7;
2. Dureza Rockwell maior do que 50;
3. Resistência á tração maior do que 80.000 psi;
#include<stdio.h>
#include<math.h>
#include<string.h>
int main()
{
int conteudo, dureza, resistencia;
scanf("%d",&conteudo);
scanf("%d",&dureza);
scanf("%d",&resistencia);
if (conteudo < 7 && dureza > 50 && resistencia > 80000){
printf("ACO DE GRAU = 10\n");
}
else if (conteudo < 7 && dureza > 50 && resistencia <= 80000) {
}
else if (conteudo < 7 && dureza <= 50 && resistencia <= 80000){
}
else if (conteudo >= 7 && dureza <= 50 && resistencia <= 80000){
}
return 0;
}
44. Fazer um algoritmo que dado um número, calcular e escrever se

este é positivo ou negativo, e múltiplo ou não de 3, ao mesmo tempo.
#include<stdio.h>
#include<math.h>
int main()
{
int numero;
if (numero < 0)
{
printf("NEGATIVO\n");
}
else if (numero > 0)
{
printf("POSITIVO\n");
}
if (numero % 3 != 0)
{
printf("NAO MULTIPLO DE 3\n");
}
else if (numero % 3 == 0)
{
printf("MULTIPLO DE 3\n");
}
return 0;
}
45. Fazer um algoritmo que calcule e imprima o salário reajustado de

um funcionário de acordo com as seguintes regras:
• Salário de até R$300,00 reajuste de 50%;
• Salário maiores que R$300,00 reajuste de 30%;
#include<stdio.h>
#include<math.h>
int main()
{
float salario, salarioreajustado;
scanf("%f",&salario);
if (salario <= 300.00){

salarioreajustado = (0.5 * salario) + salario;
printf("SALARIO COM REAJUSTE = %.2f\n",salarioreajustado);
}
else if (salario > 300.00){

salarioreajustado = (0.3 * salario) + salario;
printf("SALARIO COM REAJUSTE = %.2f\n",salarioreajustado);
}
return 0;
}
46. Fazer um algoritmo que dado três valores A, B e C verificar se

eles formam um triângulo. Formando triângulo, dizer se é triângulo
equilátero, isósceles ou escaleno.
#include<stdio.h>
#include<math.h>
int main()
{
float A, B, C;
scanf("%f",&A);
scanf("%f",&B);
scanf("%f",&C);
if (C > A + B || A > B + C || B > A + C ){

printf("NAO FORMAM UM TRIANGULO\n");
}
else if ( A != B && A != C && B != C ){

printf("TRIANGULO ESCALENO\n");
}
else if ( A == B && A == C){

printf("TRIANGULO EQUILATERO\n");
}
else if (A == B || A == C || B == C){
printf("TRIANGULO ISOSCELES\n");
}
return 0;
}
47. Fazer um algoritmo que dado os lados de um triângulo A, B e C.

Dizer se os lados formam um triângulo:
• Retângulo = (A² = B² + C²);
• Obtusângulo = (A² > B² + C²);
• Acutângulo = (A² < B² + C²) ;
#include<stdio.h>
#include<math.h>
int main()
{
float A, B, C;
scanf("%f",&A);
scanf("%f",&B);
scanf("%f",&C);
if (pow(A,2) == pow(B,2) + pow(C,2)){

printf("TRIANGULO RETANGULO\n");
}
else if (pow(A,2) > pow(B,2) + pow(C,2)){

printf("TRIANGULO OBTUSANGULO\n");
}
else if (pow(A,2) < pow(B,2) + pow(C,2)){

printf("TRIANGULO ACUTANGULO\n");
}
return 0;
}
48. Fazer um algoritmo que calcule a média aritmética das 3 notas de

um aluno e mostre, além do valor da média, uma mensagem de
“Aprovado”, caso a média seja igual ou superior a 6, ou a mensagem
“reprovado”, caso contrário.
#include<stdio.h>
#include<math.h>
int main()
{
float nota1, nota2, nota3, media;
scanf("%f",&nota1);
scanf("%f",&nota2);
scanf("%f",&nota3);
media = (nota1 + nota2 + nota3) / 3;
if (media >= 6.00){

printf("MEDIA = %.2f",media);
printf("APROVADO\n");
}
else if ( media < 6.00){

printf("MEDIA = %.2f\n",media);
printf("REPROVADO\n");
}
return 0;
}
49. Implementar um algoritmo capaz de encontrar o maior dentre 3

números quaisquer. Suponha todos
serem distintos.
#include<stdio.h>
#include<math.h>
int main()
{
int numero1, numero2, numero3;
if (numero1 > numero2 && numero1 > numero3){

printf("MAIOR NUMERO = %d\n",numero1);
}
else if (numero2 > numero1 && numero2 > numero3){

}
else if (numero3 > numero1 && numero3 > numero2){

}
return 0;
}
50. Escrever um algoritmo que leia o código de um aluno e suas três

notas. Calcular a média ponderada do aluno, considerando que o peso
para a maior nota seja 4 e para as duas restantes, 3. Mostre o
código do aluno, suas três notas, a média calculada e uma mensagem
“Aprovado” se a média for maior ou igual a 5 e “reprovado” se a
média for menor que 5.
#include<stdio.h>
#include<math.h>
int main()
{
int cod_aluno;
float nota1, nota2, nota3, mediaponderada;
scanf("%d",&cod_aluno);
scanf("%f",&nota1);
scanf("%f",&nota2);
scanf("%f",&nota3);
if (nota1 > nota2 && nota1 > nota3){
mediaponderada = (( nota1 * 4 ) + (nota2 * 3) + (nota3 * 3))
/10;
}
else if (nota2 > nota1 && nota2 > nota3){

mediaponderada = (( nota2 * 4 ) + (nota1 * 3) + (nota3 * 3))
/10;
}
else if (nota3 > nota1 && nota3 > nota2){

mediaponderada = (( nota3 * 4 ) + (nota1 * 3) + (nota2 *
3.)) /10;
}
if (mediaponderada >= 5.00){

printf("CODIGO = %d\n",cod_aluno);
printf("NOTA 1 = %.2f\n",nota1);
printf("MEDIA = %.2f\n",mediaponderada);
}
else if (mediaponderada < 5.00){

printf("CODIGO = %d\n",cod_aluno);
printf("MEDIA = %.2f\n",mediaponderada);
}
return 0;
}
51. Faça um algoritmo que leia um numero inteiro e mostre uma

mensagem indicando se este número é par ou impar, se é positivo ou
negativo
#include<stdio.h>
#include<math.h>
int main()
{
int numeroint;
scanf("%d",&numeroint);
if (numeroint > 0){

printf("NUMERO POSITIVO\n");
}
else if (numeroint < 0){

printf("NUMERO NEGATIVO\n");
}
if ( numeroint % 2 == 0){
printf("NUMERO PAR\n");
}
else if ( numeroint % 2 != 0){

printf("NUMERO IMPAR\n");
}
return 0;
}
52. Tendo como dados de entrada a altura e o sexo de uma pessoa,

construa um algoritmo que calcule seu peso ideal, utilizando as
seguintes fórmulas:
• Para Homens: (72.7 *h) – 58;
• Para Mulheres: (62.1 * h) – 44.7
#include<stdio.h>
#include<math.h>
#include<string.h>
int main()
{
float altura, pesomasc, pesofem;
char sexo[10];
scanf("%s",sexo);
if (strcmp(sexo,"MASCULINO") == 0){
pesomasc = (72.7 * altura) - 58;
printf("PESO = %.2f\n",pesomasc);
}
else if (strcmp(sexo,"FEMININO") == 0) {
pesofem = (62.1 * altura) - 44.7;
printf("PESO = %.2f\n",pesofem);
}
return 0;
53. Um usuário deseja um algoritmo onde possa escolher que tipo de

média deseja calcular a partir de 3 notas. Faça um algoritmo que
leia as notas, a opção escolhida pelo usuário e calcule a média.
(a) aritmética
(b) ponderada (3,3,4)
(c) Harmônica:
#include<stdio.h>
#include<math.h>
#include<string.h>
int main()
{
float nota1, nota2, nota3, calculo;
char tipocalculo[15];
scanf("%f",&nota1);
scanf("%f",&nota2);
scanf("%f",&nota3);
scanf("%s",tipocalculo);
if (strcmp(tipocalculo,"ARITMETICA") == 0){
calculo = (nota1 + nota2 + nota3) / 3;
printf("MEDIA ARITMETICA = %.2f\n",calculo);
}
else if (strcmp(tipocalculo,"PONDERADA") == 0){

calculo = (( nota1 * 3 ) + (nota2 * 3) + (nota3 * 4)) /10;
printf("MEDIA PONDERADA = %.2f\n",calculo);
}
else if (strcmp(tipocalculo,"HARMONICA") == 0){

calculo = 3/(1/nota1 + 1/nota2 +1/nota3);
printf("MEDIA HARMONICA = %.2f\n",calculo);
}
return 0;
54. Escrever um algoritmo que lê um conjunto de 4 valores “i”, “a”,

“b” e “c”, onde “i” é um valor inteiro e positivo e “a”, “b” e “c”
são quaisquer valores reais e os escreva. A seguir:
• Se i = 1 escrever os três valores a, b, c em ordem crescente.
• Se i = 2 escrever os três valores a, b, c em ordem decrescente.
• Se i = 3 escrever os três valores a, b, c de forma que o maior
número entre a,b,c fique entre
os dois e o menor fique por último.
#include<stdio.h>
#include<math.h>
#include<string.h>
int main()
{
int a, b, c, i;
scanf("%d",&i);
scanf("%d",&a);
scanf("%d",&b);
scanf("%d",&c);
if (i == 1){
if (a > b && a > c && b > c){
printf("%d%d%d",c,b,a);
}
else if (a > b && a > c && c > b){
printf("%d%d%d",b,c,a);
}
else if ( b > a && b > c && a > c){

printf("%d%d%d",c,a,b);
}
else if ( b > a && b > c && c > a){

printf("%d%d%d",a,c,b);
}
else if ( c > a && c > b && b > a){

printf("%d%d%d",a,b,c);
}
else if ( c > a && c > b && a > b){

printf("%d%d%d",b,a,c);
}
}
if ( i == 2){
if (a < b && a < c && b < c){

}
else if (a < b && a < c && c < b){

}
else if ( b < a && b < c && a < c){

}
else if ( b < a && b < c && c < a){

}
else if ( c < a && c < b && b < a){

}
else if ( c < a && c < b && a < b){
}
}
if ( i == 3 ){
if (a < b && a < c && b < c){

}
else if (a < b && a < c && c < b){

}
else if ( b < a && b < c && a < c){

}
else if ( b < a && b < c && c < a){

}
else if ( c < a && c < b && b < a){

}
else if ( c < a && c < b && a < b){

}
return 0;
}
55. Construa um algoritmo que calcule e escreva o custo e a

quantidade de latas de tinta necessárias, para pintar tanques
cilíndricos de combustível. É fornecida as seguintes informações: o
preço da lata de 5 litros, o raio e a altura dos tanques
cilíndricos. Cada litro de tinta pinta 3 metros quadrados.
#include<math.h>
#include<stdio.h>
#include<string.h>
#define pi 3.1415
int main(){
float precolata, altura, arealateral, areadabase, areatotal,

custo;
int raio, quantidadelatas;
scanf("%f",&precolata);
scanf("%d",&raio);
areadabase = pi * pow(raio,2);
arealateral = 2 * pi * raio * altura;
areatotal = (2 * areadabase) + arealateral;
quantidadelatas = areatotal / 15;

custo = quantidadelatas * precolata;
printf("QUANTIDADE DE LATAS = %d\n",quantidadelatas);

printf("CUSTO = %.2f\n",custo);
return 0;
56. Desenvolver um algoritmo para calcular e imprimir o preço

final de um carro. O valor do preço
inicial de fábrica é fornecido por meio de entrada. O carro pode
ter as seguintes opções:
• (a) Ar condicionado: R$ 1750,00
• (b) Pintura Metálica: R$ 800,00
• (c) Vidro Elétrico: R$ 1200,00
• (d) Direção Hidráulica: R$ 2000,00
#include<math.h>
#include<stdio.h>
#include<string.h>
int main(){
char resposta1[10], resposta2[10], resposta3[10],
resposta4[10];
float precofinal, precocarro, v1, v2, v3, v4;
scanf("%f",&precocarro);
scanf("%s",resposta1);
if (strcmp(resposta1,"SIM")== 0){
v1 = 1750.00;
}
v2 = 800.00;
v3 = 1200.00;
v4 = 2000.00;
}
precofinal = precocarro + v1 + v2 + v3 + v4 ;
printf("PRECO FINAL = %.2f\n",precofinal);
return 0;
}
57. Desenvolver um algoritmo que calcule o salário bruto e

líquido de um funcionário.
#include<math.h>
#include<stdio.h>
#include<string.h>
#define salariominimo 136.00
#define salariohora_extra 10.00
int main(){
float salariobruto, salarioliquido, horasextrasreceber,

descontoinss, descontoimpostoderenda;
int horaextras;
char nome[20];
scanf("%s",nome);
scanf("%d",&horaextras);
horasextrasreceber = horaextras * salariohora_extra;

salariobruto = salariominimo + horasextrasreceber;
descontoimpostoderenda = 0;
descontoinss = 0;
if (salariobruto > 1500){

descontoinss = salariobruto * 0.12;
}
if (salariobruto > 2000){

descontoimpostoderenda = salariobruto * 0.2 ;
}
salarioliquido = salariobruto - (descontoinss +

descontoimpostoderenda);
printf("SALARIO BRUTO = %.2f\n",salariobruto);

printf("SALARIO LIQUIDO = %.2f\n",salarioliquido);
return 0;
}
58. Números palíndromos são aqueles que escritos da direita para

a esquerda ou da esquerda para a
direita tem o mesmo valor. Ex.: 929, 44, 97379. Fazer um
algoritmo que dado um número de 5
dígitos; calcular e escrever se este número é palíndromo.
#include<math.h>
#include<stdio.h>
#include<string.h>
int main(){
int n1,n2,n3,n4,n5,numero,aux, inverter;
n1 = numero / 10000;
aux = numero % 10000;
n2 = aux / 1000;
aux = aux % 1000;
n3 = aux / 100;
aux = aux % 100;
n4 = aux / 10;
n5 = aux % 10;
inverter = (n5 * 10000) + (n4 * 1000) + (n3 * 100) + (n2 *

10) + n1;
if (numero == inverter){
printf("O NUMERO E PALINDROMO\n");
}
else {
printf("O NUMERO NAO E PALINDROMO\n");
}
return 0;
}
59. Números quadrados perfeitos são aqueles cuja raiz quadrada é

um número inteiro. Fazer um algoritmo que dado um número inteiro
positivo, calcule se ele é ou não um quadrado perfeito.
#include<math.h>
#include<stdio.h>
#include<string.h>
int main(){
int numero, verificaint;

float verificar, intoufloat;
verificar = sqrt(numero);
verificaint = verificar;
intoufloat = verificar - verificaint;
if (intoufloat == 0){
printf("E QUADRADO PERFEITO\n");
}
else {
printf("NAO E QUADRADO PERFEITO\n");
}
return 0;
}
60.O número 3025 possui a seguinte característica:

30 + 25 = 55
55² = 3025
Fazer um algoritmo que dado um número de 4 dígitos calcule e
escreva se este número possui ou não tal característica.
#include<math.h>
#include<stdio.h>
#include<string.h>
int main(){
int numero, n1, n2, n3, n4, aux, primeira, segunda, soma,
calculo;
n1 = numero / 1000;
aux = numero % 1000;
n2 = aux / 100;
aux = aux % 100;
n3 = aux / 10;
n4 = aux % 10;
primeira = (n1 * 10 ) + n2;

segunda = (n3 * 10 ) + n4;
soma = primeira + segunda;
calculo = pow(soma,2);
if (calculo == numero){
printf("O NUMERO POSSUI TAL CARACTERISTICA\n");
}
else {
printf("O NUMERO NAO POSSUI TAL CARACTERISTICA\n");
}
return 0;
}
61. Um banco concederá um crédito especial aos seus clientes,

variável com saldo médio no último ano. Faça um algoritmo que leia o
saldo médio de um cliente e calcule o valor do crédito de acordo com
a tabela abaixo. Mostre uma mensagem informando o saldo médio e o
valor de crédito (a porcentagem aplicada sobre o saldo médio).
#include<math.h>
#include<stdio.h>
#include<string.h>
int main(){
float saldomedio, credito;
scanf("%f",&saldomedio);
if (saldomedio < 200){

credito = 0;
}
else if (saldomedio > 201 && saldomedio < 400){

credito = 0.2 * saldomedio;
printf("SALDO MEDIO = %.2f\n",saldomedio);
printf("VALOR DO CREDITO = %.2f\n",credito);
}
else if (saldomedio > 401 && saldomedio < 600){

}
else if (saldomedio > 601){

}
return 0;
}
62. Um vendedor necessita de um algoritmo que calcule o preço

total devido por um cliente. O algoritmo deve receber o código de um
produto e a quantidade comprada e calcular o preço total, usando a
tabela abaixo:
#include<math.h>
#include<stdio.h>
#include<string.h>
int main(){
char cod_prod[10];
int quantidade;
float total;
scanf("%s",cod_prod);
scanf("%d",&quantidade);
if ( strcmp(cod_prod,"1001") == 0){
total = 5.32 * quantidade;
printf("PRECO TOTAL = %.2f\n",total);
}
else if ( strcmp(cod_prod,"1234") == 0){
}
}
}
}
else {
printf("CODIGO INVALIDO\n");
}
return 0;
}
63. Um vendedor necessita de um algoritmo que calcule o preço
total devido por um cliente. O algoritmo deve receber o código de um
produto e a quantidade comprada e calcular o preço total, usando a
tabela abaixo. Mostre uma mensagem no caso de código inválido.
#include<math.h>
#include<stdio.h>
#include<string.h>
int main(){
float precototal;
char cod_produto[10];
int quantidade;
scanf("%s",cod_produto);
scanf("%d",&quantidade);
if (strcmp(cod_produto,"ABCD") == 0 ){
precototal = 5.30 * quantidade;
printf("PRECO TOTAL = %.2f\n",precototal);
}
else if (strcmp(cod_produto,"XYKT") == 0 ){
}
else if (strcmp(cod_produto,"BTSD") == 0 ){
}
else if (strcmp(cod_produto,"YPOV") == 0 ){
}
else {
printf("ENTRADA INVALIDA\n");
}
return 0;
}
64. Uma empresa concederá uma aumento de salário aos seus

funcionários, variável de acordo com o cargo, conforme a tabla
abaixo. Faça um algoritmo que leia o salário e o cargo de um
funcionário e calcule o novo salário. Se o cargo do funcionário não
estiver na tabela, ele deverá, receber 40% de aumento. Mostre o
salário antigo , o novo salário e a diferença.
#include<math.h>
#include<stdio.h>
#include<string.h>
int main(){
float salario, aumento, novosalario, diferencas;

char cargo[15];
scanf("%f",&salario);
scanf("%s",cargo);
if (strcmp(cargo,"GERENTE") == 0){
aumento = 0.1 * salario;
novosalario = salario + aumento;
diferencas = novosalario - salario;
printf("ANTIGO SALARIO = %.2f\n",salario);
printf("NOVO SALARIO = %.2f\n",novosalario);
printf("DIFERENCA ENTRE SALARIOS = %.2f\n",diferencas);
}
else if (strcmp(cargo,"ENGENHEIRO") == 0){

}
else if (strcmp(cargo,"TECNICO") == 0){

}
else{
}
return 0;
}
65. Escrever um algoritmo que lê o número de identificação, as 3

notas obtidas por um aluno nas 3 verificações e a média dos
exercícios que fazem parte da avaliação. Calcular a média de
aproveitamento, usando a fórmula:
MA = ( Nota1? Nota2*2?Nota3*3?ME ) / 7
#include<math.h>
#include<stdio.h>
#include<string.h>
int main(){
int n_inscricao;
float nota1, nota2, nota3, mediaexercicios,
mediaaproveitamento;
scanf("%d",&n_inscricao);
scanf("%f",&mediaexercicios);
scanf("%f",&nota1);
scanf("%f",&nota2);
scanf("%f",&nota3);
mediaaproveitamento = ((nota1 + (nota2 * 2 )) + (( nota3 * 3

) + mediaexercicios )) / 7;
if (mediaaproveitamento >= 9.1 && mediaaproveitamento <=

10){
printf("NUMERO DE IDENTIFICACAO = %d\n",n_inscricao);
printf("MEDIA DOS EXERCICIOS = %.2f\n",mediaexercicios);
printf("MEDIA DE APROVEITAMENTO =
%.2f\n",mediaaproveitamento);
printf("CONCEITO A, ALUNO APROVADO\n");
}
else if (mediaaproveitamento >= 7.6 && mediaaproveitamento

<= 9){
printf("CONCEITO B, ALUNO APROVADO\n");
}

<= 7.5){
printf("CONCEITO C, ALUNO APROVADO\n");
}

<= 6.0){
printf("CONCEITO D, ALUNO REPROVADO\n");
}
else if (mediaaproveitamento <= 4){

printf("CONCEITO E, ALUNO REPROVADO\n");
}
return 0;
}
66. Fazer um algoritmo que leia os dados de um usuário de

telefonia de uma empresa de telecomunicações: bairro e número
completo do telefone e verifique se o número do telefone (Exemplo:
2121212) está correto, ou seja, se o prefixo (3 primeiros dígitos) é
correspondente ao bairro especificado. Sabendo-se que os prefixos
existem nos bairros conforme a tabela abaixo:
#include<math.h>
#include<stdio.h>
#include<string.h>
int main(){
char bairro[15];
int prefixo, n1, n2, n3 ,aux , compareprefixo;
scanf("%s",bairro);
scanf("%d",&prefixo);
n1 = prefixo / 1000000;
aux = prefixo % 1000000;
n2 = aux / 100000;
aux = aux % 100000;
n3 = aux / 10000;
compareprefixo = (n1 * 100) + ( n2 * 10 ) + n3;
if ((strcmp(bairro,"OESTE") == 0 || strcmp(bairro,"VILA
NOVA") == 0 || strcmp(bairro,"COIMBRA") == 0) && (compareprefixo ==
223 || compareprefixo == 225 || compareprefixo ==212 ||
compareprefixo == 243)){
printf("O TELEFONE ESTA CORRETO\n");

}
else if ((strcmp(bairro,"CENTRO") == 0 ||
strcmp(bairro,"UNIVERSITARIO") == 0 || strcmp(bairro,"SUL") == 0) &&
(compareprefixo == 223 || compareprefixo == 224 || compareprefixo ==
215 || compareprefixo == 295)) {

}
else if ((strcmp(bairro,"BUENO") == 0 ||
strcmp(bairro,"CAMPINAS") == 0 || strcmp(bairro,"LESTE") == 0 ) &&
(compareprefixo == 215 || compareprefixo == 212 || compareprefixo ==
291 || compareprefixo == 268)){

}
else {
printf("O TELEFONE ESTA INCORRETO\n");
}
return 0;
}
67. Fazer um algoritmo que receba a idade e o nome de um nadador

e imprima o nome, a idade e a categoria do nadador seguindo as
seguintes regras:
#include<math.h>
#include<stdio.h>
#include<string.h>
int main(){
int idade;
char nome[20];
scanf("%d",&idade);
scanf("%s",nome);
if (idade >= 5 && idade <= 10){

printf("%s\n",nome);
printf("%d\n",idade);
printf("INFANTIL\n");
}
else if (idade >= 11 && idade <= 17){
printf("JUVENIL\n");
}
else if (idade >= 18 ){
printf("SENIOR\n");
}
return 0;
}
68. Elabore um algoritmo que leia o valor de dois números

inteiros e a operação aritmética desejada. Calcule, então, a
resposta adequada. Utilize os símbolos da tabela a seguir para ler
qual operação aritmética escolhida.
#include<math.h>
#include<stdio.h>
#include<string.h>
int main(){
int codigo;
float valorproduto, calculo;
scanf("%d",&codigo);
scanf("%f",&valorproduto);
if (codigo == 1){
calculo = valorproduto - (0.1 * valorproduto);
}
else if (codigo == 2){

}

calculo = valorproduto;
}

calculo = valorproduto + (0.1 * valorproduto);
}
printf("PRECO FINAL = %.2f\n",calculo);
return 0;
}
69. Elabore um algoritmo que calcule o que deve ser pago por um
produto considerando o preço normal de etiqueta e a escolha da
condição de pagamento. Utilize os códigos da tabela para ler qual a
condição de pagamento escolhido e efetuar o cálculo adequado.
#include<math.h>
#include<stdio.h>
#include<string.h>
int main(){
int codigo;
float valorproduto, calculo;
scanf("%d",&codigo);
scanf("%f",&valorproduto);
if (codigo == 1){
}

}

calculo = valorproduto;
}

calculo = valorproduto + (0.1 * valorproduto);
}
printf("PRECO FINAL = %.2f\n",calculo);

return 0;
}
70. A cidade de Perdiz das Cruzes possui um único posto
telefônico. Por este posto são feitas todas as
ligações interurbanas da cidade. O valor a se pago e calculado
seguindo as seguintes regras:
? Taxa de R$2,00 pela ligação, R$1,00 para os 3 primeiros
minutos;
? Acima do três primeiros minutos as regras são de R$1,50 para
cada intervalo de 5 minutos e R$0.25 para cada minuto abaixo disto.
#include<math.h>
#include<stdio.h>
#include<string.h>
int main(){
char nome[20];
int tempo, aux1, aux2,novotempo;
float calculo, total, restohoras;
scanf("%s",nome);
scanf("%d",&tempo);
if (tempo <= 3){

calculo = 3;
printf("USUARIO = %s\n",nome);
printf("CONTA = %.2f\n",calculo);
}
else if (tempo > 3){

novotempo = tempo - 3;
aux1 = novotempo / 5;
aux2 = novotempo % 5;
calculo = aux1 * 1.50;
restohoras = aux2 * 0.25;
total = 3 + calculo + restohoras;
printf("USUARIO = %s\n",nome);
printf("CONTA = %.2f\n",total);
}
return 0;
71. A Distribuidora de Combustíveis Ave Maria ira dar um

aumento em função da quantidade de combustível comprado anualmente
por seus clientes. Os postos que consomem em média até 50.000
litros de combustível ao mês, terão aumento de
20%. Os postos que consomem acima desta média, 12% de
aumento. A distribuidora ira fornecer o nome do posto e seu consumo
anual. Calcule e escreva qual será o preço do litro de combustível
para o posto, levando-se em conta que hoje a distribuidora cobra
R$1.63 por litro.
#include<math.h>
#include<stdio.h>
#include<string.h>
int main(){
int consumoanual;
char nome[10];
float valorlitro;
scanf("%s",nome);
scanf("%d",&consumoanual);
if (consumoanual <= 50000){

valorlitro = (0.2 * 1.63) + 1.63 ;
printf("PRECO REAJUSTADO = %.2f\n",valorlitro);
}
else if (consumoanual > 50000){

valorlitro = (0.12 * 1.63) + 1.63;
printf("PRECO REAJUSTADO = %.2f\n",valorlitro);
}
return 0;
}
73. Fazer um algoritmo que:
• Leia um número indeterminado de linhas contendo cada uma a

idade de um indivíduo. A última linha, que não entrara nos cálculos,
contem o valor da idade igual a zero.
• Calcule e escreva a idade média deste grupo de indivíduos.
#include<math.h>
#include<stdio.h>
int main(){
int idade, soma, count;

float media;
soma = 0;
count = 0;
scanf("%d",&idade);
while (idade > 0){

soma += idade;
count++;
scanf("%d",&idade);
}
media = (float)soma / (float)count;
printf("IDADE MEDIA = %.2f\n",media);
return 0;
}
74. Tem-se um conjunto de dados contendo a altura e o sexo

(masculino, feminino). Fazer um algorítimo que calcule e escreva:
• A maior e a menor altura do grupo;
• A média de altura das mulheres;
• O número de homens;
#include<stdio.h>
#include<string.h>
int main(){
int x ,i,numhomens=0,nummulheres=0;
float h,media =0,somahm=0,maioraltura=0,menoraltura=0;
char sexo[12];
scanf("%d",&x);
for(i=0 ; i <x ;i++){
scanf("%f",&h);
scanf("%s",sexo);
if(strcmp(sexo,"FEMININO")==0){
nummulheres++;
somahm = h+somahm;
media =somahm/nummulheres;
}
else if(strcmp(sexo,"MASCULINO")==0){
numhomens++;
}
if(h>maioraltura){
maioraltura =h;
menoraltura = maioraltura;
}
else if(h<menoraltura){
menoraltura =h;
}
}
printf("MAIOR ALTURA = %.2f\n",maioraltura);
printf("MENOR ALTURA = %.2f\n",menoraltura);
printf("MEDIA DAS MULHERES = %.2f\n",media);
printf("NUMERO DE HOMENS = %d\n",numhomens);
return 0;
}
75. A conversão de graus Fahrenheit para centígrados e

obtido por C = 5 / 9 ( F – 32 ). Fazer um algoritmo que calcule e
escreva uma tabela de centígrados em função de graus Fahrenheit, que
variam de 50 a 150 de 1 em 1.
(Obs.: a fórmula dada não está errada).
#include<math.h>
#include<stdio.h>
#include<string.h>
int main(){
int fahrenheit;
float centigrados=0;
for (fahrenheit = 50; fahrenheit <= 150; fahrenheit++){
centigrados = (float)5 / 9 * (fahrenheit - 32);

printf("Valor de F = %d Valor de C =
%.2f\n",fahrenheit, centigrados);
}
return 0;
}
76. Um comerciante deseja fazer o levantamento do lucro das

mercadorias que ele comercializa. Para isto, mandou digitar uma
linha para cada mercadoria com o nome, preço de compra e preço de
venda das mesmas. Fazer um algoritmo que:
#include<math.h>
#include<stdio.h>
#include<string.h>
int main(){
int repetir, i, menor10 = 0, entre10e20 = 0, maior20 =

0;
char nome[20];
float precocompra, precovenda, calculo, totalvenda,
totalcompra, lucro, aux;
i = 0;
scanf("%d",&repetir);
while(i < repetir){

i++;
scanf("%s",nome);
scanf("%f",&precocompra);
scanf("%f",&precovenda);
totalcompra += precocompra;
totalvenda += precovenda;
lucro = totalvenda - totalcompra;
aux = precovenda - precocompra;

calculo = (float)(100 * aux) / precocompra;
if (calculo < 10){

menor10++;
}
else if (calculo >= 10 && calculo <= 20){
entre10e20++;
}
else if (calculo > 20){
maior20++;
}
}
printf("%d com lucro < 10%%\n",menor10);
printf("%d com lucro >= 10%% ou lucro <=
20%%\n",entre10e20);
printf("%d com lucro > 20%%\n",maior20);
printf("Total de compra = %.2f\n",totalcompra);
printf("Total de venda = %.2f\n",totalvenda);
printf("Lucro = %.2f\n",lucro);
return 0;
}
77. Supondo que a população de um país A seja de ordem de
90.000.000 de habitantes com uma taxa anual de crescimento de 3% e
que a população de um país B seja, aproximadamente, de 200.000.000
de habitantes com uma taxa anual de crescimento de 1,5%, fazer um
algoritmo que calcule e escreva o número de anos necessários para
que a população do país A ultrapasse ou iguale a população do país
B, mantidas essas taxas de crescimento.
#include<math.h>
#include<stdio.h>
#include<string.h>
int main(){
int anos ;
float a, b, calc1, calc2;
scanf("%f",&a);
scanf("%f",&b);
calc1 = a;
calc2 = b;
anos = 0;
while(calc1 < calc2){
calc1 = (0.03 * calc1) + calc1;

calc2 = (0.015 * calc2) + calc2;
anos++;
}
printf("ANOS = %d\n",anos);
return 0;
}
78. Um determinado material radioativo perde metade de sua

massa a cada 50 segundos. Dada a massa inicial, em gramas, fazer um
algorítimo que determine o tempo necessário para que essa massa se
torne menor do que 0,5 gramas. Escreva a massa inicial, a massa
final e o tempo calculado em horas, minutos e segundos.
#include<math.h>
#include<stdio.h>
int main() {
float massa, aux;

int aux2, hora, minuto, segundo, tempo;
scanf("%f",&massa);
tempo = 0;
aux = massa;
while(aux >= 0.5){
aux = aux / 2;
tempo = tempo + 50;
}
hora = tempo / 3600;
aux2 = tempo % 3600;
minuto = aux2 / 60;
segundo = aux2 % 60;
printf("MASSA INICIAL = %.2f\n",massa);

printf("MASSA FINAL = %.2f\n",aux);
printf("TEMPO = %dH %dM %dS\n",hora,minuto,segundo);
return 0;
80. Uma certa firma fez uma pesquisa de mercado para saber
se as pessoas gostaram ou não de um novo produto lançado no mercado.
Para isso, forneceu o sexo do entrevistado e sua resposta ( sim ou
não).
#include<math.h>
#include<stdio.h>
#include<string.h>
int main(){
int qnt, cont, conth_sim = 0, conth_nao = 0, contf_sim =

0, contf_nao = 0 , totalsim = 0, totalnao = 0, contmulheres = 0,
conthomens = 0;
float porc_h = 0, porc_f = 0;
char sexo[10], resposta[5];
scanf("%d",&qnt);
for (cont =0; cont<qnt; cont++ ){

scanf("%s",sexo);
scanf("%s",resposta);
if (strcmp(sexo,"MASCULINO") == 0 &&
strcmp(resposta,"SIM") == 0){
conth_sim++;
}
else if (strcmp(sexo,"MASCULINO") == 0 &&

strcmp(resposta,"NAO") == 0){
conth_nao++;
}
if (strcmp(sexo,"FEMININO") == 0 &&
strcmp(resposta,"SIM") == 0){
contf_sim++;
}
else if (strcmp(sexo,"FEMININO") == 0 &&

strcmp(resposta,"NAO") == 0){
contf_nao++;
}
totalsim = contf_sim + conth_sim;

totalnao = contf_nao + conth_nao;
contmulheres = contf_sim + contf_nao;
porc_f = (float)(100 * contf_sim) / contmulheres;
conthomens = conth_sim + conth_nao;
porc_h = (float)(100 * conth_nao) / conthomens;
printf("SIM = %d\n",totalsim);
printf("NAO = %d\n",totalnao);
printf("FEMININO - SIM = %.2f\n",porc_f);
printf("MASCULINO - NAO = %.2f\n",porc_h);
return 0;
}
81. Foi feita uma pesquisa para determinar o índice de

mortalidade infantil em um certo período. Fazer um algoritmo que:
• Leia inicialmente o número de crianças nascidas no
período;
• Leia, em seguida, um número indeterminado de linhas,
contendo, cada uma, o sexo de uma
criança morta ( masculino, feminino ) e o número de meses de
vida da criança. A última linha, que não entrara nos cálculos,
contém no lugar do sexo a palavra “VAZIO” ;
Determine e imprima:
• A porcentagem de crianças mortas no período;
• A porcentagem de crianças do sexo masculino mortas no
período;
• A porcentagem de crianças que viveram 24 meses ou menos no
período;
#include<math.h>
#include<stdio.h>
#include<string.h>
int main(){
int numerocriancas, mesesvida, contcrianca = 0,

contcriancamasculino = 0, contmenos24 = 0;
float porcentagemmortas, porcentagemmasculinomortas,
porcentagemmenores24;
char sexo[10];
scanf("%d",&numerocriancas);
scanf("%s",sexo);
scanf("%d",&mesesvida);
while (strcmp(sexo,"VAZIO") != 0){

contcrianca++;
contcriancamasculino++;
}
if (mesesvida <= 24){

contmenos24++;
}
scanf("%s",sexo);
scanf("%d",&mesesvida);
}
porcentagemmortas = (float) (contcrianca * 100) /

numerocriancas;
porcentagemmasculinomortas = (float)
(contcriancamasculino * 100) / numerocriancas;
porcentagemmenores24 = (float) (contmenos24 * 100) /
numerocriancas;
printf("PORCENTAGEM DE MORTOS =
%.2f\n",porcentagemmortas);
printf("PORCENTAGEM DE MASCULINOS MORTOS =
%.2f\n",porcentagemmasculinomortas);
printf("PORCENTAGEM DE MENOS DE 24 MESES =
%.2f\n",porcentagemmenores24);
return 0;
}
82. Uma universidade deseja fazer um levantamento a respeito

de seu concurso vestibular. Para cada curso, e fornecido o seguinte
conjunto de valores:
• O código do curso;
• Número de vagas;
• Número de candidatos do sexo masculino;
• Número de candidatos do sexo feminino;
O último conjunto, para indicar fim de dados, contem o
código do curso igual a zero. Fazer um algoritmo que:
• Calcule e escreva, para cada curso, o número de candidatos
por vaga e a porcentagem de candidatos do sexo feminino ( escreva
também o código correspondente do curso );
• Determine o maior número de candidatos por vaga e escreva
esse número juntamente com o código do curso correspondente ( supor
que não haja empate );
• Calcule e escreva o total de candidatos;
#include<math.h>
#include<stdio.h>
#include<string.h>
int main(){
int cod_curso = 0, num_vagas = 0, cand_masc = 0,

cand_fem = 0, cand_soma = 0, maiorcurso = 0;
float porc_fem = 0, cand_por_vaga = 0, maior_cand_vaga =
0, total_cand = 0;
scanf("%d",&cod_curso);
scanf("%d",&num_vagas);
scanf("%d",&cand_masc);
scanf("%d",&cand_fem);
while( cod_curso != 0){
cand_soma = cand_masc + cand_fem;

cand_por_vaga = (float) cand_soma / num_vagas ;
porc_fem = (float)(100 * cand_fem) / cand_soma;
if (cand_por_vaga > maior_cand_vaga){
maior_cand_vaga = cand_por_vaga;
maiorcurso = cod_curso;
}
else {
maior_cand_vaga = maior_cand_vaga;
printf("C/V = %.2f\n",cand_por_vaga);
printf("PORCENTAGEM F = %.2f\n",porc_fem);
total_cand += cand_soma;
scanf("%d",&cod_curso);
scanf("%d",&num_vagas);
scanf("%d",&cand_masc);
scanf("%d",&cand_fem);
}
printf("MAIOR NUMERO DE C/V = %.2f do curso
%d\n",maior_cand_vaga,maiorcurso);
printf("TOTAL DE CANDIDATOS = %.2f\n",total_cand);
return 0;
}
83. Deseja-se fazer uma pesquisa a respeito do consumo mensal de

energia elétrica em uma determinada cidade. Para isso, são
fornecidos os seguintes dados:
• Número do consumidor;
• Preço do Kw consumido;
• Quantidade de Kw consumido durante um mês;
• Código do tipo de consumidor ( residencial, industrial,
comercial );
O número do consumidor igual a zero deve ser usado como flag.
Fazer um algoritmo que:
Leia os dados descritos acima
#include<math.h>
#include<stdio.h>
#include<string.h>
int main(){
int num_consumidor = 0, qnt_consumido = 0, maiorconsumo = 0,

menorconsumo = 0, cod_res = 0, cod_ind = 0, cod_com = 0, i = 0;
float preco_consumo = 0, totalpagar = 0, media = 0,
somaqnt_consumido = 0;
char cod_tipo_consumidor[20];
scanf("%d",&num_consumidor);
scanf("%f",&preco_consumo);
scanf("%d",&qnt_consumido);
scanf("%s",cod_tipo_consumidor);
while( num_consumidor != 0){
totalpagar = qnt_consumido * preco_consumo;
printf("NUMERO = %d\n",num_consumidor);
printf("TOTAL A PAGAR = %.2f\n",totalpagar);
if (qnt_consumido > maiorconsumo){

menorconsumo = maiorconsumo;
maiorconsumo = qnt_consumido;
else{
maiorconsumo = maiorconsumo;
menorconsumo = qnt_consumido;
if (menorconsumo == 0){
menorconsumo = maiorconsumo;
}
if (strcmp(cod_tipo_consumidor,"RESIDENCIAL") == 0){
cod_res += qnt_consumido;
}
else if (strcmp(cod_tipo_consumidor,"COMERCIAL") == 0){

cod_com += qnt_consumido;
}
else if (strcmp(cod_tipo_consumidor,"INDUSTRIAL") == 0){

cod_ind += qnt_consumido;
}
i++;
somaqnt_consumido += qnt_consumido;
media = (float)somaqnt_consumido / i;
scanf("%d",&num_consumidor);
scanf("%f",&preco_consumo);
scanf("%d",&qnt_consumido);
scanf("%s",cod_tipo_consumidor);
}
printf("MAIOR CONSUMO = %d\n",maiorconsumo);
printf("MENOR CONSUMO = %d\n",menorconsumo);
printf("CONSUMIDOR RESIDENCIAL = %d\n",cod_res);
printf("CONSUMIDOR COMERCIAL = %d\n",cod_com);
printf("CONSUMIDOR INDUSTRIAL = %d\n",cod_ind);
printf("MEDIA = %.2f\n",media);
return 0;
}
84. Tem-se uma estrada ligando várias cidades. Cada cidade tem
seu marco quilométrico. Fazer um algoritmo que:
• Leia vários pares de dados, contendo cada par de dados os
valores dos marcos quilométrico, em ordem crescente, de duas
cidades. O último par contém estes dois valores iguais;
• Calcule os tempos decorridos para percorrer a distância entre
estas duas cidades, com as seguintes velocidades: 20, 30, 40, 50,
60, 70 e 80 Km/h, sabendo-se que:
T = E / V, onde :
• T = tempo
• E = especo
• V = velocidade
Escreva os marcos quilométricos, a velocidade e o tempo
decorrido entre as duas cidades, apenas quando este tempo dor
superior a 2 horas:
#include<math.h>
#include<stdio.h>
#include<string.h>
int main(){
float marco1, marco2, tempo = 0, distancia =0;

int i = 1,velocidade = 0;
scanf("%f",&marco1);
while ( marco1 != marco2){
printf("MARCO 1 = %.2f\n",marco1);
printf("MARCO 2 = %.2f\n",marco2);
i++;
velocidade = i * 10;
distancia = marco2 - marco1;
tempo = (float)distancia / velocidade;
while ( tempo >= 2 && i <= 8){

printf("VELOCIDADE = %dKm/h DECORREU O TEMPO DE %.1f
HORAS\n",velocidade,tempo);
i++;
velocidade = i * 10;
distancia = marco2 - marco1;
tempo = (float)distancia / velocidade;
}
i = 1;
}
return 0;
}
85. Uma empresa decidiu fazer um levantamento em relação aos

candidatos que se apresentarem para preenchimento de vagas no seu
quadro de funcionários, utilizando processamento eletrônico.
#include<math.h>
#include<stdio.h>
#include<string.h>
int main(){
int qnt = 0, numero, i,idade, m_inf_35anos = 0, masc_exp= 0,

qnt_cand_masc = 0, qnt_cand_fem = 0, qnt_mas_45anos = 0,
menoridade_f = 0;
float mediacand_mas = 0;
char sexo[10], experiencia[10];
scanf("%d",&qnt);
for(i = 0; i < qnt; i++){
scanf("%d",&idade);
scanf("%s",sexo);
scanf("%s",experiencia);
if(strcmp(sexo,"FEMININO")==0){
qnt_cand_fem++;
if(strcmp(experiencia,"SIM")==0){
if (idade < 35){

m_inf_35anos++;
}
if (qnt_cand_fem == 1){
menoridade_f = idade;
}
else if (idade < menoridade_f){

menoridade_f = idade;
}
}
}
else{
qnt_cand_masc++;
if (strcmp(experiencia,"SIM")== 0){
masc_exp++;
}
if(idade > 45){

qnt_mas_45anos++;
}
}
}
mediacand_mas = ((float) masc_exp / qnt_cand_masc) * 100;
printf("MULHERES INSCRITAS COM EXPERIENCIA E IDADE MENOR QUE 35
ANOS = %d\n",m_inf_35anos);
printf("CANDIDATOS MASCULINOS = %d\n",qnt_cand_masc);
printf("CANDIDATOS FEMININOS = %d\n",qnt_cand_fem);
printf("MEDIA DE HOMENS COM EXPERIENCIA =
%.2f\n",mediacand_mas);
printf("HOMENS COM MAIS DE 45 ANOS = %d\n",qnt_mas_45anos);
printf("MENOR IDADE DE MULHER COM EXPERIENCIA =
%d\n",menoridade_f);
return 0;
}
86. Uma companhia de teatro planeja dar uma série de espetáculos. A

direção calcula que, a R$ 5,00 o ingresso, serão vendidos 120
ingressos, e as despesas montarão em R$ 200,00. A uma diminuição de
R$ 0,50 no preço dos ingressos espera-se que haja um aumento de 26
ingressos vendidos. Fazer um algoritmo que escreva uma tabela de
valores do lucro esperado em função do preço do ingresso, fazendo-se
variar este preço de R$ 5,00 a R$ 1,00 de R$ 0,50 em R$ 0,50.
Escreva, ainda o lucro máximo esperado, o preço e o número de
ingressos correspondentes.
#include<math.h>
#include<stdio.h>
#include<string.h>
int main(){
float lucroesperado, i, ingressos, lucromaximo = 0, dopreco = 0,

totalingressos = 0;
ingressos = 120;
lucroesperado = (ingressos * 5.0 - 200);
for (i = 5 ; i >= 1.0; i--){

if (i == 5.0){
printf("PRECO = %.1f LUCRO ESPERADO =
%.2f\n",i,lucroesperado);
}
else{
ingressos += 26;
lucroesperado = (i * ingressos) - 200;
printf("PRECO = %.1f LUCRO ESPERADO =

%.2f\n",i,lucroesperado);
}
if ( lucromaximo == 0){
lucromaximo = lucroesperado;
dopreco = i;
totalingressos = ingressos;
}
else if (lucroesperado > lucromaximo){

lucromaximo = lucroesperado;
dopreco = i;
totalingressos = ingressos;
}
i = i + 0.5;
}
printf("LUCRO MAXIMO = %.2f DO PRECO = %.2f NUMERO DE INGRESSOS
VENDIDOS = %.2f\n",lucromaximo,dopreco,totalingressos);
return 0;
}
87. A comissão organizadora de um rallye automobilístico decidiu

apurar os resultados da competição através de um processamento
eletrônico. Um dos algoritmo necessários para a classificação das
equipes concorrentes e o que emite uma listagem geral do desempenho
das equipes, atribuindo pontos segundo determinadas normas. O
algoritmo devera:
#include<math.h>
#include<stdio.h>
#include<string.h>
int main(){
int numeroinscricao,insc_vencedora = 0;
float num1, num2, num3,tempopadrao1,tempopadrao2,tempopadrao3,
etapa1, etapa2, etapa3, ponto1 = 0, ponto2 = 0, ponto3= 0, soma = 0,
equipevencedora = 0;
scanf("%f",&tempopadrao1);
scanf("%d",&numeroinscricao);
scanf("%f",&num1);
scanf("%f",&num2);
scanf("%f",&num3);
while ( numeroinscricao != 9999){
etapa1 = tempopadrao1 - num1;

if (etapa1 < 3){

ponto1 = 100;
}
else if (etapa1 >= 3 && etapa1 <= 5){
ponto1 = 80;
}
else{
ponto1 = 80 - ((etapa1 - 5) / 5);
}
if (etapa2 < 3){

ponto2 = 100;
}
ponto2 = 80;
}
else{
ponto2 = 80 - ((etapa2 - 5) / 5);
}
if (etapa3 < 3){

ponto3 = 100;
}
ponto3 = 80;
}
else{
ponto3 = 80 - ((etapa3 - 5) / 5);
}
soma = ponto1 + ponto2 + ponto3;
if (equipevencedora == 0){
equipevencedora = soma;
insc_vencedora = numeroinscricao;
}
else if(soma > equipevencedora){
equipevencedora = soma;
insc_vencedora = numeroinscricao;
}
printf("NUMERO DE INSCRICAO = %d\n",numeroinscricao);

printf("PONTOS ETAPA 1 = %.2f PONTOS\n",ponto1);
printf("TOTAL DE PONTOS = %.2f\n",soma);
scanf("%d",&numeroinscricao);
scanf("%f",&num1);
scanf("%f",&num2);
scanf("%f",&num3);
}
printf("EQUIPE VENCEDORA = %d COM O TOTAL DE PONTOS DE =

%.2f\n",insc_vencedora,equipevencedora);
return 0;
}
88. Numa certa loja de eletrodoméstico, o comerciário encarregado da

seção de televisores recebe, mensalmente, um salario fixo mais
comissão. Essa comissão e calculada em relação ao tipo e ao numero
de televidores vendidos por mês, obedecendo a tabela abaixo:
#include<math.h>
#include<stdio.h>
#include<string.h>
int main(){
int n_empregados, n_inscricao, num_tele_cor, num_tele_preto,

cont;
float salario_fixo, salariobruto =0, totalcor, totalpreto,
desconto, salarioliquido;
scanf("%d",&n_empregados);
for(cont = 0; cont < n_empregados; cont++){

scanf("%d",&n_inscricao);
scanf("%f",&salario_fixo);
scanf("%d",&num_tele_cor);
scanf("%d",&num_tele_preto);
if (num_tele_cor >= 10){

totalcor = num_tele_cor * 50.00;
}
else{
totalcor = num_tele_cor * 5.00;
}
if (num_tele_preto >= 20){

totalpreto = num_tele_preto * 20.00;
}
else{
totalpreto = num_tele_preto * 2.00;
}
desconto = 0.08 * salario_fixo;

printf("DESCONTO %.2f\n",desconto);
salariobruto = (salario_fixo + totalpreto + totalcor) -
desconto;
printf("NUMERO DE INSCRICAO = %d\n",n_inscricao);
printf("SALARIO BRUTO = %.2f\n",salariobruto);
if (salariobruto >= 500){

salarioliquido = salariobruto - (0.15 * salariobruto ) ;
}
else {
salarioliquido = salariobruto;
}
printf("SALARIO LIQUIDO = %.2f\n",salarioliquido);

}
return 0;
}
89. Numa fábrica trabalham homens e mulheres divididos em três

classes com os respectivos salários:
A – os que fazem ate 30 pecas por mês, salário mínimo;
B – os que fazem de 31 a 35 pecas por mês, salário mínimo e mais 3%
do salário mínimo por peca acima das 30 iniciais;
C – os que fazem mais de 35 pecas por mês, salário mínimo e mais 5%
do salário mínimo por peca acima das 30 iniciais;
#include<math.h>
#include<stdio.h>
#include<string.h>
int main(){
// Definindo Variaveis
int numerooper, qntpecas, somapecas = 0, contmasculino_a = 0,
contfeminino_a = 0, contmasculino_b = 0, contfeminino_b = 0,
contmasculino_c = 0, contfeminino_c = 0, pecas_a_masc = 0,
pecas_a_fem = 0,pecas_b_masc = 0, pecas_b_fem = 0,pecas_c_masc = 0,
pecas_c_fem = 0, maiorsalario=0;
float salario = 0, somasalarios = 0, mediapeca_a_mas = 0,
mediapeca_b_mas = 0,mediapeca_c_mas = 0,mediapeca_a_fem = 0,
mediapeca_b_fem = 0,mediapeca_c_fem = 0, verificavalor = 0;
char sexo[10];
// Lendo Variaveis
scanf("%d",&numerooper);
scanf("%d",&qntpecas);
scanf("%s",sexo);
// Iniciando Laco de repeticao com flag

while (numerooper != 0){
// Iniciando condicionais
if (qntpecas <= 30){
salario = 500.00;
printf("SALARIO OPERARIO = %.2f\n",salario);
contmasculino_a++;
pecas_a_masc += qntpecas;
}
else {
contfeminino_a++;
pecas_a_fem += qntpecas;
}
}
else if(qntpecas >= 31 && qntpecas <= 35){
salario = 500.00 +((qntpecas - 30) * (0.03 * 500));
contmasculino_b++;
pecas_b_masc += qntpecas;
}
else {
contfeminino_b++;
pecas_b_fem += qntpecas;
}
else if(qntpecas > 35 ){

salario = 500.00 +((qntpecas - 30) * (0.05 * 500));
contmasculino_c++;
pecas_c_masc += qntpecas;
}
else {
contfeminino_c++;
pecas_c_fem += qntpecas;
}
// Verificando maior salario

if (maiorsalario == 0){
maiorsalario = numerooper;
verificavalor = salario;
}
if (verificavalor > salario){

maiorsalario = maiorsalario;
}
else if(verificavalor < salario){
maiorsalario = numerooper;
verificavalor = salario;
}
//Somando Salarios
somasalarios += salario ;
//Somando Pecas
somapecas += qntpecas;
// Calculando Medias Masculinas por Peca

mediapeca_a_mas = (float)pecas_a_masc / contmasculino_a;
mediapeca_b_mas = (float)pecas_b_masc / contmasculino_b;
mediapeca_c_mas = (float)pecas_c_masc / contmasculino_c;
// Calculando Medias Femininas por Peca

mediapeca_a_fem = (float)pecas_a_fem / contfeminino_a;
mediapeca_b_fem = (float)pecas_b_fem / contfeminino_b;
mediapeca_c_fem = (float)pecas_c_fem / contfeminino_c;
// Lendo Variaveis
scanf("%d",&numerooper);
scanf("%d",&qntpecas);
scanf("%s",sexo);
printf("FOLHA MENSAL FABRICA = %.2f\n",somasalarios);

printf("TOTAL DE PECAS = %d\n",somapecas);
printf("MEDIA PECA HOMENS CLASSE A = %.2f\n",mediapeca_a_mas);
printf("MEDIA PECA HOMENS CLASSE B = %.2f\n",mediapeca_b_mas);
printf("MEDIA PECA HOMENS CLASSE C = %.2f\n",mediapeca_c_mas);
printf("MEDIA PECA MULHERES CLASSE A = %.2f\n",mediapeca_a_fem);
printf("MEDIA PECA MULHERES CLASSE B = %.2f\n",mediapeca_b_fem);
printf("MEDIA PECA MULHERES CLASSE C = %.2f\n",mediapeca_c_fem);
printf("NUMERO OPERARIO COM MAIOR SALARIO = %d\n",maiorsalario);
return 0;
}
90. Uma determinada fábrica de rádios possui duas linhas de montagem

distintas: standard e luxo. A linha de montagem standard comporta um
máximo de 24 operários. Cada rádio standard da um lucro de X reais e
gasta um homem dia para sua confecção. A linha de montagem luxo
comporta no máximo 32 operários, cada rádio luxo da um lucro de Y
reais e gasta 2 homens dia para para sua
confecção. A fábrica possui 40 operários. O mercado é capaz de
absorver toda a produção e o fabricante deseja saber qual esquema de
produção a adotar de modo a maximizar seu lucro diário. Fazer um
algoritmo que leia os valores de X e Y e escreva, para esse esquema
de lucro máximo, o número de operários na linha standard e na linha
luxo, o número de rádios standard e luxo
produzidos, e o lucro. Adote o valor do rádio standard igual a 50
reais, o de luxo igual a 80 reais e adote que o preço de custo é
igual a 20 e 50 reais consecutivos.
#include<math.h>
#include<stdio.h>
#include<string.h>
int main(){
int x, y, qntradio_standart, qntradio_luxo, qntoper_standart,

qntoper_luxo;
float lucrostandart, lucroluxo;
scanf("%d",&x);
scanf("%d",&y);
lucrostandart = x;
lucroluxo = y;
qntradio_standart = x / 30;
qntradio_luxo = y /30;
qntoper_standart = qntradio_standart * 1;
qntoper_luxo = qntradio_luxo * 2;
printf("O lucro do radio standard = %.2f\n", lucrostandart);

printf("O lucro do radio luxo = %.2f\n", lucroluxo);
printf("A quantidade de radio standard = %d\n",
qntradio_standart);
printf("A quantidade de radio luxo = %d\n", qntradio_luxo);
printf("A quantidade de operarios utilizados na producao do
radio standard = %d\n", qntoper_standart);
printf("A quantidade de operarios utilizados na producao do
radio luxo = %d\n", qntoper_luxo);
return 0;
92. Sejam P( x1, y1) e Q( x2, y2) dois pontos quaisquer do
plano. A sua distância é dada por:
d=??x2-x1)² + (y2-y1)²
Escrever um algoritmo que, lendo várias linhas onde cada uma contém
as coordenadas dos dois pontos, escreva para cada par de pontos
lidos a sua distância. A última linha contém as coordenadas x1 , x2
, y1 , y2 igual a zero.
#include<math.h>
#include<stdio.h>
#include<string.h>
int main(){
int x1,x2,y1,y2;
float distancia;
scanf("%d",&x1);
scanf("%d",&y1);
scanf("%d",&x2);
scanf("%d",&y2);
while(x1 != 0 || x2 != 0 || y1 != 0 || y2 != 0){
distancia = (float)sqrt(pow((x2-x1),2) + pow((y2-y1),2));
printf("A distancia entre (%d,%d) e (%d,%d) =

%.2f\n",x1,y1,x2,y2,distancia);
scanf("%d",&x1);
scanf("%d",&y1);
scanf("%d",&x2);
scanf("%d",&y2);
}
return 0;
}
O número de quatro algorismos, 3025 possui a seguinte

característica:
30 + 25 = 55
55² = 3025
Fazer um algoritmo para um programa que pesquise e imprima todos os
números de quatro algorismos, que apresentam tal característica.
Adote para teste, 2000 para o primeiro número.
#include<math.h>
#include<stdio.h>
#include<string.h>
int main(){
int i, soma, parte1, parte2, elevacao;
for( i =2000; i < 10000; i++){
parte1 = i /100;
parte2 = i %100;
soma = parte1 + parte2;
elevacao = pow(soma,2);
if( elevacao == i){

printf("%d\n",i);
}
}
return 0;
}
94. Capicuas são números que tem o mesmo valor, se lidos da esquerda
para a direita ou da direita para a esquerda. Ex.: 44, 323, etc.
Fazer um algoritmo que determine e escreva todos os números inteiros
menores que 10.000 que são quadrados perfeitos e capicuas ao mesmo
tempo.
#include<math.h>
#include<stdio.h>
#include<string.h>
int main(){
int i, ver_inteiro, d1, d2, d3, d4, restante, verifica;

float ver_float,raiz, aux;
for (i = 121; i < 10000; i++){
raiz = sqrt(i);
ver_float = raiz;
ver_inteiro = raiz;
aux = ver_float - ver_inteiro;
if (i /100 != 0){
d1 = i /100;
restante = i % 100;
d2 = restante / 10;
d3 = restante % 10;
verifica = (d3 * 100) + (d2 * 10) + d1;
}
else if (i / 1000 != 0){

d1 = i / 1000;
restante = d1 % 1000;
d2 = restante / 100;
restante = restante % 100;
d3 = restante / 10;
d4 = restante % 10;
verifica = (d4 * 1000) + (d3 * 100) + (d2 * 10) + d1;
if( (verifica == i) && (aux == 0)){

printf("%d\n",i);
}
}
return 0;
}
95. Faça um algorítimo que receba valores inteiros de uma matriz 5×2
e preencha um vetor inteiro de
tamanho 10. Imprima o vetor preenchido.
#include<math.h>
#include<stdio.h>
#include<string.h>
int main(){
int vetor[9], i;
for (i = 0; i < 10; i++){
scanf("%d",&vetor[i]);
printf("%d\n",vetor[i]);
}
return 0;
}
Leia números de matrículas de alunos e armazene-os em um vetor até o
vetor ser preenchido por 10 matrículas. Esses números são distintos,
ou seja, o vetor não armazenará valores repetidos.
#include<math.h>
#include<stdio.h>
#include<string.h>
int main(){
int vetor[10], numero, cont, posicao = 0 ;
while (posicao < 10){
if (posicao == 0){
vetor[posicao] = numero;
printf("%d\n",vetor[posicao]);
posicao++;
}
else{
for(cont = 0; (cont < posicao)&&(vetor[cont]!= numero);

cont++);
if (cont >= posicao){

vetor[posicao] = numero;
printf("%d\n",vetor[posicao]);
posicao++;
}
}
}
return 0;
}

Preencha um vetor com X números inteiros, em que o último número
lido seja 999 (o último número não fará parte do vetor). E imprima
o vetor na ordem inversa.
#include<math.h>
#include<stdio.h>
#include<string.h>
int main(void){
int contador = 0, numero, vetor[contador];
while (numero != 999){
if (contador == 0){
vetor[contador] = numero;
contador++;
}
else{
vetor[contador] = numero;
contador++;
}
}
if (numero == 999){
contador--;
}
while ( contador >= 0 ){
printf("%d\n",vetor[contador]);
contador--;
}
return 0;
}
98. Faça um programa que receba os valores de uma matriz de

ordem 3 e imprimia sua diagonal principal de trás para frente.
#include<math.h>
#include<stdio.h>
#include<string.h>
int main(void){
int matriz[3][3], linha = 0, coluna = 0;
for(linha = 0; linha < 3; linha++){
for (coluna = 0; coluna < 3; coluna++){

scanf("%d",&matriz[linha][coluna]);
}
for (linha = 2; linha >= 0; linha--){
for(coluna = 2; coluna >=0; coluna--){

if ( linha == coluna){
printf("%d\n",matriz[linha][coluna]);
}
}
}
return 0;
}

Leia um vetor contendo 10 números, que correspondem a matrículas
de alunos. Ler 3 matrículas e imprima uma mensagem informando se
eles estão ou não presentes no vetor.
#include<math.h>
#include<stdio.h>
#include<string.h>
int main(void){
int vetor[10],contagem, verificanumero, contagemverifica =

0, contemcerto = 0;
for(contagem = 0; contagem < 10; contagem++){
scanf("%d",&vetor[contagem]);
while (contagemverifica < 3){
scanf("%d",&verificanumero);
for(contagem = 0; contagem < 10; contagem++){
if (verificanumero == vetor[contagem]){
printf("A matricula %d esta presente no
sistema\n",verificanumero);
contemcerto++;
}
}
if(contemcerto == 0){
printf("A matricula %d nao esta presente no
sistema\n",verificanumero);
}
contagemverifica++;
contemcerto = 0;
}
return 0;
}

Preencha 3 vetores, o primeiro com a nota da primeira prova, o
segundo com a nota da segunda prova e o terceiro com a média das 2
primeiras notas, e imprima o resultado “APROVADO” para aqueles que
obtiverem uma média igual ou acima de 6, e “REPROVADO” para quem
obtiverem uma média abaixo de 6.
OBS.: Saia do laço quando a primeira nota for igual a -1.
#include<math.h>
#include<stdio.h>
#include<string.h>
int main(void){
int contador = 0;
float vetor[3],nota = 0 ;
scanf("%f",&nota);
while ( nota != -1){
vetor[contador] = nota;
contador++;
if (contador == 2){
vetor[contador] = (vetor[0] + vetor[1]) / 2;

printf("%.2f\n",vetor[contador]);
if(vetor[contador] >= 6){

}
else{
}
contador = 0;
}
scanf("%f",&nota);
}
return 0;
}
101. Preencha e imprima um vetor dos 20 primeiros números primos

começando com o número 5000.
#include <stdio.h>
#include <math.h>
#include <string.h>
int main(void)
{
int contador_vetor = 0, vetor[20], numeroprimo = 0, calculo

= 0,numero, contador_verificar;
for (numero = 5000; contador_vetor < 20 ; numero++){
for (contador_verificar = 1; contador_verificar <=

numero; contador_verificar++ ){
calculo = (numero % contador_verificar);
if (calculo == 0){
numeroprimo++;
}
}
if (numeroprimo == 2){
vetor[contador_vetor] = numero;
printf("%d\n",vetor[contador_vetor]);
contador_vetor++;
}
numeroprimo = 0;
}
return 0;
}
102. Fazer um algorítimo que leia os valores de um vetor inteiro
de tamanho 10, e imprima o valor da soma dos números ímpares
presentes neste vetor.
#include <stdio.h>
#include <math.h>
#include <string.h>
int main(void)
{
int vetor[10], somaimpares = 0, contador;
for(contador = 0; contador < 10; contador++){
scanf("%d",&vetor[contador]);
if (vetor[contador] % 2 != 0){
somaimpares += vetor[contador];
}
}
printf("%d\n",somaimpares);
return 0;
}
103. Fazer um algoritmo que leia os valores de duas matrizes 3×3

e imprima a mutiplicação das duas matrizes.
#include <stdio.h>
#include <math.h>
#include <string.h>
int main(void)
{
int matriz1[3][3], matriz2[3][3], matrizmult[3][3], linha,
coluna, i, j, k;
// Fazendo Scan da PRIMEIRA matriz :DD

for( coluna = 0; coluna < 3; coluna++){
scanf("%d",&matriz1[linha][coluna]);
}
}
// Fazendo Scan da SEGUNDA matriz :DD

scanf("%d",&matriz2[linha][coluna]);
}
}
// Zerando matriz da multiplicacao
for(i = 0; i < 3; i++){

for(j = 0; j < 3; j++){
matrizmult[i][j]= 0;
}
}
// Fazendo Multiplicacao de matrizes :/

for( i = 0; i < 3; i++){
for( j = 0; j < 3; j++){
for( k = 0; k < 3; k++) {
matrizmult[i][j] += matriz1[i][k] * matriz2[k][j];
}
}
}
// Imprimindo matriz mult

if( coluna == 2){
printf("%d\n",matrizmult[linha][coluna]);
}
else{
printf("%d ",matrizmult[linha][coluna]);
}
}
}
return 0;
}
104. Faça um algorítimo que leia um vetor de 5 posições, e preencha

um segundo vetor, sendo que cada posição do segundo vetor receberá o
valor do primeiro vetor na mesma posição multiplicado pelo maior
valor dentro do primeiro vetor.
#include <stdio.h>
#include <math.h>
#include <string.h>
int main(void)
{
int vetor1[5], vetor2[5], contador, maiornumero = 0;
// Lendo valores do primeiro vetor e verificando maior numero :DD

scanf("%d",&vetor1[contador]);
if (maiornumero == 0){
maiornumero = vetor1[contador];
}
else if( vetor1[contador] > maiornumero){
maiornumero = vetor1[contador];
}
}
// Preenchendo vetor 2 multiplicando vetor 1 pelo maior numero.

for( contador = 0; contador < 5; contador++){
vetor2[contador] = vetor1[contador] * maiornumero;
printf("%d\n",vetor2[contador]);
}
return 0;
}
105. Dado dois números inteiros X e Y, preencha um vetor em que é

armazenado os primeiro X números múltiplos de Y.
#include <stdio.h>
#include <math.h>
#include <string.h>
int main(void)
{
int vetorA[5] = {0}, vetorB[8] = {0}, contador, contadorb,
igualdades = 0;
scanf("%d",&vetorA[contador]);
}
scanf("%d",&vetorB[contador]);
}

for(contadorb = 0; contadorb < 8; contadorb++){
if (vetorA[contador] == vetorB[contadorb]){
if (igualdades == vetorA[contador]){
}
else{
igualdades = vetorA[contador];
printf("%d\n",vetorA[contador]);
}
}
}
}
return 0;
}
106. Dados dois vetores, A (5 elementos) e B (8 elementos), faça um

programa que imprima todos os elementos comuns aos dois vetores.
#include <stdio.h>
#include <math.h>
#include <string.h>
int main(void)
{
int vetorA[5] = {0}, vetorB[8] = {0}, contador, contadorb,
igualdades = 0;
scanf("%d",&vetorA[contador]);
}
scanf("%d",&vetorB[contador]);
}

for(contadorb = 0; contadorb < 8; contadorb++){
if (vetorA[contador] == vetorB[contadorb]){
if (igualdades == vetorA[contador]){
else{
igualdades = vetorA[contador];
printf("%d\n",vetorA[contador]);
}
}
}
}
return 0;
}
107. Fazer um algorítimo que seja lido um número inteiro X e

preencha um vetor com os divisores de X, começando do X até o número
1. Imprimir o vetor em ordem inversa (de trás para frente)
#include <stdio.h>
#include <math.h>
#include <string.h>
int main(void)
{
int numero, divisores, numerodivisores = 0,
vetor[numerodivisores], contador = 0;
for (divisores = 1; divisores <= numero; divisores++){
if (numero % divisores == 0){

vetor[contador] = divisores;
contador++;
numerodivisores++;
}
}
for(contador =0; contador < numerodivisores; contador++){

printf("%d\n",vetor[contador]);
}
return 0;
}
108. Fazer um algoritmo que seja lido uma palavra e imprima a

quantidade de letras que compões a palavra.
#include<stdio.h>
#include<string.h>
int main()
{
char palavra[50];
int i;
scanf("%s",palavra);
for(i = 0; i <= palavra[i]; i++){}
printf("%d\n",i);
return 0;
}
109. Fazer um algorítimo que seja lido uma palavra e imprima a

quantidade de vogais que compõe a palavra
#include <stdio.h>
#include <math.h>
#include <string.h>
int main(void)
{
char palavra[20];
int contador, numVogais = 0;
scanf("%s",palavra);
for(contador=0; contador < palavra[contador]; contador++){
if (palavra[contador]== 'A' || palavra[contador]== 'E' ||

palavra[contador]== 'I' || palavra[contador]== 'O' ||
palavra[contador]== 'U'){
numVogais++;
}
}
printf("%d\n",numVogais);
return 0;
}

Cálculos com sequências de números

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Cálculos com sequências de números

Uploaded by

Copyright:

Available Formats

1. Dada uma seqüência de números inteiros não-nulos, seguida por 0, imprimir seus quadrados.

int numero, /* usada para leitura da sequencia */

quadrado; /* guarda o quadrado do numero lido */

printf("\n\tCalculo dos quadrados de uma sequencia de numeros\n");

quadrado = numero * numero;

printf("O quadrado do numero %d e' %d\n", numero, quadrado);

int n, /* guarda o numero dado */

soma; /* guarda as somas parcias */

printf("\n\tCalculo da soma dos n primeiros inteiros positivos\n");

printf("\nDigite o valor de n: ");

printf("A soma dos %d primeiros inteiros positivos e' %d\n", n, soma);

int n, /* guarda o numero dado */

soma; /* guarda as somas parcias */

printf("\n\tCalculo da soma dos n primeiros inteiros positivos\n");

printf("\nDigite o valor de n: ");

printf("A soma dos %d primeiros inteiros positivos e' %d\n", n, soma);

Dado um número inteiro positivo n, imprimir os n primeiros naturais ímpares.

Exemplo: Para n=4 a saída deverá ser 1,3,5,7

int n, /* guardara o numero dado */

i, /* contador = quantidade de impares ja' impressos */

impar; /* usado para gerar a sequencia de numeros impares */

printf("\n\tGerador de numeros impares\n");

printf("\nDigite o valor de n: ");

printf("Os %d primeiros impares sao:\n", n);

printf ("%d\n", impar);

impar = impar + 2; /* vai para o proximo impar */

4. Dados um inteiro x e um inteiro não-negativo n, calcular x n.

potencia, /* guarda as potencias parciais */

printf("\nDigite um numero inteiro: ");

printf("Digite um numero um inteiro nao-negativo: ");

printf("\nO valor de %d elevado a %d: %d\n", x, n, potencia);

essa turma (Nota máxima = 100 e nota mínima = 0).

int n, /* guarda o numero de alunos */

nota, /* usada para a leitura das notas */

contador, /* numero de notas ja' lidas */

notamaior, /* guarda a maior nota */

printf("\n\tCalculo de maior e menor nota de uma turma\n");

printf("\nDigite o numero de alunos: ");

while (contador < n) {

printf("Digite uma nota (0 a 100): ");

if (notamaior < nota)

if (notamenor > nota)

printf("A maior nota obtida foi: %d\n", notamaior);

printf("A menor nota obtida foi: %d\n", notamenor);

Dado um inteiro não-negativo n, determinar n!

int n, /* guarda o numero dado */

printf("\nDigite um inteiro nao-negativo: ");

while (contador <= n) {

fatorial = fatorial * contador;

printf("O valor de %d!: %d\n", n, fatorial);

* SOLUCAO 2: usa o comando for e calcula 1*2*3*...*(n-1)*n

int n, /* guarda o numero dado */

printf("\n\tCalculo do fatorial de um numero\n");

printf("\nDigite um inteiro nao-negativo: ");

for (i = 2; i <= n; i++)

{ /* as chave sao superfluas */

printf("O valor de %d!= %d\n", n, nfat);

* SOLUCAO 3: usa o comando for e calcula 1*n*(n-1)*(n-2)...*2,

int n, /* guarda o numero dado */

printf("\n\tCalculo do fatorial de um numero\n");

printf("\nDigite um inteiro nao-negativo: ");

for (i = n; i > 1; i--)

* SOLUCAO 2: usa o comando for e calcula 123*...(n-1)n

* SOLUCAO 3: usa o comando for e calcula 1n(n-1)(n-2)...2,

for (i = 1; i(i+1)(i+2) < n; i++)

printf("%d e' o produto %d%d%d\n", n, i, i+1, i+2);