ATIVIDADE PRATICA - LOGICA DE PROGRAMACAO E ALGORITMOS 2020_FINAL

Prévia do material em texto

CENTRO UNIVERSITÁRIO INTERNACIONAL UNINTER 
ESCOLA SUPERIOR POLITÉCNICA 
BACHARELADO EM ENGENHARIA DE PRODUÇÃO 
DISCIPLINA DE LÓGICA DE PROGRAMAÇÃO E ALGORITMOS 
 
 
 
 
 
 
 
ATIVIDADE PRÁTICA 
 
 
 
 
 
 
 
 
ADERSON C TAVARES – RU: 2815071 
PROF.VINICIUS POZZOBON BORIN, ME. 
 
 
 
 
 
 
 
 
 
 
 
 
GOIANÉSIA – GOIÁS 
2020 
Exercício 1: 
 
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: 
ITEM PRODUTO CODIGO PREÇO 
UNITÁRIO 
1 Cachorro-quente 100 5,00 
2 X-salada 101 8,79 
3 X-bacon 102 9,99 
4 Misto 103 6,89 
5 Salada 104 4,80 
6 Água 105 3,49 
7 Refrigerante 106 4,99 
 
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 encerrar o processo de compra, o usuário deve digitar um valor diferente de 1-7. 
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 (2815071) 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, a compra resultante será: 
 
ITEM PRODUTO Quantidade 
1 Cachorro-quente 1 
2 X-salada 0 
8 Inexistente #### 
 
 
 
 
 
 
 
#include<stdio.h>// INCLUSÃO DE BIBLIOTECAS DE ENTRADA E SAÍDA 
#include<stdlib.h> // INCLUSÃO DE BIBLIOTECAS LIB 
#include<conio.h>// INCLUSÃO DE BIBLIOTECAS CONIO 
#include<locale.h>// INCLUSÃO DE BIBLIOTECAS LOCALE 
 
 
void menu(); 
 
int main() { // DECLARAÇÃO DO TIPO E INÍCIO DA FUNÇÃO PRINCIPAL 
 
 
 int pedido = 0; 
 int quant = 0; 
 float valor = 0; // DECIMAIS 
 setlocale(LC_ALL, "Portuguese");// BIBLIOTECA PARA ACENTUAÇÃO EM PORTUGUÊS 
 
 menu(); 
 
 do 
 { 
 printf("Ola, Faça seu pedido: \n"); // MENSAGEM QUE APARECERÁ PARA 
O USUARIO 
 scanf_s("%i", &pedido);// O PROGRAMA GUARDARÁ AS INFORMAÇÕES 
DIGITADAS NA VARIÁVEL 
 printf(“Um momento, cadastrando seu pedido no nosso sistema....”); 
 printf("\n"); 
 
 switch (pedido) {// PEDIDO DO USUÁRIO 
 
 
 case 1:// CADASTRO 
 printf(" Quantidade do pedido %d: \n ", pedido);// TELA DO 
USUÁRIO 
 scanf_s("%d", &quant);// O PROGRAMA VAI CAPTURAR O QUE O 
USUÁRIO DIGITOU 
 valor = valor + (quant * 5.00); 
 break;// VALOR ATRIBUÍDO AO QUALITATIVO E QUANTITATIVO DO 
PEDIDO DO USUÁRIO 
 
 
 case 2:// CADASTRO 
 printf(" Quantidade do pedido %d: \n ", pedido); // APARECERÁ 
PARA O USUÁRIO DIGITAR A QUANTIDADE DO PRODUTO REQUERIDO 
 scanf_s("%d", &quant);// LEITURA DO QUE O USUÁRIO DIGITOU 
 valor = valor + (quant * 8.79); 
 break;// VALOR DOS PEDIDOS 
 
 
 case 3:// CADASTRO 
 printf(" Quantidade do pedido %d: \n ", pedido); // APARECERÁ 
PARA O USUÁRIO DIGITAR A QUANTIDADE DO PRODUTO REQUERIDO 
 scanf_s("%d", &quant);// LEITURA DO QUE O USUÁRIO DIGITOU 
 valor = valor + (quant * 9.99);// VALOR DOS PEDIDOS 
 break; 
 
 
case 4: // CADASTRO 
 printf(" Quantidade do pedido %d: \n ", pedido); // APARECERÁ 
PARA O USUÁRIO DIGITAR A QUANTIDADE DO PRODUTO REQUERIDO 
 scanf_s("%d", &quant);// LEITURA DO QUE O USUÁRIO DIGITOU 
 valor = valor + (quant * 6.89);// VALOR DOS PEDIDOS 
 break; 
 
 case 5: // CADASTRO 
 printf(" Quantidade do pedido %d: \n ", pedido);// TELA DE 
DIGITAÇÃO DO USUÁRIO 
 scanf_s("%d", &quant); // LEITURA DOS VALORES DIGITADOS PELO 
USUÁRIO 
 valor = valor + (quant * 4.80);// VALOR DOS PEDIDOS 
 break; 
 
 
 case 6: // CADASTRO 
 printf(" Quantidade do pedido %d: \n ", pedido);// TELA DE 
DIGITAÇÃO DO USUÁRIO 
 scanf_s("%d", &quant);// LEITURA DOS VALORES DIGITADOS PELO 
USUÁRIO 
 valor = valor + (quant * 3.49); // VALOR DOS PEDIDOS 
 break; 
 
 
 
 case 7: // CADASTRO 
 printf(" Quantidade do pedido %d: \n ", pedido);// TELA DE 
DIGITAÇÃO DO USUÁRIO 
 scanf_s("%d", &quant); // LEITURA DOS VALORES DIGITADOS PELO 
USUÁRIO 
 valor = valor + (quant * 4.99); // VALOR DOS PEDIDOS 
 break; 
 
 
 
 
 default: 
 printf("\n****GERANDO O TOTAL****\n");// GERAÇÃO DE NOTA 
FISCAL 
 printf("*** NOTA FISCAL *****\n"); 
 printf(" Total a se pagar = % .2f", valor); // VALOR TOTAL 
DOS PEDIDOS IMPRESSOS NA NOTA 
 break; 
 
 
 
 
 } 
 
 
 
 } while (pedido != 0); 
 
 
 
 
 
 return 0;// RETORNO PARA A FUNÇÃO PRINCIPAL, INDICANDO QUE AO FINAL DA 
EXECUÇÃO TUDO OCORREU PERFEITAMENTE 
 
 
} 
 
void menu() { // MENU DE OPÇÕES DO CARDÁPIO 
 
 
 
printf("\n"); 
 printf("*******************LISTA DE PEDIDOS**********************\n\n\n"); 
 printf("* Item Produto Codigo Preco Unitario *\n\n\n"); 
 printf("* 1 Cachorro-quente 100 5,00 *\n"); 
 printf("* 2 X-salada 101 8,79 *\n"); 
 printf("* 3 X-baicon 102 9,99 *\n"); 
 printf("* 4 Misto 103 6,89 *\n"); 
 printf("* 5 Salada 104 4,80 *\n"); 
 printf("* 6 Agua 105 3,49 *\n"); 
 printf("* 7 Refrigerante 106 4,99 *\n"); 
 printf("**************************************************************\n")
;// FOMENTAÇÃO DE VISUAL DA TABELA 
 printf("\n"); 
 printf(“Lembre-se, para finalizar o pedido é só digitar no item o numero 0 
ou maior do que 7!\n”);// LEMBRETE PARA O USUÁRIO 
 printf("\n"); 
 
 
} 
 
 
 
 
 
 
 
 
Exercício 2: 
 
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 reservatório por mês foi gasto. Armazene as informações de cada mês 
em vetores de dados. 
Sabendo 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 vazio em algum momento, informe isso na tela. Caso o reservatório 
fique cheio em algum momento, 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 (2815071) será um dos valores gastos, em 
milímetros, por mês. 
 
#include<stdio.h> //Inclusão de bibliotecas de entrada e saida 
#include<stdlib.h> 
#include<locale.h> 
 
#define TAMANHOVETOR 12 //definiçãção de tamanho do vetor 
 
int main() { //Declaração de inicio e tipo de função principal 
 
 
 float somaChuv[12], somaAgua[12], restante[12], ttl[12]; //Variavel deve 
do tipo float, pois os numeros podem ser decimais 
 int reservatorio, c; 
 setlocale(LC_ALL, "Portuguese");//Biblioteca de acentuação em portugues 
 
 
 printf("***CADASTRO DO RESERVATORIO****\n"); 
 printf("Reservatorio em milimetro - informe o valor : \n"); //Usuario 
digita o valor maximo de capacidade do reservatorio em milimetros 
 scanf_s("%i", &reservatorio); /É feita a leitura da quantidade digitada 
pelo usuario 
 
 
 printf("****CADASTRO DE CHUVA E GASTO DE AGUA*****\n"); 
 
 for (c = 1; c <= TAMANHOVETOR; c++) 
 { 
 printf("Valor de chuva no mes %d ?\n", c); //Usuario digita a 
quantidade de chuva em cada mes do ano 
 scanf_s("%f", &somaChuv[c]); //É feita a leitura da quantidade 
digitada pelo usuario 
 
 printf("***********\n"); 
 
 printf(" Gasto de agua no mes %d ?\n", c); //Usuario digita a 
quantidade de agua gasta em cada mes do ano 
 scanf_s("%f", &somaAgua[c]); //É feita a leitura da quantidade 
digitada pelo usuario 
 
 restante[c] = somaChuv[c] - somaAgua[c]; //É feita as operações 
aritmeticas pertinentes aos valores digitados pelo usuariottl[c] = restante[c] + reservatorio; //É feita as operações 
aritmeticas pertinentes aos valores digitados pelo usuario 
 
 printf("\n"); 
 
 if (ttl[c] <= 0) 
 { 
 printf(" RESERVATORIO VAZIO E COM CAPACIDADE MAXIMA !!!! 
\n"); //Mensagem para usuario 
 
 
 
 } 
 
 if (ttl[c] > reservatorio) 
 { 
 printf(" RESERVATÓRIO CHEIO - CONTROLE SEU RESERVATORIO !!!! 
\n"); //Mensagem para usuario 
 
 
 } 
 
 printf(" NIVEL TOTAL EM: %.2f mm\n", ttl[c]); //Mensagem para 
usuario 
 
 } 
 return 0; 
 
} 
 
 
 
 
 
 
 
 
 
 
 
 
Exercício 3: 
 
Faça um algoritmo em linguagem C que receba como dado de entrada uma matriz de 
caracteres. 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 
matriz. A função deve retornar um dado numérico. Se o caractere for maiúsculo, retorne 
na função o resultado deste caractere dividido por 10. Caso contrário, retorne 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 
 
 
#include <stdio.h> //Bibliotecas de entrada e saida 
#include <stdlib.h>//Inclusão de biblioteca lib 
#include<locale.h>//Inclusão de biblioteca locale 
#include <ctype.h>//Inclusão de biblioteca type 
 
 
char caracteres[10][10] = { 0 }; 
int primeiroCaracter(char);//função do tipo inteiro para primeiro caractere 
 
int main()//inicialização do programa 
{ 
 int lin, col; 
 printf("\n****************************************************************
************\n");//estética 
 void criaMatriz(int, int);//função sem retorno, criar matriz 
 void leMatriz(int, int);//função sem retorno, lê matriz 
 void contaOcorrencia(int, int);//função sem retorno, contar ocorrências de 
caracteres que aparece na matriz 
 setlocale(LC_ALL, "Portuguese");//Biblioteca de acentuação em portugues 
 //laço principal do programa 
 do 
 { 
 printf("\n Digite o numero de linhas maior que 0 e menor ou igual a 
10:\n"); //mensagem para o usuario digitar o numero desejado de linhas 
 scanf_s("%d", &lin); //imprime na tela o numero de linhas digitadas 
pelo usuario 
 printf(" Digite o numero de colunas maior que 0 e menor ou igual a 
10:\n");//mensagem para o usuario digitar o numero desejado de colunas 
 scanf_s("%d", &col);//imprime na tela o numero de colunas digitadas 
pelo usuario 
 fflush(stdin); 
 } while (11 > lin < 1 || 11 > col < 1); 
 printf("\n****************************************************************
************\n");//estética 
 printf("\n Sua matriz possui %i linhas \n", lin);//mensagem para o usuario 
sobre a quantidade de linhas que a matriz possui 
 printf(" Sua matriz possui %i colunas \n", col);//mensagem para o usuario 
sobre a quantidade de colunas que a matriz possui 
 criaMatriz(lin, col); //matriz do tipo linha coluna 
 leMatriz(lin, col);//leitura de matriz do tipo linha coluna 
 contaOcorrencia(lin, col); //contar ocorrencias do tipo matriz 
linha/coluna 
 printf("%i \n",primeiroCaracter(caracteres[0][0])); //imprime na tela 
oprimeiro caractere relacionado a primeira letra do nome do usuario 
 system("pause"); 
} 
 
//Função determinante para tamanho de matriz e seus respectivos caracteres 
void criaMatriz(int lin, int col) 
{ 
 printf("\n******************************\n"); 
 printf("\n Digite os caracteres: \n"); 
 for (int x = 0; x < lin; x++) 
 { 
 for (int y = 0; y < col; y++) 
 { 
 scanf_s(" %c", &caracteres[x][y]); 
 fflush(stdin); 
 } 
 } 
} 
//função de leitura de matriz 
void leMatriz(int lin, int col) 
{ 
 int aux, cont; 
 printf("\n******************************\n"); 
 printf("\n Sua matriz: \n"); 
 for (int x = 0; x < lin; x++) 
 { 
 for (int y = 0; y < col; y++) 
 { 
 printf(" caractere[%i][%i]: %c \n", x, y, caracteres[x][y]); 
 } 
 } 
} 
//função contadora de ocorrências de caracteres dentro matriz 
void contaOcorrencia(int lin, int col) 
{ 
 printf("\n*******************************\n"); 
 int i, j, k, found, ct = -1; 
 int vet[2][12] = { {0} }; 
 for (i = 0; i < lin; i++) 
 for (j = 0; j < col; j++) 
 { 
 if (j == lin) printf("\n"); 
 found = false; 
 for (k = 0; k <= ct; k++) 
 { 
 if (vet[0][k] == caracteres[i][j]) 
 { 
 vet[1][k]++; 
 found = true; 
 } 
 } 
 if (!(found)) 
 { 
 vet[0][++ct] = caracteres[i][j]; 
 vet[1][ct]++; 
 } 
 } 
 for (i = 0; i <= ct; i++) 
 { 
 printf("\nCaractere: %c -- ocorrencia(s): %d\n", vet[0][i], 
vet[1][i]); 
 } 
} 
//função de primeiro caractere 
int primeiroCaracter(char primeiro) 
{ 
 int resultado = (int)primeiro; 
 printf("\n**********************************\n"); 
 printf("\n Caracter: %c", primeiro); 
 printf("\n Codigo: %i", primeiro); 
 printf("\n Resultado da operacao: "); 
 if (isupper(primeiro)) 
 { 
 return (resultado / 10);//função que retorna um caracter com a 
primeira letra maiuscula de nome do usuario dividido por 10, conforme Tabela 
ASCII 
 } 
 else 
 { 
 return (resultado * 2);//função que retorna um caracter com a 
primeira letra minúscula de nome do usuario multiplicado por 2, conforme Tabela 
ASCII 
 } 
} 
 
 
 
 
 
 
 
 
 
 
 
REFERÊNCIAS BIBLIOGRÁFICAS 
 
MIZRAHI, Victorine Viviane. Treinamento em Linguagem C 2ª edição. São Paulo, 
2008. 
 
LEAL, Gislaine Camila Lapasini. Linguagem programação e banco de dados. 
Curitiba 2015. 
 
PUGA, Sandra et al.. Lógica de programação e estrutura de dados. São Paulo, 2017.