Exemplos - Programação C

Prévia do material em texto

Site da USP - INTEIROS
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;
}
Dado um número inteiro positivo n, calcular a soma dos n primeiros números inteiros positivos. 
SOLUÇÃO 1
#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;
}
SOLUÇÃO 2 
#include <stdio.h>
int main() {
 int n, /* guarda o numero dado */
 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);
 
 /* 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");
 
 /* Inicializacoes */
 printf("\nDigite o valor de 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;
}
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);
 
 /* Inicializacoes */
 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;
}
Uma loja de discos anota diariamente durante o mês de março a quantidade de discos vendidos. Determinar em que dia desse mês ocorreu a maior venda e qual foi a quantidade de discos vendida nesse dia. 
SOLUÇÃO COM APENAS LAÇO
#include <stdio.h>
Int main () {
int n, /* guarda o n´umero de dias */
dia, /* guarda o dia da maior venda */
contador, /* n´umero de dia j´a lidos */
maiorvenda,/* guarda a maior venda */
quantidade;/* usada para a leitura das quantidades */
printf("\n\tCalculo de maior venda \n");
printf("\nDigite o n´umero de dias: ");
scanf("%d", &n);
printf("\n");
printf("Digite a quantidade vendida no dia: ");
scanf("%d", &quantidade);
maiorvenda = quantidade;
dia = 1;
/* Calculo de maior venda */
for (contador = 2; contador <= n; contador++) {
	printf("Digite a quantidade vendida no dia: ");
	scanf("%d", &quantidade);
	if (maiorvenda < quantidade) {
		maiorvenda = quantidade;
		dia = contador;
	}
}
printf("\n");
printf("A maior venda foi %d discos no dia %d\n",
maiorvenda, dia);
return 0;
}
SOLUÇÃO COM LAÇO E VETOR
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <math.h>
int main(void) {
 int vendas[28];
 int dia;
 int maior = 0;
 int i;
 
 for(i=1;i<=28;i++) {
 printf("Vendas no dia %d = ",i);
 scanf("%d",&vendas[i]);
 }
 
 for(i=1;i<=28;i++) {
 if (vendas[i] > maior) {
 maior = vendas[i];
 dia = i;
 } 
 }
 printf("Dia do mes com maior numero de vendas= %d\n",dia);
 printf("Quantidade de discos vendidos = %d\n",maior);
 system("pause"); 
}
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);
 contador = contador + 1;
 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! 
SOLUCAO 1: calcula 1*2*3...*n, nessa ordem.
#include <stdio.h>
int main() {
 int n, /* guarda o numero dado */
 contador, 
 fatorial; 
 
 printf("\n\tCalculo do fatorial de um numero\n");
 printf("\nDigite um inteiro nao-negativo: ");
 scanf("%d", &n);
 
 /* inicializacoes */
 fatorial = 1;
 contador = 2;
 
 while (contador <= n) {
 fatorial = fatorial * contador;
 contador = contador + 1;
 }
 printf("O valor de %d!: %d\n", n, fatorial);
 
 return 0;
}
SOLUCAO 2: usa o comando for e calcula 1*2*3*...*(n-1) nessa ordem.
#include <stdio.h>
int main() {
 int n, /* guarda o numero dado */
 i, 
 nfat; 
 
 printf("\n\tCalculo do fatorial de um numero\n");
 printf("\nDigite um inteiro nao-negativo: ");
 scanf("%d", &n);
 
 /* inicializacoes */
 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() {
 int n, /* guarda o numero dado */
 i, 
 nfat; 
 
 printf("\n\tCalculo do fatorial de um numero\n");
 printf("\nDigite um inteiro nao-negativo: ");
 scanf("%d", &n);
 
 /* inicializacoes */
 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. 
SOLUCAO 1: Simples, curta e grossa.
Testa os numeros 0, 1, 2, ... verifincando quais sao multiplos de i ou j. 
#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);
 
 /* inicializacoes */
 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;
}
SOLUCAO 3: Mais elaborada. Faz menos iteracoes que a anterior. A cada iteracao imprime um multiplo de i ou j. Usa o comando for.
Os casos: (1) multi < multj;
 (2) multi > multj; e
 (3) multi == multj estao mais evidentes.
#include <stdio.h>
int main() {
 int i, j, n, /* dados de entrada */
 multi, multj, /* multiplos de i e multiplos de j */
 k; /* 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);
 
 /* inicializacoes */
 multi = 0;
 multj = 0;
 
 printf("Os %d primeiros multiplos de %d ou de %d sao:", n, i, j);
 for (k = 0; k < n; k++) {
 if (multi < multj) { /* Caso 1. multi < multj */
	 printf(" %d", multi);
	 multi = multi + i;
	}
 else if (multi > multj) { /* Caso 2. multi > multj */
	 printf(" %d", multj);
	 multj = multj + j; 
	}
 else { /* Caso 3. multi == multj */
 printf(" %d", multj);
 multi = multi + i;
 multj = multj + j;
	} 
 }
 printf("\n");
 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. 
/* Programa que determina se um numero e' 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. 
SOLUCAO 2. Mais elaborada e eficiente.
Usa indicador de passagem, a variaval eprimo. Ao final do programa vale que eprimo == 0 se e somente se o numero dado nao e' primo.
Observacao. Um numero inteiro maior que 1 e primo se seus únicos divisores sao ele mesmo e 1. Assim, 1 nao e' primo.
#include <stdio.h>
int main() {
 int n; /* candidato a primo */
 int divisor; /* candidato a divisor de n */
 int eprimo; /* indica se n ainda tem chance de ser primo */
 printf("\n\tTeste de primalidade\n");
 printf("\nDigite um inteiro: ");
 scanf("%d", &n);
 printf ("Candidato a primo = %d\n", n); 
 /* inicializacoes */
 if (n <= 1) { 
 eprimo = 0; /* nenhum numero <= 1 e' primo */
 }
 else {
 eprimo = 1; /* o numero e' primo ate que se prove o contrario */
 }
 /* os candidatos a divisores positivos de n sao 1,2,...,n/2 */
 divisor = 2;
 while (divisor <= n/2 && eprimo == 1) {
 if (n % divisor == 0) 	{ 
	 eprimo = 0; /* n nao e' primo! */
	}
 divisor++;
 }
 printf("O inteiro %d ", n);
 if (eprimo == 1) { 
 printf("e' primo\n");
 }
 else {
 printf("nao e' primo\n");
 }
 return 0;
}
/* 
 
* SOLUCAO 5. Uma SOLUCAO COM FALSE E TRUE NO LUGAR DE 1 E 0 e um pouco mais compacta.
 * Usa comando for e a abreviatura += 
 * Observacao. Um numero inteiro maior que 1 e primo se seus únicos divisores sao ele mesmo e 1. Assim, 1 nao e' primo.
#include <stdio.h>
#define FALSE 0
#define TRUE 1
int main() {
 int n; /* candidato a primo */
 int divisor; /* candidato a divisor de n */
 int eprimo; /* indica se n ainda tem chance de ser primo */
 printf("\n\tTeste de primalidade\n");
 printf("\nDigite um inteiro: ");
 scanf("%d", &n);
 printf ("Candidato a primo = %d\n", n); 
 /* inicializacoes */
 if (n <= 1 || (n != 2 && n % 2 == 0)) { 
 eprimo = FALSE; /* nenhum numero inteiro <= 1 ou par > 2 e' primo */
 }
 else {
 eprimo = TRUE; /* o numero e' primo ate que se prove o contrario */
 }
 /* os candidatos a divisores positivos de n sao 3,5,7,...,n/2 */
 for (divisor = 3; divisor <= n/2 && eprimo == 1; divisor += 2) {
 if (n % divisor == 0) 	{ 
	 eprimo = FALSE; /* n nao e' primo! */
	}
 }
 printf("O inteiro %d ", n);
 if (eprimo == TRUE) { 
 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.
  Exemplo:
#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;
}
(MAT 89) 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. 
/* Programa que determina se um numero e' 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);
 
 /* inicializacoes */
 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;
}
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. 
/* Programa para calcular um determinado numero de Fibonacci */
#include <stdio.h>
int main() {
 int n, 
 fant, fatual, fprox, /* numeros de Fibonacci */
 contador; /* indica qual numero de Fibonacci esta' em fatual */
 
 printf("Digite um numero n: ");
 scanf("%d", &n);
 
 /* inicializacoes */
 fant = 0;
 fatual = 1;
 contador = 1;
 
 while (contador < n) {
 fprox = fatual + fant; /* proximo numero de Fibonacci */
 fant = fatual;
 fatual = fprox;
 contador = contador + 1;
 }
 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 primeirosnaturais congruentes a j módulo m.
SOLUCAO 1.
#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);
 
 /* inicializacoes */
 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;
}
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);
 
 /* inicializacoes */
 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;
}
 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);
 /* inicializacoes */
 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. 
SOLUCAO 1. Simples, curta e grossa.
 
#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) {
 printf("A ordem crescente: %d %d %d\n", n1, n3, n2);
 }
 else if (n2 <= n1 && n1 <= n3) {
 printf("A ordem crescente: %d %d %d\n", n2, n1, n3);
 }
 else if (n2 <= n3 && n3 <= n1) {
 printf("A ordem crescente: %d %d %d\n", n2, n3, n1);
 }
 else if (n3 <= n1 && n1 <= n2) {
 printf("A ordem crescente: %d %d %d\n", n3, n1, n2);
 }
 else /* n3 <= n2 && n2 < n1 */ {
 printf("A ordem crescente: %d %d %d\n", n3, n2, n1);
 }
 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() {
 int n1, n2, n3; /* dados de entrada */
 printf("Digite tres numeros: ");
 scanf("%d", &n1);
 scanf("%d", &n2);
 scanf("%d", &n3);
 
 if (n3 > n1) {
 if (n1 > n2)	{
	 printf("A ordem crescente: %d %d %d\n", n2, n1, n3);
	}
 else 	{
	 if (n2 < n3)
	 {
	 printf("A ordem crescente: %d %d %d\n", n1, n2, n3);
	 }
	}
 } 
 if (n1 > n2) {
 if (n2 > n3)	{
	 printf("A ordem crescente: %d %d %d\n", n3, n2, n1);
	}
 else 	{
	 if (n3 < n1)	 {
	 printf("A ordem crescente: %d %d %d\n", n2, n3, n1);
	 }
	}
 }
 if (n1 < n2) {
 if (n3 < n1)	{
	 printf("A ordem crescente: %d %d %d\n", n3, n1, n2);
	}
 else 	{
	 if (n3 < n2)	 {
	 printf("A ordem crescente: %d %d %d\n", n1, n3, n2);
	 }
	}
 }
 return 0;
}
(FIS 88) Qualquer número natural de quatro algarismos pode ser dividido em duas dezenas formadas pelos seus dois primeiros e dois últimos dígitos.
Exemplos: 1297: 12 e 97.[
 5314: 53 e 14.
Escreva um programa que imprime todos os milhares (4 algarismos) cuja raiz quadrada seja a soma das dezenas formadas pela divisão acima.
Exemplo: raiz de 9801 = 99 = 98 + 01. 
Portanto 9801 é um dos números a ser impresso.
#include <stdio.h>
 int main(){
  int i,d1,d2;
 
  for(i = 1000; i <= 9999; i += 1){
    d1 = i%100;
    d2 = i/100;
    if( (d1+d2)*(d1+d2) == i )
      printf("%d\n",i);
  }
  return 0;
}
 (POLI 87) Dados n e uma sequê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);
 /* inicializacoes */
 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;
}
(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);
 /* inicializacoes */
 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);
 /* inicializacoes */
 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;
}
São dados dois números inteiros positivos p e q, sendo que o número de dígitos de p é menor ou igual ao número de dígitos de q. Verificar se p é um subnúmero de q.
Exemplos: p = 23, q = 57238, p é subnúmero de q.
p = 23, q = 258347, p não é subnúmero de q.
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define TRUE 1 
#define FALSE 0 
int main() { 
int p, q; /* dados do problema */ 
int pot10; /* guardara a menor potencia de 10 maior que p */ 
int qaux; /* variavel auxiliar; usada para `descascar' q */
int subnumero; /* guarda um subnumero de q */ 
int achou; /* indica se achou em q um subnumero igual a p */ 
/* 0. leia os dados */ 
printf("Digite um numero P:"); 
scanf("%d",&p); 
printf("Digite um numero Q maior em extensao que P:"); 
scanf("%d",&q); 
/* 1. determine a menor potencia de 10 maior que p */ 
pot10 = 1; 
while (pot10 <= p){ 
pot10 = pot10 * 10; 
} 
/* 2. verifique se algum subnumero de q e igual a p */ 
achou = FALSE; 
qaux = q; 
while (qaux >= p && achou == FALSE){ 
subnumero = qaux%pot10; 
qaux = qaux/10; 
if (subnumero == p){
 achou = TRUE; 
} 
}
if (achou == TRUE){ 
printf("%d eh subnumero de %d\n", p, q); 
}
else{ 
printf("%d nao eh subnumero de %d\n", p, q); 
} 
system("pause"); 
return 0; 
}
Simule a execução do programa abaixo destacando a sua saída:
int main() {
  int a, b, total, soma, termo, i;
  printf("Digite um par de numeros: ");
  scanf("%d %d", &a, &b);
  printf("(%d, %d)\n", a, b);
  total = 0; 
  soma  = 0;
  while (a != 0) { 
    total = total + 1; 
    termo = 1;
    for (i = 1; i <= b; i++)
      termo = termo * a;
    printf("Resp = %d\n", termo);
    soma = soma + termo;
    printf("Soma = %d\n", soma);
    printf("Digite um par de numeros: ");
    scanf("%d %d", &a, &b);
    printf("(%d, %d)\n", a, b);
  }
  printf("Total de pares: %d\n", total);
  return 0;
}
Dados: 
    2    3 
    5    2 
    7    1 
    0    5 
    3    2 
SIMULAÇÃO
Digite um par de numeros: 2 3
(2, 3)
Resp = 8
Soma = 8
Digite um par de numeros: 5 2
(5, 2)
Resp = 25
Soma = 33
Digite um par de numeros: 7 1
(7, 1)
Resp = 7
Soma = 40
Digite um par de numeros: 0 5
(0, 5)
Total de pares: 3
Site da USP – 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);
 /* inicializacoes */
 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;
 
 printf("Digite o valor de n: ");
 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;
}
4.  (GEO 84) Considere o conjunto  de pontos reais, onde
Faça um programa que lê uma seqüência de n pontos reais (x,y) e verifica se cada ponto pertence ou não ao conjunto H. O programa deve também contar o número de pontos da seqüência que pertencem a H. 
#include <stdio.h>
#include <stdlib.h>
int main () {
int n, i, cont=0;
float x, y;
printf("Digite a quantidade de pontos:" );
scanf("%d",&n);
for(i=0;i<n;i++){
printf("Digite o ponto (x y): ");
scanf("%f %f",&x,&y);
	if((x<=0)&&(y<=0)&&(y+x*x+2*x-3<=0)){
		printf("%.2f, %.2f pertence a H\n", x,y);
		cont++;
	}
	else {
		if((x>=0)&&(y+x*x-2*x-3<=0)){
		printf("%.2f, %.2f pertence a H\n", x,y);
		cont++;
		}
		else {
		printf("%.2f, %.2f não pertence a H\n", x,y);
		}
	}
}
printf("\n%d ponto(s) pertence(m) a H.",cont);
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;
}
6.  Dados x real e n natural, calcular uma aproximação para cos x através dos n primeiros termos da seguinte série:
Compare com os resultados de sua calculadora! 
#include <stdio.h>
#include <math.h> // <=== para fazer o calculo de cos(x) usando a funcao cos(.)
 // da biblioteca math. Veja o ultimo printf.
int main() {
 int n, k;
 double fatorial, x, cosx, termo;
 // Veja: fatorial declarado como 'double'
 printf("Forneça o valor do ângulo em radianos: ");
 scanf("%lf", &x);
 printf("Número de termos: ");
 scanf("%d", &n);
 cosx = 1.0;
 fatorial = 1.0; 
 termo = 1.0;
 for (k = 1; k < n; k++) {
 termo = - (termo * x * x); // veja o sinal 
 fatorial = fatorial * (2 * k -1) * (2 * k); //<==== calculo do fatorial
 // aproveitando o fatorial anterior.
 cosx = cosx + termo/fatorial; 
 }
 printf("cos(%g) = %g\n", x, cosx);
 printf("Usando a funcao cos(.) ja' disponivel: cos(%g) = %g\n", x, cos(x));
 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);
 /* inicializacoes */
 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);
 scanf("%f", &Nota2);
 scanf("%f", &Nota3);
 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;
}
11.  Dado um inteiro positivo n, calcular e imprimir o valor da seguinte soma:
#include <stdio.h>
int main() {
 float somaerrada, soma;
 int i, n; 
 printf("Digite o valor de 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.
Compare e discuta os resultados obtidos no computador. 
#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;
}
Site da USP – REPETIÇÃO
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;
}
3.  Dados 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. 
SOLUCAO: simples e direta.
#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);
 /* inicializacoes */
 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;
} 
4.  Dados n números inteiros positivos, calcular a soma dos que são primos. 
#include <stdio.h> 
#include <conio.h> 
int main() { 
 int n, numero, i, divisores=0, j, soma=0; 
 printf("Digite o comprimentoda sequencia: "); 
 scanf("%d", &n); 
 printf("Digite um sequencia de %d numeros: ", n); 
 for (i=0; i<n; i++) { 
 scanf("%d", &numero); 
 divisores = 0; 
 for (j=1; j<=numero; j++) { 
 if (numero % j==0) { 
 divisores++; 
 } 
 } 
 if (divisores == 2) { 
 soma += numero; 
 } 
 } 
 printf("A soma dos primos eh %d\n", soma); 
 getch(); 
}
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. 
SOLUCAO 1
#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;
}
6.  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;
}
7.  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 5: COM FOR 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 num1, num1-1, num1-2,..., 2, 1, 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 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);
 
 for (i = 1; i < n; i++) 
 {
 printf("Entre com o %do. numero da sequencia: ", i+1);
 scanf ("%d", &numero);
 /* calcule o max divisor comum de mdc e numero */ 
 for (divisor = mdc; mdc % divisor != 0 || numero % divisor != 0; divisor--); 
		
 /* atualize o mdc dos numeros lidos */
 mdc = divisor;
 }
 printf("MDC = %d\n", mdc);
 return 0;
} 
SOLUCAO 7: Versao mais elaborada. Usa o algoritmo de Euclides para determinar o maximo divisor comum de dois numero.
#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 resto; /* 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);
 
 for (i = 1; i < n; i++) {
 printf("Entre com o %do. numero da sequencia: ", i+1);
 scanf ("%d", &numero);
 /* algoritmo de Euclides para encontra o maxi divisor comum de 
 * mdc e numero 
 */ 
 while (numero != 0) 	{
	 resto = mdc % numero;
	 mdc = numero;
	 numero = resto;
	}
 /* neste ponto do progra mdc contem o maximo divisor comum dos 
 * numeros lido
 */
 }
 printf("MDC = %d\n", mdc);
 return 0;
} 
8.  (POLI 97) 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:
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. 
SOLUCAO 1: simples e direta. Note o cuidado especial com o ultimo segmento e ultimo elemento.
#include <stdio.h>
#define FALSE 0
#define TRUE 1
int main() {
 int n; /* no. de elementos na sequencia */
 int i; /* contador de numeros lidos */
 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");
 /* leia o tamanho da sequecia */
 printf("Entre com n: ");
 scanf ("%d", &n);
 /* determina candidato a k e paridade do primeiro 1o. segmento */
 printf("Entre com o 1o. numero da sequencia: ");
 scanf ("%d", &numero);
 paridade = numero % 2;k = 1;
 i = 1; 
 while (i < n && numero % 2 == paridade) {
 printf("Entre com o %do. numero da sequencia: ", i+1); 
 scanf ("%d", &numero);
 i = i + 1; /* mais um numero foi lido */
 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) 	{
	 printf("Entre com o %do. numero da sequencia: ", i+1); 
	 scanf ("%d", &numero);
	 i = i + 1; /* mais um numero foi lido */
	 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;
} 
SOLUCAO 4: eta solucao bonita.
#include <stdio.h>
#define FALSE 0
#define TRUE 1
int main() {
 int n; /* no. de elementos na sequencia */
 int i; /* contador de numeros lidos */
 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");
 /* leia o tamanho da sequencia */
 printf("Entre com n: ");
 scanf ("%d", &n);
 /* leia o 1o. elemento e determine a sua paridade */
 printf("Entre com o 1o. numero da sequencia: ");
 scanf ("%d", &numero);
 paridade = numero % 2; 
 kaux = 1; /* comprimento corrente do segmento */ 
 /* a sequencia e' k-alternante ate que se prove o contrario */
 k_alternante = TRUE;
 k = 0; /* o valor de k ainda precisa ser determinado */
 for (i = 1; i <= n; i++) {
 /* caso 1: i == n */
 if (i == n) 	{
	 /* acabou de ler a sequencia */ 
 /* caso 1A: 1o. segmento */ 
	 if (k == 0) {
	 /* a sequencia e' composta por numeros de mesma paridade */
	 k = kaux;
	 }
 /* caso 1B: nao e' o 1o. segmento */
 else if (kaux != k) 	 {
	 k_alternante = FALSE;
	 }
	}
 /* caso 2: i != n */
 else 	{
	 printf("Entre com o %do. numero da sequencia: ", i+1); 
	 scanf ("%d", &numero);
 /* caso 2A: numero % 2 == paridade */	 
 	 if (numero % 2 == paridade) 	 {
	 kaux = kaux + 1;
	 }
 /* caso 2B: numero % 2 != paridade */	 
	 else	 {
 /* caso 2B1: 1o. segmento */
 if (k == 0)		{
		 k = kaux;
		}
 /* caso 2B2: nao e' o 1o. segmento */
 else if (kaux != k) 		{
		 k_alternante = FALSE;
		}
	 kaux = 1;
	 paridade = (paridade + 1) % 2;
	 } 
	}
 }
 
 if (k_alternante == TRUE) 
 printf("A sequencia e %d-alternante\n", k);
 else
 printf("A sequencia nao e' k-alternante\n");
 
 return 0;
}