■  ■ respostas dos

exercícios
de fixação
em C

nina edelweiss
maria aparecida castro livi
2     Respostas dos Exercícios de Fixação em C

3  algoritmos sequenciais 5
Exercício 3.1 Algoritmo Média1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
Exercício 3.2 Algoritmo Círculo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
Exercício 3.3 Algoritmo ConversãoParaDólar . . . . . . . . . . . . . . . . . . . . . . . . . . 6
Exercício 3.4 Algoritmo ComissãoSobreVenda . . . . . . . . . . . . . . . . . . . . . . . . . . 6
Exercício 3.5 Permuta2Variáveis. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

4  estruturas condicionais e de seleção 7

Exercício 4.1 Algoritmo ParOuÍmpar. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Exercício 4.2 Algoritmo EquaçãoSegundoGrau . . . . . . . . . . . . . . . . . . . . . . . . . . 8
Exercício 4.3 Algoritmo UmaVenda. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
Exercício 4.4 Algoritmo UmaVendaComércio. . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Exercício 4.5 Algoritmo DiasDoMês1. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
Algoritmo DiasDoMês2. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
Exercício 4.6 Algoritmo IdentificarCaractere . . . . . . . . . . . . . . . . . . . . . . . 12

5  estruturas de repetição 13
Exercício 5.1 Algoritmo Fibonacci – opção 1 . . . . . . . . . . . . . . . . . . . . . . . . . . 13
Algoritmo Fibonacci – opção 2 . . . . . . . . . . . . . . . . . . . . . . . . . . 14
Exercício 5.2 Algoritmo NúmerosPerfeitos. . . . . . . . . . . . . . . . . . . . . . . . . . . 14
Exercício 5.3 Algoritmo ConverteTemperaturas . . . . . . . . . . . . . . . . . . . . . . . 15

6  variáveis estruturadas: arranjos unidimensionais 16

Exercício 6.1 Algoritmo MenorTempComVet. . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
Exercício 6.2 Algoritmo GeraVetMult5. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
Exercício 6.3 Algoritmo GeraVetIntersc. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
Exercício 6.4 Algoritmo FreqCandConcurs. . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
Exercício 6.5 Algoritmo AtletasEscore. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
Exercício 6.6 Algoritmo PesqSequencial. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
Exercício 6.7 Algoritmo PesqBin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
Exercício 6.8 Algoritmo ClassSeleção. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
Exercício 6.9 Algoritmo ClassBolha. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
 Respostas dos Exercícios de Fixação em C   3

7  variáveis estruturadas: arranjos multidimensionais 24

Exercício 7.1 Algoritmo MatrizEsparsa. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
Exercício 7.2 Algoritmo ProcPopulEst. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
Exercício 7.3 Algoritmo AcidentesNovaYork. . . . . . . . . . . . . . . . . . . . . . . . . . 27

8  tipo definido por enumeração 30

Exercício 8.1 Algoritmo Regiões . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
Exercício 8.2 Algoritmo DiaMaioresVendas. . . . . . . . . . . . . . . . . . . . . . . . . . . 31
Exercício 8.3 Algoritmo LojaMaterialEscolar . . . . . . . . . . . . . . . . . . . . . . . . 32

9  subprogramas 34
Exercício 9.1 Algoritmo TesteMenu. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
Exercício 9.2 Algoritmo TesteImpPares. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
Exercício 9.3 Algoritmo TesteMaior3. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
Exercício 9.4 Algoritmo TesteBuscaValor. . . . . . . . . . . . . . . . . . . . . . . . . . . . 36

10  manipulação de strings 37
Exercício 10.1 Função ContaStrings: inteiro. . . . . . . . . . . . . . . . . . . . . . . . . . . 37
Exercício 10.2 Procedimento SubstituiSubstr. . . . . . . . . . . . . . . . . . . . . . . . . 39
Exercício 10.3 Função Palíndroma: lógico. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

11  registros 41
Exercício 11.1 Algoritmo FuncionáriosSalMaiorMédia. . . . . . . . . . . . . . . . . . . 41
Exercício 11.2 Algoritmo IdadeAluno. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42

12  conjuntos 44

13  arquivos 44
Exercício 13.1 Função ContaVogaisEmArqTexto: inteiro. . . . . . . . . . . . . . . . . . . 44
Exercício 13.2 Procedimento ExcValArqInt. . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
4     Respostas dos Exercícios de Fixação em C

Exercício 13.3 Procedimento AltCampRegArq. . . . . . . . . . . . . . . . . . . . . . . . . . . 46

Exercício 13.4 Procedimento CriaArqAtletRand. . . . . . . . . . . . . . . . . . . . . . . . 51
Exercício 13.5 Procedimento ListaSeqArqAtletRand . . . . . . . . . . . . . . . . . . . . 54

14  ponteiros e alocação dinâmica de memória 56

Exercício 14.1 Algoritmo TestePonteiro. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
Exercício 14.2 Procedimento MontaListaEncadeada . . . . . . . . . . . . . . . . . . . . . 56

15  recursividade 59
Exercício 15.1 Procedimento MostraVersão1. . . . . . . . . . . . . . . . . . . . . . . . . . . 59
Procedimento MostraVersão2. . . . . . . . . . . . . . . . . . . . . . . . . . . 59
Exercício 15.2 Função Fibonacci: inteiro. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
Exercício 15.3 Procedimento Quick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
Exercício 15.4 Função Lugar: inteiro. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
Exercício 15.5 Função PalíndromaRec: lógico var. . . . . . . . . . . . . . . . . . . . . . . . 63
Exercício 15.6 Procedimento RV. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
 Respostas dos Exercícios de Fixação em C   5

3  algoritmos sequenciais
Exercício 3.1  Algoritmo Média1
//Informa a soma e a media das 3 notas de um aluno
#include <stdio.h>
#include <stdlib.h>
int main ( )
{
float nota1, nota2, nota3;
float soma, media;
printf("Informe as tres notas (reais):");
scanf("%f %f %f", &nota1, &nota2, &nota3);//Entrada das 3 notas
//informa as notas lidas
printf("\nNota1 = %8.2f nota2 = %8.2f nota3 = %8.2f\n",
nota1, nota2, nota3);
soma = nota1 + nota2 + nota3; // calcula a soma
printf("\nSoma = %8.2f\n", soma); // informa a soma
media = soma / 3; // calculo da media
printf("\nMedia = %8.2f\n", media); // informa media calculada
printf("\n\n");
system("pause");
return 0;
}

Exercício 3.2  Algoritmo Círculo

//Informa o perimetro de um circulo e sua area
#include <stdio.h>
#include <stdlib.h>
int main ( )
{
float raio;
float perimetro, area;
printf("Raio: ");
scanf("%f", &raio); // le o raio do circulo
perimetro = 2 * 3.14 * raio; // calcula o perimetro
area = 3.14 * (raio * raio); // calcula a area
//informa perimetro e area
printf("\nPerimetro = %8.2f Area = %8.2f\n ", perimetro, area );
printf("\n\n");
system("pause");
return 0;
}
6     Respostas dos Exercícios de Fixação em C

Exercício 3.3  Algoritmo ConversãoParaDólar

//Converte um valor em reais para dolares
#include <stdio.h>
#include <stdlib.h>
int main ( )
{
float preco; // preco em reais
float taxa; // taxa de conversao para dolar
float emdolar; // preco em dolares
printf("Preco: ");
scanf("%f", &preco); // le o preco em reais
printf("Taxa: ");
scanf("%f", &taxa); // le a taxa do dolar
emdolar = preco / taxa; //calcula o valor em dolares
// informa o valor em dolares
printf("\nPreco em dolar = %8.2f\n ", emdolar );
printf("\n\n");
system("pause");
return 0;
}

Exercício 3.4  Algoritmo ComissãoSobreVenda

//Calcula a comissao de um vendedor sobre uma venda
#include <stdio.h>
#include <stdlib.h>
int main ( )
{
int numvendedor; // numero do vendedor
float valorvenda; // valor da venda
float percentual; // percentual a receber
float comissao; // comissao a receber
printf
("Informe num do vendedor (inteiro) e valor da venda (real): ");
scanf("%d %f", &numvendedor, &valorvenda);//leitura dados venda
printf("Percentual: ");
scanf("%f", &percentual); // leitura percentual
comissao = valorvenda * percentual * 0.01; // calculo da comissao
//saida dados
printf("\nNum do vendedor = %d comissao = %8.2f\n ",
numvendedor, comissao);
printf("\n\n");
system("pause");
return 0;
}
 Respostas dos Exercícios de Fixação em C   7

Exercício 3.5  Permuta2Variáveis

//Permuta o conteudo de duas variaveis
#include <stdio.h>
#include <stdlib.h>
int main ( )
{
float a, b; // variaveis a serem permutadas
float aux;
printf("Forneca os dois valores (reais) a permutar: ");
scanf("%f %f", &a, &b);// le os dois valores
// informa os valore lidos
printf("a = %8.2f b = %8.2f ", a, b);//informa os valores lidos
//permuta o conteudo das duas variaveis
aux = a;
a = b;
b = aux;
//informa os valores trocados
printf("\na = %8.2f b = %8.2f ", a, b);
printf("\n\n");
system("pause");
return 0;
}

4  estruturas condicionais e de seleção

Exercício 4.1  Algoritmo ParOuÍmpar
//Informa se um valor lido do teclado eh par ou impar
#include <stdio.h>
#include <stdlib.h>
int main ( )
{
int valor; // valor a ser testado
int ehpar;
printf("Valor: ");
scanf("%d", &valor); //entrada do valor a ser testado
if (valor >= 0) // valor lido eh positivo
{
ehpar = ((valor % 2) == 0); //verifica se valor eh par
if (ehpar) // verdadeiro se ehpar for maior que zero (verdadeiro)
printf("Par!");
else
printf("Impar!");
}
printf("\n\n");
system("pause");
return 0;
}
8     Respostas dos Exercícios de Fixação em C

Exercício 4.2  Algoritmo EquaçãoSegundoGrau

//Informa os valores das raizes de uma equacao do segundo grau
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
int main ( )
{
float a, b, c; //coeficientes da equacao
float r1, r2; // raizes
float disc; // discriminante
//Entrada dos valores dos coeficientes da equacao
printf("Forneca os coeficientes da equacao (valores reais): ");
scanf("%f" "%f" "%f" , &a, &b, &c);
if (a == 0)
{
printf("\nNao eh equacao de segundo grau!\n");
printf("Raiz = %8.2f", -c/b);
}
else
{
disc = b *b - 4 * a * c; //calculo do discriminante
if (disc < 0)
printf("\nRaizes imaginarias!\n");
else
{
r1=(-b + sqrt(disc))/(2*a);
r2=(-b - sqrt(disc))/(2*a);
printf("Raizes: %8.2f , %8.2f", r1, r2);
}
}
printf("\n\n");
system("pause");
return 0;
}

Exercício 4.3  Algoritmo UmaVenda

//Processa uma venda de livros
#include <stdio.h>
#include <stdlib.h>
int main ( )
{
char codigo; //codigo do livro
int numerounidades; // numero de unidades vendidas
float apagar; // preco a pagar
// entrada de dados
printf("Forneca o Codigo (char) e o num. de unidades (inteiro): ");
scanf(" %c" "%d", &codigo, &numerounidades);
//calculo do preco da venda
if (codigo == 'A')
 Respostas dos Exercícios de Fixação em C   9

apagar = numerounidades * 10;

else
if (codigo == 'B')
apagar = numerounidades * 20;
else
if (codigo == 'C')
apagar = numerounidades * 30;
else
{ // codigo esta incorreto
apagar = 0;
printf("\nCodigo errado!\n");
}
if (apagar > 0) // codigo valido
{
//informa valor a pagar
printf ("\nValor a pagar %8.2f\n", apagar);
if (numerounidades > 10)
printf("\nForam vendidas mais de 10 unidades!\n");
}
printf("\n\n");
system("pause");
return 0;
}

Exercício 4.4  Algoritmo UmaVendaComércio

//Processa uma venda em um estabelecimento comercial
#include <stdio.h>
#include <stdlib.h>
int main ( )
{
float preco;
char codigo;
float desconto;
float apagar;
// entrada de dados
printf("Forneca o Codigo (char) e o preco (real): ");
scanf(" %c" "%f", &codigo, &preco);
apagar = preco; // inicializa apagar
desconto = 0; // inicializa desconto
if (codigo == 'A') //calcula desconto
desconto = preco / 5;
else
if (codigo == 'B')
desconto = preco / 10;
apagar = apagar - desconto; // calcula apagar
if (apagar >= 80) //verifica se compra >= 80,00
{
desconto = desconto + apagar / 10;
apagar = apagar * 0.9; //mais 10% de desconto
10     Respostas dos Exercícios de Fixação em C

}
//informa valor a pagar
printf("\nValor a pagar = %8.2f\n", apagar);
if (desconto != 0)
printf("\nDesconto = %8.2f\n", desconto);//informa desconto recebido
printf("\n\n");
system("pause");
return 0;
}

Exercício 4.5  (Obs.: duas versões do Algoritmo DiasDoMês)

Algoritmo DiasDoMês1
//Informa quantos dias tem um determinado mes
#include <stdio.h>
#include <stdlib.h>
int main ( )
{
int mes, ano;
int dias;
int ehbissexto;
//entrada de dados
printf("Forneca mes e ano: ");
scanf("%d" "%d", &mes, &ano);
//se fevereiro, verifica se ano eh bissexto
if (mes == 2)
{
ehbissexto = 0;
if ((ano % 100) == 0)
{
if ((ano % 400) == 0)
ehbissexto = 1;
}
else
if ((ano % 4) == 0)
ehbissexto = 1;
}
if (mes == 2) // fevereiro
if (ehbissexto)
dias = 29;
else
dias = 28;
else
if ((mes == 4) || (mes == 6) || (mes == 9) || (mes == 11))
dias = 30;//abril, junho, setembro, novembro
else
dias = 31; //demais meses
//informa numero de dias do mes
printf("\nMes %d do ano %d tem %d dias\n", mes, ano, dias);
printf("\n\n");
 Respostas dos Exercícios de Fixação em C   11

system("pause");
return 0;
}

Algoritmo DiasDoMês2
//Informa quantos dias tem um determinado mes
#include <stdio.h>
#include <stdlib.h>
int main ( )
{
int mes, ano; // dados de entrada - mes e ano
int dias; // numero de dias do mes neste ano
int ehbissexto;
//entrada de dados
printf("Forneca mes e ano: ");
scanf("%d" "%d", &mes, &ano);
switch (mes)
{
case 2: //fevereiro
ehbissexto = 0;
if (!(ano % 100))
{
if (!(ano % 400))
ehbissexto = 1;
}
else if (!(ano % 4))
ehbissexto = 1;
if (ehbissexto)
dias = 29; // ano bissexto
else dias = 28;
break;
case 4: //abril
case 6: //junho
case 9: //setembro
case 11: //novembro
dias = 30;
break;
default: //demais meses
dias = 31;
break;
} // fim comando de selecao multipla
//informa numero de dias do mes
printf("\nDias = %d\n", dias);
printf("\n\n");
system("pause");
return 0;
}
12     Respostas dos Exercícios de Fixação em C

Exercício 4.6  Algoritmo IdentificarCaractere

//Informa tipo de caractere lido
#include <stdio.h>
#include <stdlib.h>
int main ( )
{
char lido; //caractere a ser identificado
printf("Informe o caractere: ");
scanf(" %c", &lido);
switch (lido)
{
case'A': case 'a':
case'B': case 'b':
case'C': case 'c':
case'D': case 'd':
case'E': case 'e':
case'F': case 'f':
case'G': case 'g':
case'H': case 'h':
case'I': case 'i':
case'J': case 'j':
case'K': case 'k':
case'L': case 'l':
case'M': case 'm':
case'N': case 'n':
case'O': case 'o':
case'P': case 'p':
case'Q': case 'q':
case'R': case 'r':
case'S': case 's':
case'T': case 't':
case'U': case 'u':
case'V': case 'v':
case'W': case 'w':
case'X': case 'x':
case'Y': case 'y':
case'Z': case 'z': printf("\nLetra\n");
break;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9': printf("\nDigito\n");
break;
case '+':
 Respostas dos Exercícios de Fixação em C   13

case '-':
case '*':
case '/': printf("\nOperador aritmetico\n");
break;

default: printf("\nCaractere desconhecido\n");

break;
}
printf("\n\n");
system("pause");
return 0;
}

5  estruturas de repetição
Exercício 5.1  Algoritmo Fibonacci – opção 1
*/Gera uma sequencia de N termos da serie de Fibonacci,
usando 3 termos */
#include <stdio.h>
#include <stdlib.h>
int main ( )
{
int n, i, termo, termo_1, termo_2;
termo_2 = 0;//inicializa primeiro termo da serie
termo_1 = 1; // inicializa segundo termo da serie
do //consiste numero desejado de termos
{
printf("\nNumero de termos: ");
scanf("%d", &n);
}
while (n <= 0);
for (i = 1; i <= n; i++)
{
switch (i) // informa conceito
{
case 1:
printf("\n%d\n", termo_2);
break;
case 2:
printf("\n%d\n", termo_1);
break;
default:
termo = termo_1 + termo_2;
printf("\n%d\n", termo);
termo_2 = termo_1;
termo_1 = termo;
break;
}
14     Respostas dos Exercícios de Fixação em C

}
printf("\n\n");
system("pause");
return 0;
}

Algoritmo Fibonacci – opção 2

/*Gera uma sequencia de N termos da serie de Fibonacci,
usando 3 termos*/
#include <stdio.h>
#include <stdlib.h>
int main ( )
{
int n, i, termo_atual, termo_anterior;
termo_atual = 1; //inicializa primeiros termos da serie
termo_anterior = 0;
do //consiste numero desejado de termos
{
printf("\nNumero de termos: ");
scanf("%d", &n);
}
while (n <= 0);
for (i = 1; i <= n; i++)
{
printf("\n%d\n", termo_anterior);
termo_atual = termo_atual + termo_anterior;
termo_anterior = termo_atual - termo_anterior;
}
printf("\n\n");
system("pause");
return 0;
}

Exercício 5.2  Algoritmo NúmerosPerfeitos

//Identifica os numeros perfeitos inferiores a um valor lido
#include <stdio.h>
#include <stdlib.h>
int main ( )
{
int lim, divisor, numero, somadiv;
printf("\nValor limite: ");
scanf("%d", &lim);
for (numero = 2; numero < lim; numero++)
{ //verifica cada numero do intervalo
somadiv = 1; //inicializa com divisor 1
for (divisor = 2; divisor <= (numero/2); divisor++) // ate metade
if ((numero % divisor) == 0) // se eh divisor
somadiv = somadiv + divisor; //soma todos os divisores
 Respostas dos Exercícios de Fixação em C   15

if (numero == somadiv) //compara com soma de todos os divisores

printf("\n %d eh perfeito ", numero);
}
printf("\n\n");
system("pause");
return 0;
}

Exercício 5.3  Algoritmo ConverteTemperaturas

//Converte temperaturas, de acordo com menu
#include <stdio.h>
#include <stdlib.h>
int main ( )
{
int opcao;
float temp_lida;
do // laco executa pelo menos 1 vez, até ler opcao = 5
{
printf("\nConversoes:\n");
printf("\n1 - Celsius para Fahrenheit\n");
printf("\n2 - Fahrenheit para Celsius\n");
printf("\n3 - Celsius para Kelvin\n");
printf("\n4 - Kelvin para Celsius\n");
printf("\n5 - Encerra o programa\n");
do // leitura e consistencia da prim. opcao informada
{
printf("\nOpcao: ");
scanf("%d", &opcao);
}
while ((opcao < 1) || (opcao > 5));
if (opcao != 5) // se nao for opcao de encerramento
{//obtem temperatura a ser convertida
printf("\nTemperatura: ");
scanf("%f", &temp_lida);
switch (opcao) // informa conceito
{
case 1:
printf("\nEquivale a %8.2f F\n", temp_lida * 1.8 + 32);
break;
case 2:
printf("\nEquivale a %8.2f C\n", (temp_lida- 32) / 1.8);
break;
case 3:
printf("\nEquivale a %8.2f K\n", (temp_lida + 273.15));
break;
case 4:
printf("\nEquivale a %8.2f C\n", (temp_lida - 273.15));
break;
} // fim do switch
16     Respostas dos Exercícios de Fixação em C

} // fim do if
}
while (opcao != 5); //opcao de encerramento
printf("\n\n");
system("pause");
return 0;
}

6  variáveis estruturadas: arranjos unidimensionais

Obs.: Em C, os índices para acessar as dimensões dos arranjos iniciam em 0. Na tradução dos
algoritmos, da pseudolinguagem para o C, foram feitos os ajustes necessários.

Exercício 6.1  Algoritmo MenorTempComVet

//Determina menor temperatura. Usa um vetor.
#include <stdio.h>
#include <stdlib.h>
#define MAXTEMP 3
int main ( )
{
float vetor[MAXTEMP];//temperaturas
float menor; //menor temperatura
int j;
for (j = 0; j < MAXTEMP; j++)
{
printf("\nValor %d: ", j + 1);
scanf("%f", &vetor[j]); //preenche vetor por leitura
}
menor = vetor[0]; //inicializa menor com primeiro elemento do vetor
for (j = 1; j < MAXTEMP; j++)
{
if (vetor[j] < menor)//percorre vetor comparando com menor
menor = vetor[j];//troca conteudo de menor se necessario
}
printf("\nVetor lido\n\n");
for (j = 0; j < MAXTEMP; j++)
printf("%8.2f ", vetor[j]);//escreve conteudo do vetor
printf("\n\n");
//escreve menor temperatura
printf("\nMenor temperatura = %8.2f ", menor);
printf("\n\n");
system("pause");
return 0;
}
 Respostas dos Exercícios de Fixação em C   17

Exercício 6.2  Algoritmo GeraVetMult5

/*Le um vetor. Gera e apresenta outro,
so com os valores multiplos de 5 */
#include <stdio.h>
#include <stdlib.h>
#define MAX 3
int main ( )
{
int orig[MAX]; // valores originais
int mult5[MAX];// multiplos de 5
int k; // indice para percorrer vetor orig
int contmult5; // indice e contador dos multiplos de 5
for (k = 0; k < MAX; k++)
{
printf("\nValor %d: ", k + 1);
scanf("%d", &orig[k]);//preenche orig por leitura
}
contmult5 = 0;//inicializa contador de multiplos de 5 em zero
for (k = 0; k < MAX; k++)//percorre orig do inicio ao final
//testa se valor contido em orig eh multiplo de 5
if ((orig[k] % 5) == 0)
{
contmult5++;//incrementa contador de multiplos de 5
//copia valor para vetor mult5
mult5[contmult5 - 1] = orig[k];
}
printf("\n\n");
if (contmult5 == 0)//testa se encontrou algum valor multiplo de 5
printf("\nNao ha valores multiplos de 5!\n\n");
else
{ //escreve valores multiplos de 5
printf("\n\nValores multiplos de 5: \n");
for (k = 0; k < contmult5; k++)
printf("%d ", mult5[k]);
}
printf("\n\n");
system("pause");
return 0;
}

Exercício 6.3  Algoritmo GeraVetIntersc

/*Le dois vetores e gera o vetor interseccao.
Apresenta o vetor gerado ou uma
mensagem caso o vetor interseccao seja vazio*/
#include <stdio.h>
#include <stdlib.h>
#define MAX 3
int main ( )
18     Respostas dos Exercícios de Fixação em C

{
int vet1[MAX], vet2[MAX]; // vetores de entrada
int vet_inters [MAX]; // vetor interseccao
int i, j;// indices dos vetores vet1 e vet2
int k; // indice do vetor vet_inters
int igual;
// Leitura dos dois vetores de entrada
for (i = 0; i < MAX; i++)
{
printf("\nValor %d do vetor 1: ", i + 1);
scanf("%d", &vet1[i]);
}
for (i = 0; i < MAX; i++)
{
printf("\nValor %d do vetor 2: ", i + 1);
scanf("%d", &vet2[i]);
}
//Geracao do vetor interseccao
k = -1; // inicializa indice para vetor vazio
for (i = 0; i < MAX; i++) //i percorre vet1
{
j = 0; // j vai percorre vet2
igual = 0; // inicializa variavel logica
do
{
if (vet1[i] == vet2[j])
igual = 1;// achou elem. igual em vet1 e vet2
j++; // avanca para proximo elemento em vet2
}
while ((igual == 0) && (j <= MAX)) ;
if (igual)
{
k++; // incrementa indice de vet_inters
vet_inters[k] = vet1[i]; // copia elem. para vet_inters
}
}
// Apresentacao do resultado: vetor interseccao ou mensagem
if (k >= 0)
{
printf("\nConjunto interseccao\n\n");
for (i= 0; i <= k; i++)
printf("%d ",vet_inters[i]);
}
else
printf("\nNao ha conjunto interseccao\n\n");
printf("\n\n");
system("pause");
return 0;
}
 Respostas dos Exercícios de Fixação em C   19

Exercício 6.4  Algoritmo FreqCandConcurs

/*Contabiliza a frequencia absoluta dos pontos
dos candidatos a um concurso
Acrescentado: um for para zerar o vetor freq.
MAXPONTOS deve ser 121, para poder contabilizar na posicao 120.*/
#include <stdio.h>
#include <stdlib.h>
#define MAXCAND 3
#define MAXPONTOS 121
int main ( )
{
int pontos; // quantidade de pontos obtidos por um candidato
int i;// contador de candidatos
int k; // indice do vetor freq
int freq[MAXPONTOS]; //frequencia
for (k = 0; k <= MAXPONTOS; k++)
freq[k] = 0;
for (i = 0; i < MAXCAND; i++) // para cada candidato
{
do
{
printf("\nPontos do candidato %d: ", i + 1);
scanf("%d", &pontos); // le pontos do candidato
//testa validade de pontos
if ((pontos < 0) || (pontos >= MAXPONTOS))
printf("\n\nPontos invalidos");//ignora os invalidos
}
//ate valor de pontos validos
while ((pontos <0) || (pontos >= MAXPONTOS));
freq[pontos]++;//incrementa freq
}
printf("\nFrequencia absoluta de pontos");
for (k = 0; k < MAXPONTOS; k++)
printf("\n\n %d %d", k, freq[k]);
printf("\n\n");
system("pause");
return 0;
}

Exercício 6.5  Algoritmo AtletasEscore

//Apresenta dados de atleta com escore igual ou superior a media
#include <stdio.h>
#include <stdlib.h>
#define MAXATLETAS 3
#define MAXESCORE 100
int main ( )
{
int numero [MAXATLETAS], escore[MAXATLETAS];
int i;// valores dos indices dos vetores
20     Respostas dos Exercícios de Fixação em C

int somatorio; // somatorio dos escores

float media; // media dos escores
somatorio = 0; // inicializa somatorio de escores em zero
for (i = 0; i < MAXATLETAS; i++) // para cada atleta
{
do
{
printf("\nNumero do atleta %d: ", i + 1);
scanf("%d", &numero[i]); // leitura do numero do atleta
//testa validade da leitura
if ((numero[i] < 1) || (numero[i] > MAXATLETAS))
printf("\n\nNumero invalido");
}
while ((numero[i] <= 0) || (numero[i] > MAXATLETAS));
do
{
printf("\nEscore do atleta %d: ", i + 1);
scanf("%d", &escore[i]); // leitura do escore do atleta
//testa validade do escore
if ((escore[i] < 1) || (escore[i] > MAXESCORE))
printf("\n\nEscore invalido");
}
while ((escore[i] <= 0) || (escore[i] > MAXESCORE));
somatorio = somatorio + escore[i]; // acumula escore lido
}
media = somatorio / MAXATLETAS; //faz media dos escores
printf("\nAtletas com escore >= media");
for (i = 0; i < MAXATLETAS; i++) // para cada atleta
if (escore[i] >= media) //testa se escore eh >= que media
//informa dados atleta
printf("\n\n Numero %d Escore %d", numero[i], escore[i]);
printf("\n\n");
system("pause");
return 0;
}

Exercício 6.6  Algoritmo PesqSequencial

//Realiza pesquisa sequencial sobre um vetor
#include <stdio.h>
#include <stdlib.h>
#define MIN 0
#define MAX 10
int main ( )
{
int vet [MAX]; //vetor ordenado
int i;// indice do arranjo
int procurado; // valor a ser procurado no vetor vet
int achado; // sinaliza se valor buscado foi encontrado
for (i = MIN; i < MAX; i++)
 Respostas dos Exercícios de Fixação em C   21

{
printf("\nValor %d: ", i + 1);
scanf("%d", &vet[i]); // preenche vet por leitura
}
printf("\nValor a procurar: ");
scanf("%d", &procurado); // le valor a ser procurado em vet
achado = 0; // inicializa achado
i = MIN;
while ((!achado) && (i < MAX))
{
if (vet[i] == procurado)
achado = 1;
i++;
}
if (achado)
printf("\nEncontrou o valor buscado!\n");
else
printf("\nNao encontrou o valor buscado!\n");
printf("\n\n");
system("pause");
return 0;
}

Exercício 6.7  Algoritmo PesqBin

//Realiza pesquisa binaria em um vetor
#include <stdio.h>
#include <stdlib.h>
#define MAX 10
int main ( )
{
int vet [MAX]; //vetor ordenado
int i;// indice do arranjo
int procurado; // valor a ser procurado no vetor vet
int achado; // sinaliza se valor buscado foi encontrado
int inf, sup, med; // indices inferior, superior, medio na pesquisa
for (i = 0; i < MAX; i++)
{
printf("\nValor %d: ", i + 1);
scanf("%d", &vet[i]); // preenche vet por leitura
}
printf("\nValor a procurar: ");
scanf("%d", &procurado); // le valor a ser procurado em vet
inf = 0; // posiciona inf e sup nos limites de vet
sup = MAX;
achado = 0; // inicializa achado em falso
while ((inf <= sup) && (achado == 0))
{
med = (inf + sup) / 2; // calcula o indice do termo medio
printf("\nMed = %d\n", med);
22     Respostas dos Exercícios de Fixação em C

if (vet[med] == procurado)//verifica se eh o valor procurado

achado = 1;// o valor foi encontrado
else
if (procurado > vet[med])
inf = med + 1; // valor esta na metade superior
else
sup = med - 1; // valor esta na metade inferior
}
if (achado)
printf("\nValor achado!\n");
else
printf("\nValor nao achado!\n");
printf("\n\n");
system("pause");
return 0;
}

Exercício 6.8  Algoritmo ClassSeleção

//Classifica um vetor pelo metodo de selecao, em ordem crescente
#include <stdio.h>
#include <stdlib.h>
#define MIN 0
#define MAX 10
int main ( )
{
int vet [MAX]; //vetor ordenado
int i, j;// indices de uma passada
int menor; // menor valor da passada
int aux; // auxiliar para fazer a troca
for (i = 0; i < MAX; i++)
{
printf("\nValor %d: ", i + 1);
scanf("%d", &vet[i]); // preenche vet por leitura
}
for (i = 0; i < MAX - 1; i++)
{
menor = i;
for (j = i + 1; j < MAX; j++)
if (vet[j] < vet[menor])
menor = j;
if (menor != i)
{ // vai fazer a troca
aux = vet[i];
vet[i] = vet[menor];
vet[menor] = aux;
}
}
for (i = MIN; i < MAX; i++)
printf("\n%d ", vet[i]); // mostra vet ordenado
 Respostas dos Exercícios de Fixação em C   23

printf("\n\n");
system("pause");
return 0;
}

Exercício 6.9  Algoritmo ClassBolha

//Classifica um vetor pelo metodo da bolha
#include <stdio.h>
#include <stdlib.h>
#define MAX 5
int main ( )
{
int vet [MAX]; //vetor a ser classificado
int i;// indice que percorre o vetor
int k; //ao terminar a varredura, armazena a posicao
//onde ocorreu a ultima troca
int m; // limite superior da varredura - recua um
//ou posicoes a cada iteracao
int aux; // variavel auxiliar utilizada para a troca
int trocou; // verdadeira se ocorreu alguma troca
for (i = 0; i < MAX; i++)
{
printf("\nValor %d: ", i + 1);
scanf("%d", &vet[i]); // preenchimento do vetor por leitura
}
trocou = 1; //inicializa trocou em verdadeiro
m = MAX - 1;
k = 0;
while (trocou)
{
trocou = 0;
for (i = 0; i < m; i++)
if (vet[i] > vet[i + 1])
{ // troca dois elementos de posicao
aux = vet[i];
vet[i] = vet[i + 1];
vet[i + 1] = aux;
k = i; // k posicao em que ocorreu a troca
trocou = 1; //indica que nesta varredura houve troca
}
m = k; // m indica ate onde sera feita a proxima varredura
printf("\n\n k = %d|\n\n", k);
system("pause");
} // fim enquanto

printf("\n\n Vetor Classificado \n\n");

for (i = 0; i < MAX; i++)
printf("\n%d ", vet[i]); // mostra vetor classificado
printf("\n\n");
24     Respostas dos Exercícios de Fixação em C

system("pause");
return 0;
}

7  variáveis estruturadas: arranjos multidimensionais

Obs.: Em C, os índices para acessar as dimensões dos arranjos iniciam em 0. Na tradução dos
algoritmos, da pseudolinguagem para o C, foram feitos os ajustes necessários.

Exercício 7.1  Algoritmo MatrizEsparsa

//Geracao de uma matriz condensada a partir de uma matriz esparsa
#include <stdio.h>
#include <stdlib.h>
#define MAX 3
int main ()
{
int esparsa[MAX] [MAX]; // matriz esparsa
int condens[MAX*MAX] [MAX]; //matriz condensada
int i, j; //indices
int cont; // contador
//preenchimento da matriz esparsa por leitura
printf
("Insira os valores para a matriz esparsa (%d x %d):\n\n",
MAX, MAX);
for(i=0; i<MAX; i++)
for(j=0; j<MAX; j++)
{
printf("Valor %d x %d: ", i+1, j+1);
scanf("%d", &esparsa[i] [j]);
}
for(i=0; i<MAX; i++)
{
for(j=0; j<MAX; j++)
printf("%d ", esparsa[i][j]);
printf("\n\n");
}
//Criacao da matriz condensada
cont = -1;
for(i=0; i<MAX; i++)
for(j=0; j<MAX; j++)
if(esparsa[i] [j] != 0)//se valor nao for nulo
{
cont++;
condens[cont] [0] = esparsa[i] [j]; //valor nao nulo
condens[cont] [1] = i; // linha do valor nao nulo
condens[cont] [2] = j; //coluna do valor nao nulo
}
//impressao da matriz condensada, caso exista
if(cont < 0)
 Respostas dos Exercícios de Fixação em C   25

printf("Matriz nao possui nenhum elemento nao nulo!!!");

else
for(i = 0; i <= cont; i++)
printf("\n\n %d %d %d ",
condens[i][0], condens[i][1], condens[i][2]);
printf("\n\n");
system("pause");
return 0;
}

Exercício 7.2  Algoritmo ProcPopulEst

/*Processa dados de populacao das capitais e municipios mais populosos
dos 26 estados brasileiros */
#include <stdlib.h>
#include <stdio.h>
#define MAX_EST 3
#define MAX_MUNIC 4
int main ( )
{
char titulo[] =
"Municipios com populacao > populacao media das capitais:";
int tabpop[MAX_EST][MAX_MUNIC];
int maior; // auxilia determinacao municipio mais populoso
int i, j;
int estadomaior, municipiomaior;
int somapopcap; // somatorio populacao capitais
int primeiravez; // controla apresentacao de cabecalho
float mediapopcap;
//leitura dos dados de populacao
for (i = 0; i < MAX_EST; i++)
{
printf ("\nEstado %d" , i + 1 );
for (j = 0; j < MAX_MUNIC; j++)
if (j == 0)
do
{
printf("\nPopulacao da capital: ");
scanf ("%d", &tabpop[i][j]);
printf("\n\n");
if (tabpop[i][j] <= 0)
printf("\nPopulacao deve ser > 0!");
}
while (tabpop[i][j] <= 0);
else
do
{
printf("\nPopulacao do municipio %d: " , j );
scanf ("%d", &tabpop[i][j]);
printf("\n\n");
26     Respostas dos Exercícios de Fixação em C

if (tabpop[i][j] <= 0)
printf("\nPopulacao deve ser > 0!");
}
while (tabpop[i][j] <= 0);
}
//Calcula a media da populacao das capitais}
somapopcap = 0;
for (i = 0; i < MAX_EST; i++)
somapopcap = somapopcap + tabpop[i][0];
mediapopcap = (float)somapopcap / MAX_EST;
printf ("Media de populacao das capitais: %12.0f" ,
mediapopcap);
//Determinacao do municipio mais populoso e
//em que estado se encontra
maior = tabpop[0][1];
estadomaior = 0;
municipiomaior = 1;
for (i = 0; i < MAX_EST; i++)
for (j = 1; j < MAX_MUNIC; j++)
if (tabpop[i][j] > maior)
{
maior = tabpop[i][j];
estadomaior = i;
municipiomaior = j;
}
printf("\n\n");
printf
("O municipio mais populoso eh o %d do estado %d com %d habitantes",
municipiomaior , estadomaior + 1 , maior );
printf("\n\n");
//Determinacao e apresentacao dos municipios que tem populacao maior
//que a media da populacao das capitais.
primeiravez = 1;
for (i = 0; i < MAX_EST; i++)
for (j = 1; j < MAX_MUNIC; j++)
if (tabpop[i][j] > mediapopcap)
{
if (primeiravez) // cabecalho so quando for escrever
{
puts (titulo);
// printf("\n\n");
primeiravez = 0;
}
printf
("\nMunicipio : %d do Estado: %d Populacao: %12d",
j , i + 1, tabpop[i][j]);
}
if (primeiravez)
{
 Respostas dos Exercícios de Fixação em C   27

printf
("\nNenhum dos municipios mais populosos tem populacao");
printf("\nsuperior aa media da populacao das capitais.");
}
printf("\n\n");
system("pause");
return 0;
}

Exercício 7.3  Algoritmo AcidentesNovaYork

//processa acidentes ocorridos na Ilha de Manhattan
#include <stdio.h>
#include <stdlib.h>
#define MAXAVENIDAS 10
#define MINRUAS 30
#define MAXRUAS 58
#define INTERSECPERIGO 4
#define IND_AJUST 29
int main ( )
{
int matriz[MAXAVENIDAS] [( MAXRUAS - MINRUAS) + 1];
int matriz_condensada[MAXAVENIDAS * (MAXRUAS - MINRUAS) ][3];
int avenida, rua;
// indices
int i;
int linha, m, k; // variaveis geracao da matriz condensada
int cont_com_acidentes = 0; // contador cruzamento com acidentes
int trocou;
int aux1, aux2, aux3; // auxiliares de classificacao
//inicializacao da matriz com zeros
for (avenida = 0; avenida < MAXAVENIDAS; avenida++)
for (rua = 0; rua < MAXRUAS; rua++)
matriz[avenida] [rua] = 0;
// preenchimento da matriz com acidentes
do
{
printf("Avenida de 1 a %d, ou -1 para parar): ", MAXAVENIDAS);
scanf("%d", &avenida);
if ((avenida < 1 || avenida > MAXAVENIDAS) && avenida != -1)
printf("\nAvenida invalida\n\n");
}
while ((avenida < 1 || avenida > MAXAVENIDAS) && avenida != -1);
while (avenida != -1) // marca de parada: avenida = -1
{
do
{
printf("\nRua de %d a %d ", MINRUAS, MAXRUAS);
scanf("%d", &rua);
if (rua < MINRUAS || rua > MAXRUAS)
28     Respostas dos Exercícios de Fixação em C

printf("\nRua invalida\n\n");
}
while (rua < MINRUAS || rua > MAXRUAS);
do
{
printf
("Numero acidentes do cruzamento avenida %d com rua %d: \n",
avenida, rua);
printf("\n\n avenida %d rua %d\n\n",
avenida - 1, ((rua - IND_AJUST) - 1));
scanf("%d", &matriz[avenida - 1] [(rua - IND_AJUST) - 1]);
if (matriz[avenida - 1] [(rua - IND_AJUST) - 1] < 1)
printf("\nNumero de acidentes invalido!\n");
}
while (matriz[avenida - 1] [(rua - IND_AJUST) - 1] < 1);
do
{
printf("Avenida de 1 a %d, ou -1 para parar): ", MAXAVENIDAS);
scanf("%d", &avenida);
if ((avenida < 1 || avenida > MAXAVENIDAS) && avenida != -1)
printf("\nAvenida invalida");
}
while ((avenida < 1 || avenida > MAXAVENIDAS) && avenida != -1);
}
for (avenida = 0; avenida < MAXAVENIDAS; avenida++)
{
printf("\n");
for (rua = 0; rua < MAXRUAS - IND_AJUST; rua++)
printf("\%2d ", matriz[avenida] [rua]);
}
// Geracao da matriz condensada
linha = -1;
for (i = 0; i < MAXAVENIDAS; i++)
{
for (j = 0; j < MAXRUAS - IND_AJUST; j++)
if ( matriz[i] [j] > 0)
{
linha++;
cont_com_acidentes++;
matriz_condensada[linha] [0] = matriz[avenida] [j];
matriz_condensada[linha] [1] = i + 1;
matriz_condensada[linha] [2] = j + IND_AJUST + 1;
}
}
printf("\nCruzamentos com acidentes:");
printf("\nAvenida Rua Acidentes");
printf("\n\n");
for (i = 0; i <= linha; i++)
printf("\n%6d %6d %6d", matriz_condensada[i] [0],
matriz_condensada[i] [1], matriz_condensada[i] [2]);
 Respostas dos Exercícios de Fixação em C   29

//classificacao da matriz condensada

trocou = 1;
m = linha;
k = 1;
while (trocou)
{
trocou = 0;
for (i = 0 ; i < m; i++)
if (matriz_condensada[i][0] < matriz_condensada[i + 1] [0])
{
aux1 = matriz_condensada[i][0];
aux2 = matriz_condensada[i][1];
aux3 = matriz_condensada[i][2];
matriz_condensada[i][0] = matriz_condensada[i + 1] [0];
matriz_condensada[i][1] = matriz_condensada[i + 1] [1];
matriz_condensada[i][2] = matriz_condensada[i + 1] [2];
matriz_condensada[i + 1][0] = aux1;
matriz_condensada[i + 1][1] = aux2;
matriz_condensada[i + 1][2] = aux3;
k = i;
trocou = 1;
}
m = k;
}
//Apresentacao dos resultados
printf("\n\n");
for (i = 0; i <= linha; i++)
printf("\n%6d %6d %6d", matriz_condensada[i] [0],
matriz_condensada[i] [1], matriz_condensada[i] [2]);
if (cont_com_acidentes)
{
i = 0;
do
{
printf("\n\nInterseccao perigosa: %d", i + 1);
printf (" avenida %d ", matriz_condensada[i] [1] );
printf (" rua %d ", matriz_condensada[i] [2]);
printf (" acidentes %d\n\n", matriz_condensada[i] [0]) ;
i++;
}
while (i <= linha && i <= INTERSECPERIGO);
if (linha < INTERSECPERIGO)
printf("\nNao ha mais interseccoes com acidentes!");
}
else
printf("\nNenhum acidente informado!");
printf("\n\n");
system("pause");
return 0;
}
30     Respostas dos Exercícios de Fixação em C

8  tipo definido por enumeração

Obs.: A conversão de um valor do tipo enumeração para um inteiro acontece de maneira
automática em C. Essa característica da linguagem é explorada nos exercícios a seguir.

Exercício 8.1  Algoritmo Regiões

/Manipulacao de variavel do tipo enumeracao
#include <stdio.h>
#include <stdlib.h>
int main ( )
{
enum tipo_regiao{sul, norte, leste, oeste} regiao;
int varcontr;
int lido;
printf("\nForneca o codigo correspondente aa regiao:\n");
for (varcontr = sul; varcontr <= oeste; varcontr++)
{
switch (varcontr)
{
case sul: printf("\n1 - Regiao Sul\n");
break;
case norte: printf("\n2 - Regiao Norte\n");
break;
case leste: printf("\n3 - Regiao Leste\n");
break;
case oeste: printf("\n4 - Regiao Oeste\n\n");
break;
}
}
do
{
scanf("%d", &lido);
// verifica consistencia do valor lido
if ((lido < 1) || (lido > 4))
printf("\nCodigo invalido!\n");
}
while ((lido < 1) || (lido > 4));
// atribuicao de valor a variavel tipo enumeracao
switch (lido)
{
case 1: regiao = sul;
break;
case 2: regiao = norte;
break;
case 3: regiao = leste;
break;
 Respostas dos Exercícios de Fixação em C   31

case 4: regiao = oeste;

break;
}
//informar valor contido em variavel do tipo enumeracao
if (regiao == sul)
printf("\nRegiao eh Sul.");
else
if (regiao == norte)
printf("\nRegiao eh Norte.");
else
if (regiao == leste)
printf("\nRegiao eh Leste.");
else
printf("\nRegiao eh Oeste.");

printf("\n\n");
system("pause");
return 0;
}

Exercício 8.2  Algoritmo DiaMaioresVendas

//Informa o dia da semana com maiores vendas e valor de vendas nesse dia
#include <stdio.h>
#include <stdlib.h>
int main ( )
{
enum dias_semana{seg= 2, ter, qua, qui, sex, sab};
float vendas[sab];
int dia_maior_venda, indice;

//preenche por leitura vetor vendas

for (indice = seg; indice <= sab; indice++)
{
printf("\nVendas do dia %d: ", indice);
scanf("%f", &vendas[indice]);
}
// identifica dia de maior venda
dia_maior_venda = seg; // inicializa em seg
for (indice = ter; indice <= sab; indice++)
if (vendas[indice] > vendas[dia_maior_venda])
dia_maior_venda = indice; // troca pelo maior encontrado
// informa dia de maior venda
switch (dia_maior_venda)
{
case seg:
printf("\nDia de maior volume de vendas: segunda_feira\n");
break;
case ter:
32     Respostas dos Exercícios de Fixação em C

printf ("\nDia de maior volume de vendas: terca_feira\n");

break;
case qua:
printf ("\nDia de maior volume de vendas: quarta_feira\n");
break;
case qui:
printf ("\nDia de maior volume de vendas: quinta_feira\n");
break;
case sex:
printf ("\nDia de maior volume de vendas: sexta_feira\n");
break;
case sab:
printf ("\nDia de maior volume de vendas: sabado\n");
break;
}
//informa valor de maior venda
printf("\nValor da maior venda: %8.2f\n",vendas[dia_maior_venda]);
printf("\n\n");
system("pause");
return 0;
}

Exercício 8.3  Algoritmo LojaMaterialEscolar

//Gerencia de estoques de loja de material escolar
#include <stdio.h>
#include <stdlib.h>
#define MAX_ESTOQ 100
#define NRO_PROD 4
int main ( )
{
enum produto{caderno = 0, lapis, esferografica, borracha};
int i, nr, prod;
char p;
int estoque[NRO_PROD];
//entrada dos estoques
printf("\nEntre com os valores de estoque: ");
for (i = caderno; i <= borracha; i++)
{
switch (i)
{
case caderno: printf("\nCadernos: ");
break;
case lapis: printf("\nLapis: ");
break;
case esferografica: printf("\nEsferograficas: ");
break;
case borracha: printf("\nBorrachas: ");
break;
 Respostas dos Exercícios de Fixação em C   33

}
do
{
scanf("%d", &estoque[i]);
if ((estoque[i] < 0) || (estoque[i] > MAX_ESTOQ))
printf
("Estoque invalido! \n\nEntre com o valor correto: ");
}
while ((estoque[i]< 0) || (estoque[i] > MAX_ESTOQ));
}
//laco para processamento de varias vendas
do
{
printf("\nForneca a letra inicial do produto desejado");
printf(" (c, l, e, b ou f para terminar):\n");
scanf(" %c", &p);
printf("\nQuantos produtos deseja? ");
scanf("%d", &nr);
switch (p)
{
case 'c': //Caderno
if (estoque[caderno] >= nr)
estoque[caderno] = estoque[caderno] - nr;
else printf("\nSem estoque!");
break;
case 'l': //Lapis
if (estoque[lapis] >= nr)
estoque[lapis] = estoque[lapis] - nr;
else printf("\nSem estoque!");
break;
case 'e': //Esferografica
if (estoque[esferografica] >= nr)
estoque[esferografica] = estoque[esferografica] - nr;
else printf("\nSem estoque!");
break;
case 'b': //Borracha
if (estoque[borracha] >= nr)
estoque[borracha] = estoque[borracha] - nr;
else printf("\nSem estoque!");
break;
case 'f': //Fim do laco de vendas
printf("\n FIM \n\n");
break;
}
}
while (p != 'f');
// Informa estoques finais
for (i = caderno; i <= borracha; i++)
34     Respostas dos Exercícios de Fixação em C

{
switch (i)
{
case caderno: printf("\nCadernos: ");
break;
case lapis: printf("\nLapis: ");
break;
case esferografica: printf("\nEsferograficas: ");
break;
case borracha: printf("\nBorrachas: ");
break;
}
printf("%d \n", estoque[i]);
}
printf("\n\n");
system("pause");
return 0;
}

9  subprogramas
Exercício 9.1  Algoritmo TesteMenu
//Chama uma funcao void para apresentar ao usuario um menu de opcoes
#include <stdio.h>
#include <stdlib.h>
void ApresentaMenu ( );
int main ( )
{
int lido;
lido = 0;
while (lido != 10)
{
ApresentaMenu ( );
scanf("%d", &lido);
printf("\nLido = %d", lido);
}
printf("\n\n");
system("pause");
return 0;
}
void ApresentaMenu ( )
{
// apresenta ao usuario um menu com diferentes opcoes
printf("\nEscolha sua opcao de compra:\n");
printf("\n1: Refrigerante");
printf("\n2: Cerveja");
printf("\n3: Bauru");
 Respostas dos Exercícios de Fixação em C   35

printf("\n4: Cachorro Quente");

printf("\n5: Batatas Fritas");
printf("\n6: Sundae ");
printf("\n10: Parar\n");
}

Exercício 9.2  Algoritmo TesteImpPares

//Imprime os pares entre os limites passados como parametros
#include <stdio.h>
#include <stdlib.h>
void ImpPares (int, int);
int main ( )
{
int valor_inf, valor_sup;
printf
("\nForneca valor inferior (zero para parar) e valor superior: ");
scanf("%d %d", &valor_inf, &valor_sup);
while (valor_inf != 0)
{
ImpPares(valor_inf, valor_sup);
printf("\nForneca valor inferior e valor superior: ");
scanf("%d %d", &valor_inf, &valor_sup);
}
printf("\n\n");
system("pause");
return 0;
}
void ImpPares (int inferior, int superior)
{
int numero;
if (inferior % 2) // limite inferior nao eh par
inferior++; // alterou limite inferior para par
for (numero = inferior; numero <= superior; numero = numero + 2)
{
printf(" %d ");
system ("pause");
}
}

Exercício 9.3  Algoritmo TesteMaior3

//Chama funcao que devolve o maior de 3 valores
#include <stdio.h>
#include <stdlib.h>
#define ARR_INF 0
#define ARR_SUP 3

float Maior3 (float, float, float);

int main ( )
36     Respostas dos Exercícios de Fixação em C

{
float vet_maiores [ARR_SUP];
float v1[ARR_SUP], v2[ARR_SUP], v3[ARR_SUP];
int indice;
for (indice = ARR_INF; indice < ARR_SUP; indice++)
{
printf("\nForneca o primeiro valor real: ");
scanf("%f", &v1[indice]);
printf("\nForneca o segundo valor real: ");
scanf("%f", &v2[indice]);
printf("\nForneca o terceiro valor real: ");
scanf("%f", &v3[indice]);
vet_maiores[indice] =
Maior3(v1[indice], v2[indice], v3[indice]);
}
printf("\n\n");
// Imprime vetor de maiores valores
for (indice = ARR_INF; indice < ARR_SUP; indice++)
printf(" %6.2f ", vet_maiores[indice]);
printf("\n\n");
system("pause");
return 0;
}
float Maior3 (float val1, float val2, float val3)
{
float maior;
maior = val1;
if (val2 > maior)
maior = val2;
if (val3 > maior)
maior = val3;
return maior;
}

Exercício 9.4  Algoritmo TesteBuscaValor

/*Funcao void que recebe parametros de entrada e devolve valores em parametros
de saída */
#include <stdio.h>
#include <stdlib.h>
#define LIM_INF 0
#define LIM_SUP 5
void BuscaValor (float *, float, int *, int *);
int main ( )
{
float vet [LIM_SUP];
float valor;
int indice;
int encontrou;
int posicao;
 Respostas dos Exercícios de Fixação em C   37

for (indice = LIM_INF; indice < LIM_SUP; indice++)

{
printf("\nForneca valor real: ");
scanf("%f", &vet[indice]);
}
printf("\nValor real a buscar: ");
scanf("%f", &valor);
BuscaValor(vet, valor, &posicao, &encontrou);
printf("\n\n");
// Analise dos resultados da busca
if (encontrou)
printf("\nPosicao = %d", posicao + 1);
else
printf("\nValor nao foi encontrado!") ;
printf("\n\n");
system("pause");
return 0;
}
void BuscaValor (float *vet, float valor_buscado, int *posicao,
int *achou)
{
int indice;
*achou = 0; // inicializa achou com falso
for (indice = LIM_INF; indice < LIM_SUP; indice++)
if (vet[indice] == valor_buscado)
{
*achou = 1;
*posicao = indice;
}
}

10  manipulação de strings
Exercício 10.1  Função ContaStrings: inteiro
/*Usa uma funcao que devolve o numero de ocorrencias de uma string dentro de
outra*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAXNOME 60
int ContaStrings (char *, char *);
int main ( )
{
int resultado;
char string1[MAXNOME];
char string2[MAXNOME];
printf("Forneca string principal (sem espacos): ");
scanf("%s", &string1);
38     Respostas dos Exercícios de Fixação em C

printf
("Forneca string a ser pesquisada(igual ou menor que a anterior): ");
scanf("%s", &string2);
printf
("\n\nO texto %s tem %d ocorrencias do texto %s\n",string1,
ContaStrings(string1, string2), string2 );
printf("\n\n");
system("pause");
return 0;
}
int ContaStrings (char st1[], char st2[])
{
int inds1, inds2; // indices para percorrer strings
int comps1, comps2; // comprimento das strings
int cont; // contador de ocorrencias
int inicomp; // indice de st1 que inicia uma comparacao
inds1 = 0;
inds2 = 0;
comps1 = strlen(st1);
comps2 = strlen (st2);
cont = 0; // inicializa contador de ocorrencias
while ((comps1 - 1) >= (comps2 - 1))
{
inicomp = inds1; // guarda onde inicia esta comparacao
while ((st1[inds1] == st2[inds2]) && (inds2 < comps2))
{
inds1++;
inds2++;
}
if (inds2 >= comps2) // encontrou uma ocorrencia de st2 em st1
{
cont++;
// diminui comprimento de st1 para busca
comps1 = comps1 - comps2;
// posiciona novamente no primeiro caractere de st2
inds2 = 0;
}
else
{
inds1 = inicomp + 1;
inds2 = 0;
comps1--;
}
}
return cont; //devolve contagem
}
 Respostas dos Exercícios de Fixação em C   39

Exercício 10.2  Procedimento SubstituiSubstr

/*Usa uma funcao void para substituir em um texto todas as
ocorrencias de um outro texto informado. O trecho a ser substituido deve ser
de mesmo tamanho que o novo texto.
STRING PRINCIPAL NAO PODE CONTER ESPACOS*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#define MAXNOME 60
void ContaStrings (char *, char *, char *);
int main ( )
{
int resultado;
char linha[MAXNOME];
char string1[MAXNOME];
char string2[MAXNOME];
printf("Forneca a linha(string principal): ");
scanf("%s", &linha);
printf("Forneca string a substituir (igual ou menor a anterior): ");
scanf("%s", &string1);
printf
("Forneca string que substituira a anterior (igual a anterior): ");
scanf("%s", &string2);
ContaStrings(linha, string1, string2);
printf("\n\nString final %s\n",linha);
printf("\n\n");
system("pause");
return 0;
}
void ContaStrings (char linha[], char sst1[], char sst2[])
{
int complinha; // comprimento da linha
int compsstr; // comprimento das substrings
int ilinha; // indice que percorre a linha
int isst;// indice para percorrer as substrings
int iaux; // indice que percorre a linha durante uma comparacao
int terminou; // se 1, indica o final das buscas
// inicializacoes
complinha = strlen(linha); // comprimento da linha recebida
// poderia ser o comprimento de sst2, pois sao iguais
compsstr = strlen(sst1);
ilinha = 0; // posiciona indice no primeiro caractere da linha
terminou = 0; // controla o final das analises
do
{ // percorre linha ate encontrar primeiro caractere de sst1
while ((linha[ilinha] != sst1[0]) &&
(complinha-ilinha >= compsstr))
ilinha++;
if ((complinha - ilinha) >= compsstr)
40     Respostas dos Exercícios de Fixação em C

{ // encontrou primeira letra da substring na linha

// compara caracteres de linha e sst1 ate comprimento de sst1
iaux = ilinha;
isst = 0;
//compara caracteres de linha e sst1 ate comprimento de sst1
while ((linha[iaux] == sst1[isst]) && (isst < compsstr))
{
iaux++;
isst++;
}
if ((isst == (compsstr)) && (linha[iaux - 1] ==
sst1[isst - 1]))
// encontrou sst1 em linha e vai substituir por sst2
for (isst = 0; isst < compsstr; isst++)
{
linha[ilinha] = sst2[isst];
ilinha++;
}
else
ilinha++; // avanca para proximo em linha
}
else terminou = 1;
}
while (!terminou);
}

Exercício 10.3  Função Palíndroma: lógico

/*Usa uma funcao que retorna verdadeiro
se uma string recebida como parametro eh uma palindroma.
Palavra fornecida nao pode conter espacos.*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAXNOME 60
int palindroma (char *);
int main ( )
{
int resultado;
char palavra[MAXNOME];
printf("Forneca palavra a verificar: ");
scanf("%s", &palavra);
if (palindroma(palavra))
printf("\n\n Eh palindroma");
else
printf("\n\n Nao eh palindroma");
printf("\n\n");
system("pause");
return 0;
}
 Respostas dos Exercícios de Fixação em C   41

int palindroma (char palavra [])

{
int frente, atras; // indices que percorrem a string
int dif; // indica se encontrou letra diferente
frente = 0; //posiciona indice no inicio da palavra
atras = strlen(palavra) - 1; // e no final da palavra
printf("\n%d", atras);
dif = 0; // inicializa dif
while ((!dif) && (frente < atras))
{
if (palavra[frente] != palavra[atras])
dif = 1;
else
{
frente++; // avanca frente
atras--; // retrocede atras
}
}
return !dif;
}

11  registros
Exercício 11.1  Algoritmo FuncionáriosSalMaiorMédia
//Informa nomes dos funcionarios com salario superior a media
#include <stdio.h>
#include <stdlib.h>
#define MAXNOME 60
#define NRFUNC 2
#define NRSAL 2
struct tipo_salario
{
int ano;
float valor;
};
struct funcionario
{
int cod;
char nome[MAXNOME];
tipo_salario salario[NRSAL] ;
int depto;
char cargo;
};
int main ()
{
int indfunc, indsal; //indices
float somasal, mediasal; // soma e media dos salarios
struct funcionario funcionarios[NRFUNC];
42     Respostas dos Exercícios de Fixação em C

//Preencher por leitura todos os dados dos funcionarios

for (indfunc = 0; indfunc < NRFUNC; indfunc++)
{
printf("\nForneca os dados do funcionario %d", indfunc + 1);
printf("\nCodigo do funcionario: ");
scanf("%d", &funcionarios[indfunc].cod);
printf("\nNome do funcionario: ");
scanf("%s", &funcionarios[indfunc].nome);
printf("\nUltimos salarios: ");
for (indsal = 0; indsal < NRSAL; indsal++)
{
printf("\nAno do salario %d: ", indsal + 1);
scanf("%d", &funcionarios[indfunc].salario[indsal].ano);
printf("\nValor do salario %d: ", indsal + 1);
scanf("%f", &funcionarios[indfunc].salario[indsal].valor);
}
printf("\nDepartamento em que esta lotado: ");
scanf("%d", &funcionarios[indfunc].depto);
printf("\nCargo do funcionario: ");
scanf(" %c", &funcionarios[indfunc].cargo);
}
// calcular a media dos salarios atuais
somasal = 0; // inicializa somatorio dos salarios em zero
for (indfunc = 0; indfunc < NRFUNC; indfunc++)
{
somasal =
somasal + funcionarios[indfunc].salario[NRSAL - 1].valor;
// o salario atual deve estar armazenado na ultima posicao
}
//calculo da media dos salarios atuais
mediasal = somasal /NRFUNC;
printf("\nMedia salarios atuais: %8.2f", mediasal);
//Informar nome dos funcionarios com salario superior a media
for (indfunc = 0; indfunc < NRFUNC; indfunc++)
{
if (funcionarios[indfunc].salario[NRSAL - 1].valor > mediasal)
printf("\n%s", funcionarios[indfunc].nome);
}
system("pause");
return 0;
}

Exercício 11.2  Algoritmo IdadeAluno

/*Armazena os dados de um aluno e informa com que idade entrou no curso*/
#include <stdio.h>
#include <stdlib.h>
#define MAXNOME 60
int main ()
 Respostas dos Exercícios de Fixação em C   43

{
struct data
{
int dia;
int mes;
int ano;
};
struct tipo_aluno
{
char nome[MAXNOME];
struct data admissao;
struct data nasc;
};
int idade; // idade que o aluno entrou no curso
struct tipo_aluno aluno;
//Leitura dos dados do aluno
printf("\nNome do aluno: ");
scanf("%s", aluno.nome);
printf("\nData de admissao do aluno\n ");
printf("\nDia:");
scanf("%d", &aluno.admissao.dia);
printf("\nMes: ");
scanf("%d", &aluno.admissao.mes);
printf("\nAno: ");
scanf("%d", &aluno.admissao.ano);
printf("\nData de nascimento do aluno\n ");
printf("\nDia: ");
scanf("%d", &aluno.nasc.dia);
printf("\nMes: ");
scanf("%d", &aluno.nasc.mes);
printf("\nAno: ");
scanf("%d", &aluno.nasc.ano);
printf("\n%s\n ", aluno.nome);
//Calculo da Idade de Ingresso
if (aluno.admissao.mes == aluno.nasc.mes)
if (aluno.admissao.dia >= aluno.nasc.dia)
idade = aluno.admissao.ano - aluno.nasc.ano;
else
idade = aluno.admissao.ano - aluno.nasc.ano - 1;
else
if (aluno.admissao.mes > aluno.nasc.mes)
idade = aluno.admissao.ano - aluno.nasc.ano;
else
idade = aluno.admissao.ano - aluno.nasc.ano - 1;
//Informa idade de ingresso
printf("\nIdade de ingresso de %s = %d\n ", aluno.nome, idade);
system("pause");
return 0;
}
44     Respostas dos Exercícios de Fixação em C

12  conjuntos
Na versão do C utilizada, não existe o tipo Conjunto.

13  arquivos
Exercício 13.1  Função ContaVogaisEmArqTexto: inteiro
/*Utiliza uma funcao que conta as vogais em um arquivo texto*/
#include <stdio.h>
#include <stdlib.h>
int ContaVogaisEmArqTexto (FILE *, char *);
int main( )
{
FILE *arq_ent;
char nome_arq_ent[] = "texto.txt";
system("color f1");
printf("\nNumero de vogais no arquivo: %d\n",
ContaVogaisEmArqTexto(arq_ent, nome_arq_ent));
system ("pause");
return 0;
}
int ContaVogaisEmArqTexto (FILE *arq_ent, char *nome_arq_ent )
{
int total_de_vogais = 0;
char caract;
if ((arq_ent = fopen(nome_arq_ent, "r")) == NULL)
{
printf("Erro abertura arquivo para ler\n");
system("pause");
}
else
{
while (!(feof(arq_ent)))// laco de leitura
{
caract = getc(arq_ent); // leitura caractere a caractere
if (caract == 'a' || caract == 'A' || caract == 'e'
|| caract == 'E' ||
caract == 'i' || caract == 'I' || caract == 'o'
|| caract == 'O' ||
caract == 'u' || caract == 'U' )
total_de_vogais++;

}
fclose (arq_ent);
return total_de_vogais;
}
}
 Respostas dos Exercícios de Fixação em C   45

Exercício 13.2  Procedimento ExcValArqInt

/*
Usa uma funcao void (= procedimento) que exclui
um valor de um arquivo de inteiros, gerando
um novo arquivo sem esse valor. O acesso ao arquivo
devera ser puramente sequencial.
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define MAXNOME 40
void ExcValArqInt(FILE *, FILE *, char [], char[], int *);
int main ( )
{
FILE * arq_entrada;
FILE * arq_saida;
int resul_tado;
char nome_entrada [MAXNOME];
char nome_saida [MAXNOME];
system ("color f1");
fflush(stdin);
printf
("Nome do arquivo de entrada(com no maximo %d caracteres): ", MAXNOME - 1);
fgets(nome_entrada, sizeof(nome_entrada), stdin);
if (nome_entrada[strlen(nome_entrada) - 1] == '\n')
nome_entrada[strlen(nome_entrada) - 1] = '\0';
fflush(stdin);
printf
("Nome do arquivo de saida(com no maximo %d caracteres): ",
MAXNOME - 1);
fgets(nome_saida, sizeof(nome_saida), stdin);
if (nome_saida[strlen(nome_saida) - 1] == '\n')
nome_saida[strlen(nome_saida) - 1] = '\0';
fflush(stdin);
ExcValArqInt(arq_entrada, arq_saida, nome_entrada, nome_saida, &resul_tado);
printf("\n%d", resul_tado);
printf("\n\n");
system("pause");
return 0;
}
void ExcValArqInt(FILE *arq_ent, FILE *arq_sai, char nome_arq_ent[],
char nome_arq_sai[], int *resultado)
{
int val_excl, valor;
*resultado = 0;
if ((arq_ent = fopen(nome_arq_ent, "r")) == NULL)
{
printf("Erro abertura arquivo para ler\n");
system("pause");
46     Respostas dos Exercícios de Fixação em C

}
else
{
if ((arq_sai = fopen(nome_arq_sai, "w")) == NULL)
{
printf("Erro abertura arquivo para escrever\n");
system("pause");
}
else
{
printf("\nValor a excluir: \n");
scanf("%d", &val_excl);
while(fread(&valor, sizeof(int),1,arq_ent) !=0)
{
if (valor != val_excl)
fwrite(&valor, sizeof(int), 1, arq_sai);
else
*resultado = 1;
}
fclose (arq_ent);
fclose (arq_sai);
}
}
}

Exercício 13.3  Procedimento AltCampRegArq

OBS.: o procedimento é parte do código de programa a seguir. Na sequência estão dois outros
programas, um que gera o arquivo clientes e outro que lista o arquivo clientes.
/*
Usa um procedimento que altera um campo de um registro de um arquivo pela
geracao de um novo.
Se alteracao efetuada, devolve verdadeiro na variavel logica
alterou_ok.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAXNOME 30
#define MAXTEL 10
#define MAXEND 50
#define MAXCOD 50
#define MAX 50
void AltCampRegArq(FILE *, FILE *, char*, char*, int, struct regist, int*,
int);
struct regist
{
int cod;
char nome[MAXNOME];
char endereco[MAXEND];
 Respostas dos Exercícios de Fixação em C   47

char fone[MAXTEL];
};
int main( )
{
int codigo, resultalt;
FILE *arq_cli1;
FILE *arq_cli2;
struct regist reg;
system ("color 70");
char nome_cli1[MAX], nome_cli2[MAX];
fflush(stdin);
printf("Nome do arquivo de entrada (arq_cli1): ");
fgets(nome_cli1, sizeof(nome_cli1), stdin);
if (nome_cli1[strlen(nome_cli1) - 1] == '\n')
nome_cli1 [strlen(nome_cli1) - 1] = '\0';
fflush(stdin);
printf("Nome do arquivo de saida (arq_cli2): ");
fgets(nome_cli2, sizeof(nome_cli2), stdin);
if (nome_cli2[strlen(nome_cli2) - 1] == '\n')
nome_cli2 [strlen(nome_cli2) - 1] = '\0';
fflush(stdin);
do
{
printf("\nCodigo do registro a alterar: ");
scanf("%d", &codigo);
if (codigo < 1 || codigo > MAXCOD)
printf("Codigo deve ser entre 1 e %d", MAXCOD);
}
while ((codigo < 1) || (codigo > MAXCOD));
AltCampRegArq(arq_cli1, arq_cli2, nome_cli1,
nome_cli2, codigo, reg, &resultalt, MAX);
if (resultalt)
printf("\nAlteracao do reg %d bem sucedida!", codigo);
system("pause");
return 0;
}
void AltCampRegArq(FILE *arq_cli1, FILE *arq_cli2, char* nome_arq_cli1, char*
nome_arq_cli2, int codigo, struct regist reg, int* alterou_ok, int maximo)
{
char endereco_aux[maximo];
*alterou_ok = 0;
if(!(arq_cli1 = fopen(nome_arq_cli1,"r")))
{ //abre para leitura
printf("Erro de abertura arquivo arquivo de entrada");
system("pause");
}
else
{
if(!(arq_cli2 = fopen(nome_arq_cli2,"w")))
48     Respostas dos Exercícios de Fixação em C

{ //abre para escrita

printf("Erro de abertura arquivo arquivo de saida");
system("pause");
}
else
{
while(!feof(arq_cli1)) // laco de leitura
{
if (fread(&reg,sizeof(struct regist),1,arq_cli1)==1)
{
// se nao eh registro a alterar
if (reg.cod != codigo)
//grava reg sem alteacao
fwrite(&reg,sizeof(struct regist),1,arq_cli2);
else //achou registro a alterar
{
printf("\nNovo endereco: ");
fflush(stdin);
//leitura do endereco a alterar
fgets(endereco_aux, maximo, stdin);
if (endereco_aux[strlen(endereco_aux) - 1]== '\n')
endereco_aux [strlen(endereco_aux) - 1] = '\0';
fflush(stdin);
strcpy(reg.endereco, endereco_aux);
//reg.endereco = endereco_aux;
//grava reg alterado
fwrite(&reg,sizeof(struct regist),1,arq_cli2);
*alterou_ok = 1; //alteracao efetuada
}//else do if reg.cod
}//fim do if (fread...
}// fim do whil
fclose (arq_cli1);
fclose (arq_cli2);
}//fim do else do if (!(arq_cli2...
}
}

GeraArqCli - Programa que cria o arquivo clientes

/*Cria um arquivo de clientes*/

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define MAXNOME 30
#define MAXTEL 10
#define MAXEND 50
#define MAXCOD 50
#define MAX 50
struct regist
 Respostas dos Exercícios de Fixação em C   49

{
int cod;
char nome[MAXNOME];
char endereco[MAXEND];
char telefone[MAXTEL];

};
FILE* arq_cli;
FILE* abrearquivo(int);
int geraarquivo(FILE *,struct regist *, int, int, int, int);
void listagem(FILE *, struct regist *);
int main()
{
struct regist emp;
if(((arq_cli = abrearquivo(MAX))== NULL))
{
printf("\nOcorreu um erro na abertura do arquivo inicial.\n");
system("pause");
}
else
{
printf("Listados: %d",geraarquivo(arq_cli, &emp,
MAXCOD, MAXNOME, MAXTEL, MAXEND));
fclose(arq_cli);
system("pause");
return 0;
}
}
FILE * abrearquivo(int maximo)
{
char nome[maximo];
printf("\nInforme o nome do arquivo:");
fflush(stdin);
fgets(nome, maximo, stdin);
if (nome[strlen(nome)-1]=='\n')
(nome[strlen(nome)-1]='\0');
return fopen(nome, "wb+");
}
int geraarquivo(FILE *arquivo, struct regist *emp,
int max_cod, int max_nom, int max_fone, int max_end)
{
int continuar=0, cod=0, cont=0;
do
{
do
{
printf("\nCodigo da empresa (1 a %d):", max_cod);
fflush(stdin);
scanf("%d", &emp->cod);
50     Respostas dos Exercícios de Fixação em C

if((emp->cod < 1) || (emp->cod > max_cod))

printf("Erro! Informe outro valor, de 1 a %d.", max_cod);
}
while(((emp->cod)<1) || ((emp->cod)>max_cod));
cod = emp->cod - 1;
printf("Nome:");
fflush(stdin);
fgets((emp->nome),max_nom, stdin);
printf("Endereco:");
fflush(stdin);
fgets((emp->endereco),max_end, stdin);
printf("Telefone:");
fflush(stdin);
fgets((emp->telefone), max_fone, stdin);
fseek(arquivo,cod*sizeof(struct regist), SEEK_SET);
fwrite(emp, sizeof(struct regist), 1, arquivo);
printf("\nDeseja incluir outro registro ");
printf("(0-parar, outro inteiro para continuar)?");
scanf("%d", &continuar);
cont++;
}
while(continuar!=0);
return cont;
}

ListaArqCli – programa que lista o arquivo clientes

/*Lista um arquivo de clientes*/

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define MAXNOME 30
#define MAXTEL 10
#define MAXEND 50
#define MAX 50
struct regist
{
int cod;
char nome[MAXNOME];
char endereco[MAXEND];
char telefone[MAXTEL];
};
FILE* arq_cli;
FILE* abrearquivo(int);
void listagem(FILE *, struct regist *);
int main()
{
struct regist emp;
if(((arq_cli = abrearquivo(MAX))== NULL))
 Respostas dos Exercícios de Fixação em C   51

{
printf("\nOcorreu um erro na abertura do arquivo inicial.\n");
system("pause");
}
else
{
listagem(arq_cli, &emp);
fflush(stdin);
printf("\n");
fclose(arq_cli);
system("pause");
return 0;
}
}
FILE * abrearquivo(int maximo)
{
char nome[maximo];
printf("\nInforme o nome do arquivo:");
fflush(stdin);
fgets(nome, maximo, stdin);
if (nome[strlen(nome)-1]=='\n')
(nome[strlen(nome)-1]='\0');
return fopen(nome, "r");
}
void listagem(FILE *arquivo, struct regist *emp)
{
while(!feof(arquivo))
{
if(fread(emp, sizeof(struct regist), 1, arquivo)==1)
{
if ((emp->cod)>0)
{
printf("Codigo: %d\n\n", emp->cod);
printf("Nome: %s\n\n", emp->nome);
printf("Endereco: %s\n\n", emp->endereco);
printf("Fone: %s\n\n", emp->telefone);
}
}
}
}

Exercício 13.4  Procedimento CriaArqAtletRand

/*
Usa uma funcao void para a inclusao randômica de registros em
um arquivo com dados de atletas.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
52     Respostas dos Exercícios de Fixação em C

#define MAXCOD 10
#define MAXNOME 31
FILE *arq;
struct atlet
{
int cod;
char nome[MAXNOME];
int idade;
float altura;
};
void CriaArqAtletRand(FILE *, int, int, struct atlet);
void EliminaNovaLinha (char *);
FILE * AbreArqLeituraEEscrita (FILE *, char *);
void VeSePosOcupNoArq (FILE *, int , struct atlet, int *);
int main( )
{
struct atlet reg;
system ("color f1");
CriaArqAtletRand(arq, MAXCOD, MAXNOME, reg );
system("pause");
return 0;
}

void CriaArqAtletRand(FILE *arq, int maxcod, int maxnome, struct atlet atleta )
{
char nomearq[maxnome];
int cod_ent, op, a_listar, ocup;
int result_leitura;
struct atlet buffer;
fflush(stdin);
printf
("Nome do arquivo (com no maximo %d caracteres): ", maxnome - 1);
fgets(nomearq, sizeof(nomearq), stdin);
EliminaNovaLinha (nomearq);
fflush(stdin);
if (!(arq = AbreArqLeituraEEscrita (arq, nomearq)))
{
printf("Erro abertura");
system("pause");
}
else
{
do
{
do
{
printf("Codigo do atleta: ");
scanf("%d", &cod_ent);
if (cod_ent < 1 || cod_ent > maxcod)
 Respostas dos Exercícios de Fixação em C   53

printf
("\nCodigo deve estar entre 1 e %d!\n", maxcod);
}
while (cod_ent < 1 || cod_ent > maxcod);
VeSePosOcupNoArq (arq, cod_ent, atleta, &ocup);
if (!ocup)
{
atleta.cod = cod_ent;
fflush(stdin);
printf
("\nNome (com no maximo %d caracteres): ",
maxnome - 1);
fgets (atleta.nome, sizeof(atleta.nome), stdin);
EliminaNovaLinha (atleta.nome);
fflush(stdin);
printf("\nIdade: ");
scanf("%d",&atleta.idade);
printf("\nAltura: ");
scanf("%f",&atleta.altura);
fseek(arq,cod_ent*sizeof(struct atlet),SEEK_SET);
fwrite(&atleta,sizeof(struct atlet),1,arq);
fflush(arq);
}
else
printf
("\nCodigo - %d - inclusao para ja existente!\n", cod_ent);
printf("\n1-InserirNovo, 2-Encerrar\n");
scanf("%d", &op);
}
while(op != 2);
/*
//para ativar este trecho basta retirar os símbolos de
//comentario.
fseek(arq, 0 * sizeof(struct atlet), SEEK_SET);
printf("-----Comeco da listagem-----\n");
while(!feof(arq))
{
if (fread(&atleta,sizeof(struct atlet),1,arq) == 1)
{//le e confirma se o que foi lido eh estrutura,
//entao imprime
if (atleta.idade > 0)
{
printf("Codigo: %d\n", atleta.cod);
printf("Nome: %s\n",atleta.nome);
printf("Idade: %d\n",atleta.idade);
printf("Altura: %6.2f\n\n",atleta.altura);
}
}
}
54     Respostas dos Exercícios de Fixação em C

printf("-----Fim da listagem-----\n");
*/
fclose(arq);
}
}
void EliminaNovaLinha (char estringue[])
{
if (estringue[strlen(estringue) - 1] == '\n')
estringue[strlen(estringue) - 1] = '\0';
}
FILE * AbreArqLeituraEEscrita (FILE *arq, char *nomarq)
{/* tenta abrir como r+b, se o arquivo
nao existir abre como w + b*/
if(!(arq = fopen(nomarq,"r+b")))
arq = fopen(nomarq, "w+b");
return arq;
}
void VeSePosOcupNoArq (FILE *arq_atleta, int num, struct atlet reg, int *ocup)
{
//verifica se posicao num do arquivo esta ocupada
//posicionamento do arquivo
fseek(arq,num*sizeof(struct atlet),0);
*ocup = fread(&reg,sizeof(struct atlet),1,arq); // leitura
//ocup recebera 1 se leitura for bem sucedida.
//0, se nao existir a posicao
if (*ocup == 1 && reg.idade == 0)
// neste caso a posicao existe, mas eh do sistema,
// entao pode ser usada
*ocup = 0;
}

Exercício 13.5  Procedimento ListaSeqArqAtletRand

/*
Lista sequencialmente um arquivo com dados de uma estrutura
com informacoes de atletas. Arquivo gerado randomicamente.
Na listagem eh bloqueada a apresentacao de posicoes
para as quais nao foram fornecidos dados.
*/
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
struct atlet
{

int cod;
char nome[30];
int idade;
float altura;
};
 Respostas dos Exercícios de Fixação em C   55

void ListaSeqArqAtleRand (FILE *, struct atlet);

int main( )
{
FILE *arq_atleta;
struct atlet atleta;
int contlidos = 0;
char nome[15];
int op;
system("color 70");
ListaSeqArqAtleRand(arq_atleta, atleta);
system("pause");
return 0;
}
void ListaSeqArqAtleRand (FILE * arq_atleta, struct atlet atleta)
{
char nome[15];
int contlidos = 0;
printf("Nome do arquivo: ");
gets(nome);
fflush(stdin);
if(!(arq_atleta = fopen(nome,"rb")))
{
printf("Erro abertura");
system("pause");
}
else
{
printf("-----Comeco da listagem-----\n");
while(!feof(arq_atleta))
if (fread(&atleta,sizeof(struct atlet),1,arq_atleta) == 1)
{//lê e confirma se o que foi lido é estrutura,
//então imprime
contlidos++;
if (atleta.idade > 0)
{
printf("Codigo: %d\n", atleta.cod);
printf("Nome: %s\n",atleta.nome);
printf("Idade: %d\n",atleta.idade);
printf("Altura: %6.2f\n\n",atleta.altura);
}
}
printf("-----Fim da listagem-----\n");
fclose(arq_atleta);
}
}
56     Respostas dos Exercícios de Fixação em C

14  ponteiros e alocação dinâmica de memória

Exercício 14.1  Algoritmo TestePonteiro
//Exemplo de Lista Encadeada
#include <stdio.h>
#include <stdlib.h>
typedef struct treg
{
char letra;
struct treg *elo1;
struct treg *elo2;
};
int main ( )
{
struct treg *p1, *p2, *p3;
p1 = (struct treg *) malloc(sizeof(treg));
p2 = (struct treg *) malloc(sizeof(treg));
p3 = (struct treg *) malloc(sizeof(treg));
p1->letra = 'A';
p2->letra = 'B';
p3->letra = 'C';
p1->elo1 = p2;
p1->elo2 = p3;
printf("\nLetra das tres variaveis (direto): \n%c %c %c\n",
p1->letra, p2->letra, p3->letra);
printf("\nLetra pelos elos para variaveis 2 e 3: \n%c %c\n",
p1->elo1->letra, p1->elo2->letra);
system ("pause");
return 0;
}

Exercício 14.2  Procedimento MontaListaEncadeada

//Exemplo de uso de ponteiros.
//Cria listas das disciplinas e notas de todos os alunos.
//Depois informa disciplinas e notas de um determinado aluno
#include <stdio.h>
#include <stdlib.h>
#define MAXALUNOS 2
struct tipoNo
{
int codigo;
float valor;
struct tipoNo *elo;
};
tipoNo * MontaListaEncadeada( ) ;
int main ( )
{
int aluno;
 Respostas dos Exercícios de Fixação em C   57

int i;
struct tipoNo *plista_Al, *paux;
tipoNo *alunos[MAXALUNOS];
//ler dados de todos os alunos, montando listas
printf("\nForneca dados dos alunos\n ");
printf ("Codigo do aluno: ");
scanf("%d", &aluno); // leitura do codigo do primeiro aluno
// enquanto codigo for valido
while ((aluno > 0) && (aluno < (MAXALUNOS + 1)))
{
plista_Al = MontaListaEncadeada() ;
//Guardar ponteiro do inicio da lista desse aluno no vetor
alunos[aluno -1] = plista_Al;
printf ("\n\nCodigo do aluno: ");
scanf("%d", &aluno); // le codigo do proximo aluno
}
/*
//Para ativar este trecho, basta tirar os simbolos de //comentario.
//Lista disciplinas e medias de todos os alunos
for (i = 0; i < MAXALUNOS; i++)
{
printf("\n\nDados do aluno %d ", i + 1);
paux = alunos[i];
while (paux != NULL)
{
printf
("\nCodigo %d valor %6.2f", paux->codigo, paux->valor);
paux = paux->elo;
}
}
*/
//informar disciplinas e notas de um determinado aluno
printf("\n\n\nLista dados de um aluno determinado\n");
do
{
printf ("\n\nCodigo do aluno: ");
scanf("%d", &aluno); //leitura do codigo do aluno a ser pesquisado
if ((aluno < 1) || (aluno > MAXALUNOS))
printf("\nCodigo entre 1 e %d\n", MAXALUNOS);
}
while ((aluno < 1) || (aluno > MAXALUNOS));
paux = alunos[aluno - 1];
while (paux != NULL)
{
//informa disciplina e nota
printf("\nCodigo %d valor %6.2f", paux->codigo, paux->valor);
//avanca para proximo nodo
paux = paux->elo;
}
58     Respostas dos Exercícios de Fixação em C

printf("\n\n");
system ("pause");
return 0;
}
tipoNo * MontaListaEncadeada()
{
struct tipoNo *pnovo, *pult, *plista;
int cod;
float val;
//inicializar plista para lista vazia
plista = NULL;
//Ler dados da primeira disciplina
printf("\nForneca codigo da disciplina:");
scanf("%d", &cod);
printf("\nForneca media:");
scanf("%f", &val);
//repetir enquanto nao tiver sido lido o ultimo no
while (cod >= 0)
{
// alocar novo no para a lista
pnovo = (struct tipoNo *) malloc (sizeof (tipoNo));
//preencher no com os dados lidos
pnovo->codigo = cod;
pnovo->valor = val;
if (plista == NULL)
{
plista = pnovo;//eh o primeiro no da lista
pult = pnovo;
}
else
{
// encadear no novo com o ultimo
pult->elo = pnovo;
// avancar ponteiro do ultimo para o novo no alocado
pult = pnovo;
}
//ler dados das proximas disciplinas
printf("\nForneca codigo da disciplina:");
scanf("%d", &cod);
printf("\nForneca media:");
scanf("%f", &val);
}
if (plista != NULL) // testa se a lista tem algum no
pult->elo = NULL; // elo do ultimo passa a ser nulo

return plista;
}
 Respostas dos Exercícios de Fixação em C   59

15  recursividade
Exercícios 15.1  Procedimento MostraVersão1
/*Usa uma funcao void recursiva, com informacoes sendo apresentadas
na fase do desempilhamento.*/
#include <stdio.h>
#include <stdlib.h>
void MostraVersao1(int, int);
int main ( )
{
int vali = 2;
int valn = 8;
system("color f1");
MostraVersao1(vali, valn);
printf("\n\n");
system("pause");
return 0;
}
void MostraVersao1(int i, int n)
{
if (i >= n)
{
printf("\n\nChamadas Recursivas concluidas");
printf("\n%d", i);
}
else
{
MostraVersao1(i+2, n);
printf("\n%d", i);
}
}

Procedimento MostraVersão2
/*Usa uma funcao void recursiva, com informacoes sendo apresentadas
na fase do empilhamento.*/
#include <stdio.h>
#include <stdlib.h>
void MostraVersao1(int, int);
int main ( )
{
int vali = 2;
int valn = 8;
system("color f1");
MostraVersao1(vali, valn);
printf("\n\n");
system("pause");
return 0;
}
60     Respostas dos Exercícios de Fixação em C

void MostraVersao1(int i, int n)

{
if (i >= n)
{
printf("\nChamadas Recursivas concluidas");
printf("\n%d", i);
}
else
{
printf("\n%d", i);
MostraVersao1(i+2, n);

}
}

Exercício 15.2  Função Fibonacci: inteiro

/*Usa uma funcao inteira que calcula o n-esimo termo da serie de Fibonacci.*/
#include <stdio.h>
#include <stdlib.h>
int Fibonacci(int);
int main ( )
{
int termo;
system("color f1");
printf("\nQue termo deve ser calculado? ");
scanf("%d", &termo);
printf("\n\n O termo %d eh %d\n", termo, Fibonacci(termo));
system("pause");
return 0;
}
int Fibonacci(int n)
{
if (n<3)
return n - 1;
else
return Fibonacci(n - 1) + Fibonacci(n - 2);
}

Exercício 15.3  Procedimento Quick

/*Usa uma funcao void que classifica um vetor em ordem crescente, pelo
quicksort, de forma recursiva.*/
#include <stdio.h>
#include <stdlib.h>
#define LIMSUP 6

void Quick(int *, int, int);

void Troca (int*, int*);
int main ( )
 Respostas dos Exercícios de Fixação em C   61

{
int vetor[LIMSUP];
int i;
system("color f1");
for (i = 0; i < LIMSUP; i++)
{
printf("\nValor %d: ", i + 1);
scanf("%d", &vetor[i]);
}
for (i = 0; i < LIMSUP; i++)
printf("\n%d ", vetor[i]);
Quick(vetor,0, LIMSUP - 1);
for (i = 0; i < LIMSUP; i++)
printf("\n%d ", vetor[i]);
printf("\n\n");
system("pause");
return 0;
}
void Quick(int *v, int li, int ls)
{
int x;
int i, j; // indices utilizados para percorrer o vetor
int pivo; // valor contido no primeiro elemento considerado
int sinal; // indica final de uma varredura
sinal = 0;
if (li < ls)
{
i = li; // posiciona i e j no inicio e no final
j = ls;
pivo = v[li];
do
{
i++;
//avanca i enquanto o elemento for inferior ao pivo e nao chegar
//ao final do segmento analisado
while ((v[i] < pivo) && (i < ls))
i++;
//recua j enquanto o elemento for superior ao pivo
//e nao chegar ao inicio do segmento analisado
while ((v[j] > pivo) && (j > li))
j-- ;
if (i < j) // permuta dois elementos
Troca(v + i, v + j);
else
sinal = 1; // indica que terminou
}
while (!sinal);
Troca(v + j, v + li); //posiciona pivo em sua posicao
Quick(v, li, j - 1);
62     Respostas dos Exercícios de Fixação em C

Quick(v, j + 1, ls);
}
}
void Troca(int *a, int *b)
{
int aux;
aux = *a;
*a = *b;
*b = aux;
}

Exercício 15.4  Função Lugar: inteiro

/*Usa uma funcao recursiva para devolver a posicao onde se encontra um valor
x, em um vetor v, atraves de pesquisa binaria.
Caso o valor nao seja encontrado, a funcao devolve -1. O vetor deve estar
ordenado em ordem crescente.
*/
#include <stdio.h>
#include <stdlib.h>
#define MAX 5
int lugar (int *, int, int, int);
int main ( )
{
int vetor[MAX];
int i, j, valor, pos;
system("color 70");
printf
("\nForneca os %d valores inteiros do vetor, em ordem crescente\n",
MAX);
for (i = 0; i < MAX; i++)
{
printf ("\nValor [%d]:", i + 1);
scanf ("%d", vetor + i);
}
printf("\nValores lidos:\n");
for (i = 0; i < MAX; i++)
printf ("%d ", *(vetor + i));
printf("\n\n");
printf("\nValor a pesquisar (negativo para parar): ");
scanf("%d", &valor);
while (valor >= 0)
{
pos = lugar (vetor, valor, 0, MAX - 1);
if (pos < 0)
printf("\nValor %d nao achado!\n", valor);
else
printf
("\nValor %d achado na posicao %d\n", valor, pos + 1);
printf("\nValor a pesquisar (negativo para parar): ");
 Respostas dos Exercícios de Fixação em C   63

scanf("%d", &valor);
}
printf("\nPesquisa encerrada!\n");
system("pause");
return 0;
}
int lugar (int *v, int x, int inf, int sup)
{
int meio;
if (((inf == sup) && (v[sup] != x)) || (inf > sup))
return -1; // nao achou
else
{
// determina elemento central
meio = (inf + sup) / 2;
if (*(v + meio) == x)
return meio; //achou
else
//identifica a metada onde sera continuada a pesquisa e
//faz chamada recursiva, alterando um dos limites.
if (x < *(v + meio))
return lugar(v, x, inf, meio - 1); //metade superior
else
return lugar(v, x, meio + 1, sup); //metade inferior
}
}

Exercício 15.5  Função PalíndromaRec: lógico var

/*Usa uma funcao recursiva que retorna verdadeiro
se uma string recebida como parametro for uma palindroma.
Palavra fornecida nao pode conter espacos.*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAXNOME 60
int palindroma (char *, int, int);
int main ( )
{
int resultado;
char palavra[MAXNOME];
printf("Forneca palavra a verificar: ");
scanf("%s", &palavra);
if (palindroma(palavra, 0, (strlen(palavra) - 1)))
printf("\n\n Eh palindroma");
else
printf("\n\n Nao eh palindroma");
printf("\n\n");
system("pause");
return 0;
64     Respostas dos Exercícios de Fixação em C

}
int palindroma (char s [], int inicio, int fim )
{
if (inicio >= fim)
return 1;
else
if (s[inicio] == s[fim])
return palindroma(s, ++inicio, --fim);
else
return 0;
}

Exercício 15.6  Procedimento RV

/*Usa uma funcao recursiva para ler uma sequencia de caracteres terminada pelo
caractere # e imprimi-la de tras para diante.
*/
#include <stdio.h>
#include <stdlib.h>
void RV ();
int main ( )
{
printf("\nForneca uma sequencia de caracteres terminada por #:");
RV();
printf("\n");
system("pause");
return 0;
}
void RV ()
{
char c;
scanf(" %c", &c);
if (c != '#')
RV( );
printf("%c", c);
}