LINGUAGEM DE PROGRAMAÇÃO - ATIVIDADE PRÁTICA - NOTA 100

Prévia do material em texto

CENTRO UNIVERSITÁRIO INTERNACIONAL UNINTER 
ESCOLA SUPERIOR POLITÉCNICA 
BACHARELADO EM ENGENHARIA ELÉTRICA 
DISCIPLINA DE LÓGICA DE PROGRAMAÇÃO 
 
 
 
 
 
 
 
ATIVIDADE PRÁTICA 
 
 
 
 
 
 
 
 ALUNO: THOMAS HAUSMANN STARY 
 RU: 2904687 
 PROFESSOR: WINSTON SEN LUN FUNG. 
 
 
 
 
 
 
 
 
 
 
 
DIADEMA – SÃO PAULO 
24/10/2020 
ii 
 
SUMÁRIO 
 
 
1 INTRODUCAO ........................................................................................................................................ 1 
2 DESENVOLVIMENTO ........................................................................................................................... 1 
2.1 – EXERCÍCIO 1 ........................................................................................................................................ 1 
2.2 – EXERCÍCIO 2 ........................................................................................................................................ 7 
2.3 – EXERCÍCIO 3 ........................................................................................................................................ 9 
2.4 – EXERCÍCIO 4 ...................................................................................................................................... 11 
2.5 – EXERCÍCIO 5 ...................................................................................................................................... 12 
3 CONCLUSÕES .................................................................................................................................... 166 
 
 
1 
 
1 INTRODUCAO 
É essencial para um engenheiro, considerando que na atualidade o mundo hoje está na 
era digital, que o mesmo conheça no mínimo o básico de linguagem de programação, isto con-
siderando qualquer área da engenharia, nos primórdios da programação era necessário conhe-
cimentos avançados da máquina pois a programação era em linguagem de máquina, com a 
evolução a programação ficou mais intuitiva e padronizada, sendo criado diversas linguagem, 
um das criadas foi o C/C++, está será a linguagem utilizada no trabalho proposto. 
Conforme o roteiro apresentado, é necessário a resolução de 5 exercícios de programa-
ção, no decorrer serão tratados cada um dos mesmos. 
 
2 DESENVOLVIMENTO 
Os exercícios que foram solicitados foram desenvolvidos e apresentados seus códigos e 
o programa rodando, o relatório foi dividido pelos exercícios propostos, estes exercícios estão 
citados no trabalho exatamente como estão descritos nas orientações para execução. 
2.1 – EXERCÍCIO 1 
Vamos supor que várias pedras do jogo de xadrez estão no tabuleiro. Para facilitar a 
indicação das peças, vamos convencionar: 1–peões 3–torres 5–reis 0–ausência de peças 2–ca-
valos 4–bispos 6–rainhas, o tabuleiro está apresentado na afigura 1 
 
 
Figura 1: Tabuleiro proposto exercício 1. Fonte: Relatório de orientações. 
2 
 
 
Construa um programa, em linguagem C, que: 
a) Solicite ao usuário que informe qual peça deseja colocar em cada posição do tabu-
leiro. 
b) Mostre o tabuleiro informado pelo usuário na tela. 
c) Determine a qual a quantidade de cada tipo de peça no tabuleiro. 
O código está apresentado na figura 2. 
 
#include <stdio.h> 
#include <stdlib.h> 
#include <stdbool.h> 
#include <iostream> 
#include <string.h> 
#include <math.h> 
 
using namespace std; 
 
int main() 
{ 
 char operacao; 
 char c_grade[8][8]; // Matriz bidirecional para armazenamento de da-
dos de entrada 
 char c_grade_aux[10][10]; // Matriz bidirecional para Cópia de da-
dos de entrada para função de contagem 
 char c_contar[100] = {NULL};// Matriz unidirecional com Caracter Contados 
 int i_contar[100] = {NULL}; // Matriz unidirecional com Contador de res-
pectivo Caracter 
 int i_n=8; // Variável inteira para entrada de nú-
mero de linhas desejados 
 int i_m=8; 
 int l=0; // Variável inteira para entrada de nú-
mero de colunas desejados 
 int c=0; 
 
 printf("Grade com as coordenadas \n"); 
 for (int l = 0; l < i_n; l++) 
 { 
 for (int c = 0; c < i_m; c++) 
 { 
 printf("| %d %d |",l,c); 
 } 
 printf("|\n"); 
 } 
 printf( "\n1 = peoes"); 
 printf( "\n2 = cavalos"); 
3 
 
 printf( "\n3 = torres"); 
 printf( "\n4 = bispos"); 
 printf( "\n5 = reis"); 
 printf( "\n6 = rainhas"); 
 printf( "\n0 = ausencia de pecas\n"); 
 
for (int l = 0; l < i_n; l++) 
{ 
 for (int c = 0; c < i_m; c++) 
 { 
 printf("| %d %d |= ",l,c); 
 do 
 { 
 operacao = getchar(); 
 } while(operacao!='1' && operacao!='2' && operacao!='3' && opera-
cao!='4'&& operacao!='5'&& operacao!='6'&& operacao!='0'); 
 
 
 switch(operacao) 
 { 
 case '1': 
 c_grade[l][c]='1'; 
 break; 
 
 case '2': 
 c_grade[l][c]='2'; 
 break; 
 
 case '3': 
 c_grade[l][c]='3'; 
 break; 
 
 case '4': 
 c_grade[l][c]='4'; 
 break; 
 
 case '5': 
 c_grade[l][c]='5'; 
 break; 
 
 case '6': 
 c_grade[l][c]='6'; 
 break; 
 
 case '0': 
 c_grade[l][c]='0'; 
 break; 
 } 
 } 
4 
 
} 
 
printf("Grade com os VALORES \n"); 
printf("\n"); 
for (int l = 0; l < i_n; l++) 
{ 
 for (int c = 0; c < i_m; c++) 
 { 
 printf("| %c | ",c_grade[l][c]); 
 c_grade_aux[l][c]=c_grade[l][c]; 
 c_contar[(l*i_m)+c]=c_grade[l][c]; 
 } 
 printf("\n"); 
} 
 for (int l = 0; l < i_n; l++) 
{ 
 for (int c = 0; c < i_m; c++) 
 { 
 for (int l1 = 0; l1 < i_n; l1++) 
 { 
 for (int c1 = 0; c1 < i_m; c1++) 
 { 
 if (c_grade_aux[l1][c1]==c_contar[(l*i_m)+c]) 
 {i_contar[(l*i_m)+c]++; 
 c_grade_aux[l1][c1]=NULL; 
 } 
 } 
 } 
 } 
} 
printf("\n"); 
printf("Grade com CONTAGEM dos Valores \n"); 
for (int i = 0; i < (i_n*i_m); i++) 
{ 
if (i_contar[i]!=0){ 
 printf("\n"); 
 switch(c_contar[i]) 
 { 
 case '1': 
 printf( "peoes "); 
 break; 
 
 case '2': 
 printf( "cavalos "); 
 
 break; 
 
 case '3': 
 printf( "torres "); 
5 
 
 
 break; 
 
 case '4': 
 printf( "bispos "); 
 
 break; 
 
 case '5': 
 printf( "reis "); 
 
 break; 
 
 case '6': 
 printf( "rainhas "); 
 
 break; 
 
 case '0': 
 printf( "ausencia de pecas "); 
 break; 
 } 
 printf("| %c | %d ",c_contar[i],i_contar[i]); 
} 
} 
printf("\n"); 
} 
Figura 2: Código proposto exercício 1. 
 
A figura 3 apresenta o programa rodando, no mesmo foram executados os comandos 
propostos para o exercício, onde está apresentado a grade de coordenadas e a inserção dos va-
lores em cada coordenada, foi mostrado as 16 primeiras peças que correspondem as peças de 
xadrez de um dos concorrentes, na figura 4 é mostrado o resultado da inserção dos dados, com 
a posição das peças e a contagem de cada peça. 
6 
 
 
Figura 3: Programa do exercício 1 rodando parte 1. 
 
7 
 
 
Figura 4: Programa do exercício 1 rodando parte 2. 
 
2.2 – EXERCÍCIO 2 
Escreva um programa, em LINGUAGEM C, que: 
a) Solicite ao usuário a entrada de um registro que armazene na memória o Nome 
do funcionário e o seu salário. 
b) Utilizando o salário informado calcule o imposto de renda devido e mostre na 
tela, conforme a tabela apresentada na figura5. 
 
 
Figura 5: Tabela do imposto de renda. Fonte: Relatório de orientações. 
8 
 
 
A figura 6 apresenta o código desenvolvido. 
 
#include <stdio.h> 
#include <conio.h> 
 struct reg_cadastro { 
 char c_nome[50]; 
 float salario; 
 }; 
 
float teste_imposto(float valor){ 
 float aux = 0; 
 if((valor >= 0) && (valor <= 1637.11)) {aux = 0;} 
 if((valor >= 1637.12) && (valor <= 2453.50)) {aux = valor*0.075;} 
 if((valor >= 2453.51) && (valor <= 3271.38)) {aux = valor*0.15;} 
 if((valor >= 3271.39) && (valor <= 4087.65)) {aux = valor*0.225;} 
 if(valor >= 4087.65) {aux = valor*0.275;} 
 return aux; 
} 
 
int main(void) 
{ 
 
 struct reg_cadastro rg_valor; 
 printf("Dados de entrada \n\n"); 
 printf("Inserir seu NOME "); 
 scanf("%s", &rg_valor.c_nome); 
 printf("Inserir seu SALARIO "); 
 scanf("%f",&rg_valor.salario); 
 printf("\n"); 
 printf ("Conteudo da variavel Valor NOME : %s \n", rg_valor.c_nome); 
 printf ("Conteudo da variavel valor SALARIO: %.2f \n", rg_valor.salario); 
 printf ("Conteudo da variavel valor IMPOSTO: %.2f \n", teste_im-
posto(rg_valor.salario)); 
 
} 
Figura 6: Código desenvolvido no exercício 2. 
 
A figura 7 está apresentado o programa em execução no terminal 
 
9 
 
 
Figura 7: Programa do exercício 2 rodando. 
 
2.3 – EXERCÍCIO 3 
Faça um programa, em linguagem C, que lê 5 frases, informadas pelo o usuário, de, 
no máximo, 50 caracteres cada uma e armazene-as em um arquivo. Mas, antes de gravar cada 
frase no arquivo, é necessário converter todas as suas letras para maiúsculas. O nome do arquivo 
será fornecido, via teclado, pelo usuário. A seguir, feche o arquivo. Reabra o arquivo, para 
leitura, exibindo na tela todas as frases convertidas. 
A figura 8 apresenta o código desenvolvido para resolução do exercício 3 proposto e na 
figura 9 o programa está sendo executado no terminal. 
 
#include <stdio.h> 
#include <stdlib.h> 
#include <stdbool.h> 
#include <iostream> 
#include <string.h> 
#include <math.h> 
#include <strings.h> 
#include <ctype.h> 
#include <fstream> 
 struct reg_cadastro { 
 char c_nome[50]; 
 }; 
int main(void) 
{ 
 
 struct reg_cadastro rg_valor[5]; 
 int l=0; 
 char aux_nome[50]; 
 FILE *fp; 
 printf("Dados de entrada \n\n"); 
 
10 
 
 printf("Grade com as coordenadas \n"); 
 for (int l = 0; l < 5; l++) 
 { 
 printf("Digite a frase linha %d",l); 
 gets(rg_valor[l].c_nome); 
 } 
 fp = fopen ("TEST.txt","w"); 
 for (int l = 0; l < 5; l++) 
 { 
 for (int c = 0; c < (strlen(rg_valor[l].c_nome)); c++) 
 { 
 rg_valor[l].c_nome[c]= toupper(rg_valor[l].c_nome[c]); 
 fputc ( rg_valor[l].c_nome[c], fp ); 
 } 
 fputc ( '\n', fp ); 
 } 
 fclose (fp); 
 
 fp = fopen ("TEST.txt","r"); 
 for (int l = 0; l < 5; l++) 
 { 
 if (fp == NULL) { 
 printf("Erro"); 
 } else { 
 if ( fgets (aux_nome, 50 , fp) != NULL ) 
 printf(" %d - ",(strlen(aux_nome)-1)); 
 puts (aux_nome); 
 } 
 } 
 fclose (fp); 
} 
 
Figura 8: Código desenvolvido para o exercício 3. 
 
11 
 
 
Figura 9: Programa do exercício 3 rodando. 
 
2.4 – EXERCÍCIO 4 
Faça um programa, em linguagem C, para calcular a área e o perímetro de um hexágono. 
O programa deve implementar uma função chamada calc_hexa que calcula a área e o perímetro 
de um hexágono regular de lado L. O programa deve solicitar ao usuário o lado do polígono, 
calcular e imprimir a área e o perímetro do polígono. O programa termina quando for digitado 
um valor negativo qualquer para o lado. A função deve obedecer ao seguinte protótipo. 
 
 
A figura 10 apresenta o código desenvolvido para resolução do exercício 4 e na figura 
11 o programa sendo executado está apresentado, neste teste foram inseridos vários valores para 
certificar o funcionamento. 
 
#include <stdio.h> 
#include <stdlib.h> 
#include <stdbool.h> 
#include <iostream> 
#include <string.h> 
#include <math.h> 
 
12 
 
float lado=1; 
float f_area; 
float F_perimetro; 
 void calc_hexa(float L, float *area, float *perimetro) { 
 float aux_sqrt; 
 float aux_pow; 
 
 aux_sqrt = sqrt(3); 
 aux_pow = pow(L,2); 
 *area = (3*(aux_pow*aux_sqrt))/2; 
 *perimetro = L*6; 
 } 
 
int main(void) 
{ 
 do{ 
 printf("Digite o VALOR para o lado do HEXAGONO "); 
 scanf("%f",&lado); 
 if (lado>0){ 
 calc_hexa(lado, &f_area, &F_perimetro); 
 printf("Area = %.6f, Perimetro = %.2f\n", f_area, F_perimetro); 
 } else { 
 printf("SAIU"); 
 } 
 } while(lado>0); 
} 
Figura 10: Código desenvolvido para o exercício 4. 
 
 
Figura 11: Programa do exercício 4 rodando. 
 
2.5 – EXERCÍCIO 5 
Faça um programa, em linguagem C, que: 
a) Crie uma struct chamada ponto2d que tenha como atributos os pontos x,y. 
b) Crie duas estruturas do tipo ponto2d chamadas ponto_inicial e ponto_final. 
13 
 
c) Mostre um menu com as seguintes opções e implemente‐ as: 
 
[1] ‐ Digitar os valores do primeiro ponto 
[2] - Digitar os valores do segundo ponto 
[3] ‐ Mostrar a distância entre os pontos 
[4] ‐ Sair 
 
A figura 12 apresenta o código desenvolvido para resolução do exercício 5 e na 
figura 13 é apresentado o programa sendo executado. 
 
#include <stdio.h> 
#include <stdlib.h> 
#include <stdbool.h> 
#include <iostream> 
#include <string.h> 
#include <math.h> 
struct ponto2d { 
 int y; 
 int x; 
 }; 
 
float calc_d(int ini_x, int ini_y,int fin_x, int fin_y) { 
 float aux_distancia; 
 float aux_x; 
 float aux_y; 
 aux_x = pow((ini_x - fin_x),2); 
 aux_y = pow((ini_y - fin_y),2); 
 aux_distancia = sqrt(aux_x+aux_y); 
 return aux_distancia; 
} 
 
int main(void) 
{ 
 struct ponto2d ponto_inicial; 
 struct ponto2d ponto_final; 
 char operacao; 
do 
 { 
 printf( "\n| 1 | = Digitar os valores do PONTO INICIAL"); 
 printf( "\n| 2 | = Digitar os valores do PONTO INICIAL"); 
 printf( "\n| 3 | = Distancia entre os dois pontos"); 
 printf( "\n| 4 | = SAIR\n"); 
 do 
 { 
14 
 
 operacao = getchar(); 
 } while(operacao!='1' && operacao!='2' && operacao!='3' && operacao!='4'); 
 
 
 switch(operacao) 
 { 
 case '1': 
 printf("PONTO INICIAL Inserir valor de X "); 
 scanf("%d",&ponto_inicial.x); 
 printf("\n"); 
 printf("PONTO INICIAL Inserir valor de Y "); 
 scanf("%d",&ponto_inicial.y); 
 printf("\n"); 
 break; 
 
 case '2': 
 printf("PONTO FINAL Inserir valor de X "); 
 scanf("%d",&ponto_final.x); 
 printf("\n"); 
 printf("PONTO FINAL Inserir valor de Y "); 
 scanf("%d",&ponto_final.y); 
 printf("\n"); 
 break; 
 case '3': 
 printf("Distancia entre os 2 PONTOS %.2f ", calc_d(ponto_ini-
cial.x,ponto_inicial.y,ponto_final.x,ponto_final.y)); 
 break; 
 
 case '4': 
 break; 
 } 
} while(operacao!='4'); 
} 
Figura 12: Código desenvolvido para o exercício 5. 
 
15 
 
 
Figura 13: Programa do exercício 5 rodando. 
 
 
 
 
 
 
 
 
 
16 
 
3 CONCLUSÕES 
Através do desenvolvimento do trabalho, resolvendo estes exercícios, foi possível concluir 
a amplitude de possibilidades de utilização da programação, desde um jogo como o de xadrez, 
passando por um cálculo de imposto de renda até um cálculo geométrico, entre outras coisas, 
algumas coisas que podem ser utilizados na engenharia, outras nem tanto, mas conclui-se que 
na vida do engenheiro á necessário o conhecimento mínimo nesta ferramenta de trabalho que é 
a programação.