CENTRO UNIVERSITÁRIO INTERNACIONAL UNINTER

ESCOLA SUPERIOR POLITÉCNICA

BACHARELADO EM ENGENHARIA DA COMPUTAÇÃO
DISCIPLINA DE LÓGICA DE PROGRAMAÇÃO E ALGORITMOS

ATIVIDADE PRÁTICA

ALIAN VARGAS PITTA – RU: 3288581

PROFESSOR: VINICIUS POZZOBON BORIN

PETRÓPOLIS - RIO DE JANEIRO

2020
1 EXERCÍCIO

ENUNCIADO: Faça um algoritmo em linguagem C para calcular quanto cada cliente

gastou em pedidos realizados em uma lancheria. A lancheria vende os seguintes produtos:

Ao iniciar o programa, deve-se aparecer na tela um menu com todos os itens vendidos e
seus respectivos preços. O usuário deve escolher digitando de 1-7 qual item quer comprar.
Observe que o usuário pode comprar o mesmo item diversas vezes e também pode comprar
vários itens diferentes (exemplo: 2 águas e um cachorro-quente, no mesmo pedido). Para en-
cerrar o processo de compra, o usuário deve digitar um valor diferente de 17. Ao encerrar a
compra, deve-se listar todos os itens comprados, seus preços individuais e o total a se pagar.
Imprima na tela um teste do seu programa utilizando os três primeiros e os últimos dígitos do
seu RU da UNINTER como os valores de entrada para os pedidos. Os três primeiros dígitos
serão os itens comprados, e os três últimos a quantidade de cada item comprado. Por exemplo,
se seu RU for 1234567, a compra resultante será:

1
Código:
#include <stdio.h>//Esta biblioteca contém várias funções de entrada e saída
#include <stdlib.h>//Esta biblioteca contém várias funções e constantes básicas
#include <locale.h>//necessário para usar setlocale

/*Prototipagem de função*/
char * pedido_nome(int numero_pedido);
void limpa_buffer();

// Declaracao de variaveis
int opcao,qntd, indice,c = 0;
float total = 0;
float pedido[50][4]; //50 linhas e 4 colunas (ate 50 pedidos por vez)
char nome_pedido[15];// 15 linhas

int main()
{
// Acentuação em português
setlocale(LC_ALL, "Portuguese");
system("cls"); // Limpar a tela

do
{
// Menu de Oppces
if(indice == 0) // Caso nao tenha nenhum pedido, o menu parecera.
{
printf("\n");
printf("*************Aluno: Alian Vargas Pitta***RU: 3288581************\n");
printf("****************************************************************\n");
printf("******************Opção de 1 a 7 para pedidos*******************\n");
printf("*******Opção que não seja de 1 a 7, para cancelar o pedido******\n");
printf("****************************************************************\n");
printf("* *\n");
printf("* ITEM PRODUTO CÓDIGO VALOR UNITÁRIO *\n");
printf("* 1 Cachorro-quente 100 5,00 *\n");
printf("* 2 X-salada 101 8,79 *\n");
printf("* 3 X-bacon 102 9,99 *\n");
printf("* 4 Misto 103 6,89 *\n");
printf("* 5 Salada 104 4,80 *\n");
printf("* 6 Água 105 3,49 *\n");
printf("* 7 Refrigerante 106 4,99 *\n");
printf("* 8 Sorvete 107 3,50 *\n");
printf("****************************************************************\n");
}
else //Se ja houver algum item no pedido, pula uma linha
printf("\n");

//Pede para usuário entrar com uma opcao e utiliza o "scanf" para armazenar essa
entrada na variavel "opcao"
printf("Entre com uma opção: ");
scanf("%d", &opcao);
limpa_buffer(); //Funcao para limpar buffer do teclado.

//Se o valor de entrada estiver entre 1 e 7 o programa segue

if(opcao >= 1 && opcao <= 8)
{
//Exibe o nome do item escolhido
printf("---> %s", pedido_nome(opcao));
//Pede para o usuario entrar com a quantidade desejada e utiliza o "scanf" para
armazenar essa entrada na variavel "qntd"
printf("\nQuantidade: ");
scanf("%d",&qntd);
limpa_buffer(); //Funcao para limpar buffer do teclado.

//Se a quantidade for menor que 1, entra no laco de repeticao "while" ate que uma
quantidade maior ou igual a 1 seja inserida
while(qntd<1)
{
printf("\nPedido mínimo é de 1 e seu pedido foi de %d", qntd);
printf("\nQuantidade: ");
scanf("%d",&qntd);
}
}

// Montagem da lista de pedidos

// Armazena a opcao escolhida, a quantidade e o preco na matriz
switch (opcao)
{
case 1:
pedido[indice][0] = opcao;
pedido[indice][1] = qntd;
pedido[indice][2] = 5.00;
indice++;
break;
case 2:
pedido[indice][0] = opcao;
pedido[indice][1] = qntd;
pedido[indice][2] = 8.79;
indice++;
break;
case 3:
pedido[indice][0] = opcao;
pedido[indice][1] = qntd;
pedido[indice][2] = 9.99;
indice++;
break;
case 4:
pedido[indice][0] = opcao;
pedido[indice][1] = qntd;
pedido[indice][2] = 6.89;
indice++;
break;
case 5:
pedido[indice][0] = opcao;
pedido[indice][1] = qntd;
pedido[indice][2] = 4.80;
indice++;
break;
case 6:
pedido[indice][0] = opcao;
pedido[indice][1] = qntd;
pedido[indice][2] = 3.49;
indice++;
break;
case 7:
pedido[indice][0] = opcao;
pedido[indice][1] = qntd;
pedido[indice][2] = 4.99;
indice++;
break;
case 8:
pedido[indice][0] = opcao;
pedido[indice][1] = qntd;
pedido[indice][2] = 3.50;
indice++;
break;

default:
printf("Opção inválida");
break;
}
}
while(opcao >=1 && opcao <=8);

system("cls"); //Limpa a tela

// Impressao do relatorio de pedidos
printf("Relatório dos Pedidos\n");
printf("\nITEM \t NOME \t\t\t QTDE \t PREÇO \t VALOR\n");//Utilizando tabulacao
para melhor visualizacao
for (int i = 0; i < indice; i++)
{
//De acordo com o dedido, teremos um nome do pedido e esse nome varia de tamanho.
E feita uma verificacao do pedido para inserir a tabulacao
//de acordo com ele, assim a visualizacao do pedido sempre estara alinhada de
acordo com o titulo das colunas
if(pedido[i][0] == 1)
printf("%.0f \t %s \t %.0f \t %.2f \t %.2f\n", pedido[i][0], pedido_nome(pe-
dido[i][0]), pedido[i][1], pedido[i][2], (pedido[i][1] * pedido[i][2]));
else if(pedido[i][0] == 2 || pedido[i][0] == 3)
printf("%.0f \t %s \t\t %.0f \t %.2f \t %.2f\n", pedido[i][0], pedido_nome(pe-
dido[i][0]), pedido[i][1], pedido[i][2], (pedido[i][1] * pedido[i][2]));
else if(pedido[i][0] == 4 || pedido[i][0] == 6)
printf("%.0f \t %s \t\t\t %.0f \t %.2f \t %.2f\n", pedido[i][0], pedido_nome(pe-
dido[i][0]), pedido[i][1], pedido[i][2], (pedido[i][1] * pedido[i][2]));
else if(pedido[i][0] == 5 || pedido[i][0] == 7 || pedido[i][0] == 8)
printf("%.0f \t %s \t\t %.0f \t %.2f \t %.2f\n", pedido[i][0], pedido_nome(pe-
dido[i][0]), pedido[i][1], pedido[i][2], (pedido[i][1] * pedido[i][2]));
else
printf("%.0f \t %s \t\t %.0f \t %.2f \t %.2f\n", pedido[i][0], pedido_nome(pe-
dido[i][0]), pedido[i][1], pedido[i][2], (pedido[i][1] * pedido[i][2]));

total += (pedido[i][1] * pedido[i][2]);//Multiplica o valor do pedido pela quanti-

dade e insere na variavel total, isso se repetira ate "varrer" todos os pedidos
}
printf("\n\nValor Total do Pedido: %.2f\n\n", total); // Impressao do valor total
dos pedidos
system("pause");

return 0;
}

//Funcao para retornar o nome do pedido de acordo com o codigo

char * pedido_nome(int numero_pedido)
{
char *retorno;
// alocando 20 posições de char
// igual ponteiro ...
retorno=malloc(15*sizeof(char));

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

{
retorno[i] = NULL;
}

switch (numero_pedido) // Montagem da lista de pedidos

{
case 1:
retorno[0] = 'C';
retorno[1] = 'a';
retorno[2] = 'c';
retorno[3] = 'h';
retorno[4] = 'o';
retorno[5] = 'r';
retorno[6] = 'r';
retorno[7] = 'o';
retorno[8] = '-';
retorno[9] = 'q';
retorno[10] = 'u';
retorno[11] = 'e';
retorno[12] = 'n';
retorno[13] = 't';
retorno[14] = 'e';
break;
case 2:
retorno[0] = 'X';
retorno[1] = '-';
retorno[2] = 's';
retorno[3] = 'a';
retorno[4] = 'l';
retorno[5] = 'a';
retorno[6] = 'd';
retorno[7] = 'a';
break;
case 3:
retorno[0] = 'X';
retorno[1] = '-';
retorno[2] = 'b';
retorno[3] = 'a';
retorno[4] = 'c';
retorno[5] = 'o';
retorno[6] = 'n';
break;
case 4:
retorno[0] = 'M';
retorno[1] = 'i';
retorno[2] = 's';
retorno[3] = 't';
retorno[4] = 'o';
break;
case 5:
retorno[0] = 'S';
retorno[1] = 'a';
retorno[2] = 'l';
retorno[3] = 'a';
retorno[4] = 'd';
retorno[5] = 'a';
break;
case 6:
retorno[0] = 'Á';
retorno[1] = 'g';
retorno[2] = 'u';
retorno[3] = 'a';
break;
case 7:
retorno[0] = 'R';
retorno[1] = 'e';
retorno[2] = 'f';
retorno[3] = 'r';
retorno[4] = 'i';
retorno[5] = 'g';
retorno[6] = 'e';
retorno[7] = 'r';
retorno[8] = 'a';
retorno[9] = 'n';
retorno[10] = 't';
retorno[11] = 'e';
break;
case 8:
retorno[0] = 'S';
retorno[1] = 'o';
retorno[2] = 'r';
retorno[3] = 'v';
retorno[4] = 'e';
retorno[5] = 't';
retorno[6] = 'e';
break;

default:
retorno[0] = 'E';
retorno[1] = 'R';
retorno[2] = 'R';
retorno[3] = 'O';
break;
}

return retorno;
}

//Funcao para limpar buffer do teclado

void limpa_buffer()
{
while ((c = getchar()) != '\n' && c != EOF);
}

Imagem do código sendo executado:

2 EXERCÍCIO

Faça um algoritmo em linguagem C que receba como dado de entrada a quantidade máxima
em milímetros que um reservatório de água suporta. E também como dado de entrada informe
quantos milímetros de chuva tivemos em cada mês do ano, e quantos milímetros deste reser-
vatório por mês foi gasto. Armazene as informações de cada mês em vetores de dados. Sa-
bendo a capacidade do reservatório, quanto choveu em cada mês e quanto foi gasto. Informe o
valor disponível de água, em milímetros, para cada mês do ano. Caso o reservatório fique va-
zio em algum momento, informe isso na tela. Caso o reservatório fique cheio em algum mo-
mento, também informe isso na tela. Imprima na tela um teste do seu programa utilizando o
seu RU da UNINTER como os valores de entrada, cada dígito do seu RU será um dos valores
gastos, em milímetros, por mês. Por exemplo, se seu RU for 1234567, faça:
Código:
#include <stdio.h>//Esta biblioteca contém várias funções de entrada e saída
#include <stdlib.h>//Esta biblioteca contém várias funções e constantes básicas
#include <locale.h>//necessário para usar setlocale

//Prototipagem de funcao
char * retorna_mes(int num_mes);

//Declaracao de variaveis
float ml_capac_reserv, ml_chuva_mes, ml_gasto_mes, resultado_mes, resultado_acumu-
lado, calculo = 0.0;
int contador = 0;
float meses_entrada_gasto[12][12];

int main()
{
// Acentuacao em portugues
setlocale(LC_ALL, "Portuguese");
//Pedindo ao usuario para entrar com a capacidade do reservatorio em milimetros
printf("Entre com a capacidade do reservatório em milímetros: ");
scanf("%f", &ml_capac_reserv);
printf("\n\n");

//Enquanto o contador for menor que 12 (0 até o 11)

while(contador < 12)
{
printf("Entre a com a quantidade em milímetros de chuva que teve em %s: ",re-
torna_mes(contador));
scanf("%f", &meses_entrada_gasto[contador][0]);
printf("Entre com a quantidade em milímetros de água gasta em %s: ",re-
torna_mes(contador));
scanf("%f", &meses_entrada_gasto[contador][1]);

//Pega o valor de entrada em mm no mes e subtrai pelo que foi gasto

resultado_mes = meses_entrada_gasto[contador][0] - meses_entrada_gasto[conta-
dor][1];
//Adiciona o valor em uma variavel que ira "monitorar" o estado atual do reserva-
torio
resultado_acumulado += resultado_mes;

//Se o acumulado for menor

if(resultado_acumulado <=0)
{
printf("\nRESERVATÓRIO VAZIO, NO MÊS DE %s O GASTO FOI DE %.2f mm\n\n",re-
torna_mes(contador),resultado_mes);
printf("\a");
resultado_acumulado = 0;// Garante que o valor nao ficara negativo
}
//Caso o valor acumulado fique maior ou igual a capacidade do reservatorio
else if(resultado_acumulado >= ml_capac_reserv)
{
printf("\nRESERVATÓRIO CHEIO, A CAPACIDADE ATUAL É DE %.2f mm E O ACUMULADO ESTÁ
EM %.2f mm.\n\n",ml_capac_reserv,resultado_acumulado);
printf("\a");
resultado_acumulado = ml_capac_reserv;// Garante que o valor nao ficara maior do
que se pode armazenar
}

//caso contrario, segue a execucao normal

else
{
if(resultado_mes < 0 && contador == 0)// Se o armazenado no mes de Janeiro (conta-
tor == 0) for inferior ao gasto
printf("No mês de %s o gasto foi superior ao armazenado da chuva, tivemos uma
perda de %.2f mm.\n",retorna_mes(contador),resultado_mes);

if(resultado_mes < 0 && contador > 0)// Se o armazenado no mes de Fevereiro a De-
zembro (contator > 0) for inferior ao gasto
printf("No mês de %s o gasto foi superior ao armazenado da chuva, em relação ao
armazenado pelo mês anterior tivemos uma perda de %.2f mm.\n",retorna_mes(conta-
dor),resultado_mes);

else if(resultado_mes > 0 && contador == 0)// Se o armazenado no mes de Janeiro

(contator == 0) for superior ao gasto
printf("No mês de %s o acumulo pelas chuvas foi superior ao gasto, tivemos um ar-
mazenamenro de %.2f mm.\n",retorna_mes(contador),resultado_mes);

else if(resultado_mes > 0 && contador > 0)// Se o armazenado no mes de Fevereiro a
Dezembro (contator > 0) for superior ao gasto
printf("No mês de %s o acumulo pelas chuvas foi superior ao gasto, em relação ao
mês anterior tivemos um aumento de %.2f mm.\n",retorna_mes(contador),resul-
tado_mes);

else if(resultado_mes == 0)//Caso o armazenado e o gasto forem iguais

printf("No mês de %s tanto o gasto quando o que foi armazenado se equivale-
ram.\n",retorna_mes(contador));

printf("O acumulado está em: %.2f mm", resultado_acumulado);

printf("\n\n");
}

contador++;//Incrementa o contador
}
system("cls"); // Limpar a tela
printf("*******************************************\n");
printf("CAPACIDADE DO RESERVATORIO: %.2f mm\n",ml_capac_reserv);
printf("*******************************************\n");
printf("MÊS \t\t CHUVA \t\t GASTO \t\t ARMAZENADO\n");

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

{
if(i == 0 || i == 1 || i == 8 || i == 9 || i == 10 || i == 11)//De acordo com o
mes, as tabulacoes serao diferentes para uma melhor visualizacao dos resultados
{
calculo = meses_entrada_gasto[i][0] - meses_entrada_gasto[i][1];

if((meses_entrada_gasto[i][0] - meses_entrada_gasto[i][1]) <= 0) //vazio

printf("%s \t %.2f mm \t %.2f mm \t VAZIO\n",retorna_mes(i),meses_en-
trada_gasto[i][0],meses_entrada_gasto[i][1]);
else if((meses_entrada_gasto[i][0] - meses_entrada_gasto[i][1]) >= ml_capac_re-
serv) //CHEIO
printf("%s \t %.2f mm \t %.2f mm \t CHEIO\n",retorna_mes(i),meses_en-
trada_gasto[i][0],meses_entrada_gasto[i][1]);
else
printf("%s \t %.2f mm \t %.2f mm \t %.2f mm\n",retorna_mes(i),meses_en-
trada_gasto[i][0],meses_entrada_gasto[i][1],(meses_entrada_gasto[i][0] - meses_en-
trada_gasto[i][1]));

//printf("%s \t %.2f mm \t %.2f mm \t %.2f\n",retorna_mes(i),meses_en-

trada_gasto[i][0][0],meses_entrada_gasto[i][1][0],(meses_entrada_gasto[i][0][0] -
meses_entrada_gasto[i][1][0]));
}

else
{
if((meses_entrada_gasto[i][0] - meses_entrada_gasto[i][1]) <=0) //vazio
printf("%s \t\t %.2f mm \t %.2f mm \t VAZIO\n",retorna_mes(i),meses_en-
trada_gasto[i][0],meses_entrada_gasto[i][1]);
else if((meses_entrada_gasto[i][0] - meses_entrada_gasto[i][1]) >= ml_capac_re-
serv) //CHEIO
printf("%s \t\t %.2f mm \t %.2f mm \t CHEIO\n",retorna_mes(i),meses_en-
trada_gasto[i][0],meses_entrada_gasto[i][1]);
else
printf("%s \t\t %.2f mm \t %.2f mm \t %.2f mm\n",retorna_mes(i),meses_en-
trada_gasto[i][0],meses_entrada_gasto[i][1],(meses_entrada_gasto[i][0] - meses_en-
trada_gasto[i][1]));
//printf("%s \t\t %.2f mm \t %.2f mm \t %.2f\n",retorna_mes(i),meses_en-
trada_gasto[i][0][0],meses_entrada_gasto[i][1][0],(meses_entrada_gasto[i][0][0] -
meses_entrada_gasto[i][1][0]));
}
}

system("pause");
return 0;
}

//Funcao para retornar o nome do mes

char * retorna_mes(int num_mes)
{
char *retorno;
// alocando 10 posições de char
// igual ponteiro ...
retorno=malloc(10*sizeof(char));

//Laco de repeticao para "limpar" o vetor antes da utilizacao, assim evita de

ficar algum "lixo"
for(int i = 0; i<10; i++)
{
retorno[i] = NULL;
}

//De acordo com o numero do mes, retorna o nome.

switch(num_mes)
{
case 0:
retorno[0] = 'J';
retorno[1] = 'A';
retorno[2] = 'N';
retorno[3] = 'E';
retorno[4] = 'I';
retorno[5] = 'R';
retorno[6] = 'O';
break;
case 1:
retorno[0] = 'F';
retorno[1] = 'E';
retorno[2] = 'V';
retorno[3] = 'E';
retorno[4] = 'R';
retorno[5] = 'E';
retorno[6] = 'I';
retorno[7] = 'R';
retorno[8] = 'O';
break;
case 2:
retorno[0] = 'M';
retorno[1] = 'A';
retorno[2] = 'R';
retorno[3] = 'Ç';
retorno[4] = 'O';
break;
case 3:
retorno[0] = 'A';
retorno[1] = 'B';
retorno[2] = 'R';
retorno[3] = 'I';
retorno[4] = 'L';
break;
case 4:
retorno[0] = 'M';
retorno[1] = 'A';
retorno[2] = 'I';
retorno[3] = 'O';
break;
case 5:
retorno[0] = 'J';
retorno[1] = 'U';
retorno[2] = 'N';
retorno[3] = 'H';
retorno[4] = 'O';
break;
case 6:
retorno[0] = 'J';
retorno[1] = 'U';
retorno[2] = 'L';
retorno[3] = 'H';
retorno[4] = 'O';
break;
case 7:
retorno[0] = 'A';
retorno[1] = 'G';
retorno[2] = 'O';
retorno[3] = 'S';
retorno[4] = 'T';
retorno[5] = 'O';
break;
case 8:
retorno[0] = 'S';
retorno[1] = 'E';
retorno[2] = 'T';
retorno[3] = 'E';
retorno[4] = 'M';
retorno[5] = 'B';
retorno[6] = 'R';
retorno[7] = 'O';
break;
case 9:
retorno[0] = 'O';
retorno[1] = 'U';
retorno[2] = 'T';
retorno[3] = 'U';
retorno[4] = 'B';
retorno[5] = 'R';
retorno[6] = 'O';
break;
case 10:
retorno[0] = 'N';
retorno[1] = 'O';
retorno[2] = 'V';
retorno[3] = 'E';
retorno[4] = 'M';
retorno[5] = 'B';
retorno[6] = 'R';
retorno[7] = 'O';
break;
case 11:
retorno[0] = 'D';
retorno[1] = 'E';
retorno[2] = 'Z';
retorno[3] = 'E';
retorno[4] = 'M';
retorno[5] = 'B';
retorno[6] = 'R';
retorno[7] = 'O';
break;
default:
retorno[0] = 'E';
retorno[1] = 'R';
retorno[2] = 'R';
retorno[3] = 'O';
break;
}
return retorno;
}

Imagem do código sendo executado:

3 EXERCÍCIO

Faça um algoritmo em linguagem C que receba como dado de entrada uma matriz de ca-
racteres. Cada posição da matriz deve armazenar um caractere.
A dimensão da matriz deverá ser MxN, onde M e N são dados de entrada escolhidos
pelo usuário. Declare a matriz como sendo de dimensão máxima 10x10, e valide os
valores de M e N, que devem estar entre 1 e 10, incluindo 1 e 10. Para a valida-
ção, o usuário deve ficar preso no programa enquanto não digitar um número válido
para M e para N. Após escolhida a dimensão da matriz e povoado ela com caracteres.
Faça:
• Conte o número de ocorrências de cada caractere que aparece na matriz. Após a
contagem, liste cada caractere digitado e o número de ocorrências;
• Crie uma função que receba como parâmetro o primeiro caractere cadastrado na ma-
triz. A função deve retornar um dado numérico. Se o caractere for maiúsculo, re-
torne na função o resultado deste caractere dividido por 10. Caso contrário, re-
torne o resultado do caractere multiplicado por 2; Imprima na tela um teste do seu
programa utilizando como primeiro caractere a primeira letra do seu nome.

Código:
#include <stdio.h>//Esta biblioteca contém várias funções de entrada e saída
#include <stdlib.h>//Esta biblioteca contém várias funções e constantes básicas
#include <locale.h>//necessário para usar setlocale

/*Declaracao de variaveis*/
char caracter[10][10], vetor[100], entr_char, aux;
int M, N, indice, cont, c, i, j;
float resultado,primeira_letra;
/*Fim da declaracao de variaveis*/

/*Declaracao de funcoes*/
void matriz_entrada();
void dados_matriz();
void exibi_matriz();
void exibe_ocorrencia_caraceres();
float primeiro_caracter(float caracter_entrada, char prim_letra);
void limpa_buffer();
/*Fim declaracao de funcoes*/

int main()
{
// Acentuação em português
setlocale(LC_ALL, "Portuguese");
/*Funcao principal (main) chama as outras funcoes
*/
matriz_entrada();// Chama a funcao
dados_matriz();// Chama a funcao
exibi_matriz();// Chama a funcao
exibe_ocorrencia_caraceres();// Chama a funcao
printf("Resultado da função: %.2f",primeiro_caracter(caracter[0][0],carac-
ter[0][0]));// Chama a funcao, passa como parametro o primeiro caracter e exibe o
retorno da funcao
printf("\n\n");//Qubra de linhas
system("pause");
return 0;
}

/*Funcao para pedir ao usuario que digite o tamanho em

Linhas e Colunas para a matriz bidimensional.
*/
void matriz_entrada()
{
do// Foi utilizado o "DO WHILE" porque e preciso que seja executado primeiro pra
depois verificar se esta de acordo com o requerido
{
printf("\nDigite valores de 1 a 10 para quantidade de Linhas: ");
scanf_s("%d", &M);
limpa_buffer(); //Funcao para limpa buffer do teclado.
}
//Laco de repeticao referente as Linhas
while (M < 1 || M > 10);// validação dos numeros de 1 a 10

do
{
//imprime instrucões ao usuário
printf("\nDigite valores de 1 a 10 para quantidade de Colunas: ");
scanf_s("%d", &N);// amarzena o dado na variavel.
limpa_buffer(); //Funcao para limpa buffer do teclado.
}
//Laco de repeticao referente as Colunas
while (N < 1 || N > 10); // validação dos numeros de 1 a 10
}

//Funcao para pedir que o usuario entre com os dados e armazena esses dados na ma-
triz
void dados_matriz()
{
for (i = 0; i < M; i++)
{
for (j = 0; j < N; j++)
{
//mostra para o usuario a posição que esta a matriz.
printf("Digite o caracter [%d] [%d]: ", i, j);
scanf_s("%c", &caracter[i][j]);// amarzena o dado digitado pelo usuário na matriz
bidimensional na sua posicao atual ([M][N]).
limpa_buffer(); //Funcao para limpa buffer do teclado.
}
}
}

//Funcao para exibir os dados da matriz

void exibi_matriz()
{
// Exibe a mensagem para usuario
printf("Matriz formada de Linhas x Colunas.\n");
for (i = 0; i < M; i++)//Laco de repeticao das Linhas
{
for (j = 0; j < N; j++)//Laco de repeticao das Colunas
{
printf("%c ", caracter[i][j]);//imprime o valor da matriz na posicao atual
([M][N])
}
printf("\t");//Tabulacao, para melhor exibicao dos dados
}

printf("\n\n");//Quebra de M, para melhor exibicao dos dados

}

// Funcao para mostrar a quantidade de vezes que cada caracter foi inserido
void exibe_ocorrencia_caraceres()
{
// inicia a variavel em 0.
indice = 0;
//Armazena todos os dados da matriz em um vetor e utiliza a variavel indice para
"contar" o tamanho do vetor
for (i = 0; i < M; i++)
{
for (j = 0; j < N; j++)
{
vetor[indice] = caracter[i][j];
indice++;
}
}

//Laco de repeticao que varre todo o vetor para verificar quantas ocorrencias tem
de cada caracter
//E ordenar de acordo com a tabela ASCII
//A variavel "i" deve ser menor que o indice, porque o laço de repeticao, nao pre-
cisa varrer todas as posicoes, ja que nao faz sentido comparar o caractere com ele
mesmo.
for (i = 0; i < indice; i++)
{
//Laco de repeticao para comparar o caracter que esta na posicao atual (i) com o
caracter seguinte (j = i+1)
for (j = i + 1; j < indice; j++)
{
//printf("\n\n I = %d J = %d Indice = %d Vetor i = %d e vetor j = %d",i , j,in-
dice, vetor[i], vetor[j]);
//printf("\n\n");
if (vetor[i] > vetor[j])// Se o caracer atual for maior (de acordo com seu valor
na tabela ASCII) que o caracter seguinte, a posicao deles sera trocada dentro do
vetor
{
//printf("DENTRO DO IF -- I = %d J = %d Indice = %d Vetor i = %d e vetor j = %d",i
, j,indice, vetor[i], vetor[j]);
//printf("\n");
aux = vetor[i];//Variavel auxiliar para armazenar o valor do vetor atual
//Inverte os caracteres no vetor para ordená-los em ordem crescente
vetor[i] = vetor[j];// Atribui o valor do vetor na posição seguinte, no vetor
atual
vetor[j] = aux;// Atribui o valor do vetor na posição anterior, na posição se-
guinte do vetor
//printf("DEPOIS DO IF -- I = %d J = %d Indice = %d Vetor i = %d e vetor j = %d",i
, j,indice, vetor[i], vetor[j]);
//printf("\n");
//printf("DEPOIS DO IF -- I = %d J = %d Indice = %d Vetor i = %d e vetor j+1 =
%d",i , j,indice, vetor[i], vetor[j+1]);
//printf("\n");
}
}
}

cont = 1; //O minimo em que um caracter pode aparecer na lista e de 1

for (i = 1; i < indice; i++)
{
//Inicia com i=1 para comparar o segundo com o primeiro.
if (vetor[i] == vetor[i - 1])
cont++; //Se e igual ao anterior incrementa a variavel cont

else
{
//Se mudou o numero
if (cont > 1)
{
//Acabou de contar o número anterior, entao podemos exibir
//o numero de vezes que ele aparece
printf("O caracter %c aparece %d vezes! \n", vetor[i - 1], cont);
//Recomeça a contagem para o novo número:
cont = 1;
}
else
{
//Acabou de contar o numero anterior, entao podemos exibir o numero de vezes em
que ele aparece
printf("O caracter %c aparece %d vez!\n", vetor[i - 1], cont);
//Atribui o valor 1 a variavel "cont" para recomecar a contagem na proxima repeti-
cao
cont = 1;
}
}
}

if (cont > 1)
{
//Imprime o ultimo caracter
printf("O caracter %c aparece %d vezes!\n", vetor[i - 1], cont);
}
else
{
//Imprime o ultimo caracter
printf("O caracter %c aparece %d vez!\n", vetor[i - 1], cont);
}
}

//A funcao recebe 2 parametros de mesmo valor, sendo um armazenado como float
(para ser utilizado em calculo) e outro como char (para exibir como caracter, po-
dendo ser letra ou simbulo)
float primeiro_caracter(float caracter_entrada, char prim_letra)
{
//Confere para ver se a primeira letra e maiuscula, pela tabela ASCII a letra
A(maiusculo) = 65 e a letra Z(maiusculo) = 90
//Caso a condicao seja verdadeira o bloco dentro do if sera executado
if ((caracter_entrada >= 65) && (caracter_entrada <= 90))
{
printf("\nO primeiro caracter é o \"%c\" e é uma letra maiúscula!", prim_letra);
//Se o caractere for maiusculo, retorne na funcao o resultado deste caractere di-
vidido por 10
resultado = caracter_entrada / 10;
//printf("\nA funcao pedida para esse tipo de caracter resulta em: %.2f ", resul-
tado);
}
//Caso a condicao do "if" seja falsa, o else executara os comandos entre as chaves
else
{
printf("\nO primeiro caracter é o \"%c\" e é uma letra minúscula!", prim_letra);
//Caso contrario, retorne o resultado do caractere multiplicado por 2
resultado = caracter_entrada * 2;
//printf("\nA função pedida para esse tipo de caracter resulta em: %.2f ", resul-
tado);
}
printf("\n");

return resultado;
}

//Funcao para limpar buffer do teclado

void limpa_buffer()
{
while ((c = getchar()) != '\n' && c != EOF);
}
Imagem do código sendo executado: