ATIVIDADE PRÁTICA - Lógica de programação e algoritimos

Prévia do material em texto

CENTRO UNIVERSITÁRIO INTERNACIONAL UNINTER 
ESCOLA SUPERIOR POLITÉCNICA 
GRAD - CST GESTÃO DA TECNOLOGIA DA INFORMAÇÃO 
DISCIPLINA DE LÓGICA DE PROGRAMAÇÃO E ALGORITMOS 
 
 
 
 
 
 
 
ATIVIDADE PRÁTICA 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2019
 
 
1 
 
Exercício 1 : 
 
Uma Certa empresa fez uma pesquisa de mercado para saber se as pessoas gostaram ou não do seu último produto lançado. Pa-
ra isto, coletou o sexo do entrevistado e a sua resposta (sim ou não). Sabendo que foram entrevistadas 150 pessoas, fazer um 
algoritmo que calcule e mostre ao final: 
 
• O número de pessoas que responderam sim; 
• O número de pessoas que responderam não; 
• A percentagem de pessoas do sexo feminino que responderam sim; 
• A percentagem de pessoas do sexo masculino que responderam não; 
 
Para a resposta SIM/NÃO. Utilize uma variável do tipo CHAR, que armazena S ou N, ou use uma variável do tipo INT que ar-
mazena 1 (para SIM) e 2 (para NÃO). 
Solução do aluno: 
 
#include <stdio.h>//BIBLIOTECA PADRAO DE ENTRADA E SAIDA 
#include <stdlib.h>//BIBLIOTECA PARA FAZER A PARADA NO FINAL DO CODIGO 
 
#define TOTAL 150 //DEFINE O NUMERO TOTAL DE PESSOAS 
int main() { 
 
 int contS = 0, contN = 0, contNmasc = 0, contSfem = 0;//VARIAVEIS DO TIPO INTEIRO 
 int sexo, resposta;//VARIAVEIS DO TIPO INTEIRO 
 
 for (int i = 1; i <= TOTAL; i++)//DEFINE UMA VARIAVEL DE CONTROLE 
 { 
 printf_s("Gostou do produto? (1 para Sim e 2 para Nao): ");//COLETA A RESPOSTA SE GOSTOU OU NAO DO PRODUTO 
 scanf_s("%d", &resposta);//ARMAZENA A RESPOSTA DO ENTREVISTADO 
 printf_s("Qual seu sexo? (1 para Masculino e 2 para Feminino): ");//COLETA O SEXO DO ENTREVISTADO 
 scanf_s("%d", &sexo);//ARMAZENA O SEXO DO ENTREVISTADO 
 if (resposta == 1) 
 {//RESPOSTA SIM 
 contS++; 
 if (sexo == 2) 
 
 
 
 
 {//RESPOSTA SIM E FEMININO 
 contSfem++; 
 } 
 } 
 else 
 {// RESPOSTA NAO 
 contN++; 
 if (sexo == 1) 
 {//RESPOSTA NAO E MASCULINO 
 contNmasc++; 
 } 
 } 
 } 
 
 printf_s("\n");//PULAR UMA LINHA 
 
 printf_s("Total de pessoas que responderam sim: %d\n", contS);//SOMA DO TOTAL DE PESSOAS QUE RESPONDERAM SIM 
 printf_s("Total de pessoas que responderam nao: %d\n", contN);//SOMA DO TOTAL DE PESSOAS QUE RESPONDERAM NAO 
 printf_s("A porcentagem de pessoas do sexo feminino que responderam sim: %d%%\n", (contSfem * 100) / 150);//PORCENTAGEM DO TO-
TAL DE PESSOAS DO SEXO FEMININO QUE RESPONDERAM SIM 
 printf_s("A porcentagem de pessoas do sexo masculino que responderam nao: %d%%\n\n", (contNmasc * 100) / 150);//PORCENTAGEM DO 
TOTAL DE PESSOAS DO SEXO MASCULINO QUE RESPONDERAM NAO 
 
 
 system("pause"); 
 return 0; 
} 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Imagem do código funcionando no computador: 
 
 
 
 
 
 
 
Exercício 2: 
Para cada um dos consumidores de energia elétrica de uma cidade é informado o número da conta e o total de KW consumido no 
mês. Sabendo-se que o custo do KW é de R$ 1,75, fazer um algoritmo para: 
 Armazenar e listar o número da conta, o total de KW consumidos e o valor a pagar de cada consumir cadastrado; 
 Listar o número da conta, o total de KW consumidos e o valor a pagar do consumidor que mais gastou e o que menos gastou; 
 Mostrar a média de consumo da cidade; 
 Mostrar o número de consumidores que ultrapassaram o consumo de 170 KW; 
 
Armazene as informações em estruturas de vetores e/ou matrizes. Na tela, deve existir um MENU que pergunta ao usuário se ele 
deseja cadastrar um novo consumidor ou listar alguma informação (maior, menor, média, etc.). 
 
Solução do aluno: 
 
#include <stdio.h>//BIBLIOTECA PADRAO DE ENTRADA E SAIDA 
#include <stdlib.h>//BIBLIOTECA PARA FAZER A PARADA NO FINAL DO CÓDIGO 
 
#define numerodedigitos 5 //VALOR MAXIMO DO VETOR 
#define precoKW 1.75 //PREÇO POR CADA KW CONSUMIDO 
 
float conta[numerodedigitos][2]; 
int total = 0; 
void menu() {//PROCESSO PARA EXIBIÇÃO DO MENU 
 system("cls");//COMANDO PARA LIMPAR A TELA 
 printf_s("*****************EXIBINDO MENU***************** \n"); 
 printf_s("* 1 - Cadastrar conta e KW consumido * \n"); 
 printf_s("* 2 - Exibir o maior consumo * \n"); 
 printf_s("* 3 - Exibir o menor consumo * \n"); 
 printf_s("* 4 - Consumo acima 170 KW * \n"); 
 printf_s("* 5 - Consumo medio da cidade * \n"); 
 printf_s("* 6 - Sair * \n"); 
 printf_s("*********************************************** \n"); 
 printf_s("\nDigite a opcao: "); 
} 
void coletadedados() {//PROCESSO PARA COLETA DE DADOS DO USUARIO CONTA E KW CONSUMIDO 
 
 
 
 
 system("cls");//COMANDO PARA LIMPAR A TELA 
 printf_s("\nConta: "); 
 scanf_s("%f", &conta[total][0]); 
 printf_s("\nConsumo KW: "); 
 scanf_s("%f", &conta[total][1]); 
 total++; 
 printf_s("\nCadastro feito!\n"); 
 system("pause"); 
} 
void exibirconsumomaior() {//PROCESSO PARA EXIBIR O MAIOR CONSUMO 
 system("cls");//COMANDO PARA LIMPAR A TELA 
 float KW = 0, valor = 0, registrouser = 0; 
 int i; 
 for (i = 0; i < total; i++) { 
 if (conta[i][1] > KW) { 
 registrouser = conta[i][0]; 
 KW = conta[i][1]; 
 } 
 } 
 valor = (float)(KW * precoKW); 
 printf_s("\nMaior consumo: "); 
 printf_s("\nConta de numero: %0.2f", registrouser); 
 printf_s("\nKW consumido: %0.2f", KW); 
 printf_s("\nValor total da conta para pagar: %0.2f\n", valor); 
 system("pause"); 
} 
void exibirconsumomenor() { //PROCESSO PARA EXIBIR O MENOR CONSUMO 
 system("cls");//COMANDO PARA LIMPAR A TELA 
 float KW = 123456789, valor = 0, registrouser = 0; 
 int i; 
 for (i = 0; i < total; i++) { 
 if (conta[i][1] < KW) { 
 registrouser = conta[i][0]; 
 KW = conta[i][1]; 
 } 
 } 
 valor = (float)(KW * precoKW); 
 printf_s("\nMenor consumo: "); 
 printf_s("\nConta de numero: %0.2f", registrouser); 
 printf_s("\nKW consumido: %0.2f", KW); 
 
 
 
 
 printf_s("\nValor total da conta para pagar: %0.2f\n", valor); 
 system("pause"); 
} 
void exibirconsumoacima(float n) {//PROCESSO PARA EXIBIR OS CONSUMIDORES ACIMA DO KW PEDIDO NO EXERCICIO 
 system("cls");//COMANDO PARA LIMPAR A TELA 
 int contador = 0, i = 0; 
 printf("\nConsumo acima de %.2fKW", n); 
 for (i = 0; i < total; i++) { 
 if (conta[i][1] > n) { 
 printf("\nConta de numero: %.2f - KW: %.2f", conta[i][0], conta[i][1]); 
 contador++; 
 } 
 } 
 printf_s("\nTotal de consumidores encontrados: %d\n", contador);//EXIBE O TOTAL DE CONSUMIDORES ENCONTRADOS ACIMA DA MEDIA NA 
CIDADE 
 system("pause"); 
} 
void exibirmediacidade() {//PROCESSO PARA EXIBIR A MEDIA DE CONSUMO DA CIDADE 
 system("cls");//COMANDO PARA LIMPAR A TELA 
 float media = 0; 
 int i; 
 for (i = 0; i < total; i++) { 
 media = media + conta[i][1];//SOMANDO O CONSUMO 
 } 
 media = media / total; //CALCULANDO A MEDIA 
 printf_s("\nO consumo medio da cidade e de: %.2fKW\n", media); //EXIBE A MEDIA 
 system("pause"); 
} 
int main() 
{ 
 int opcao;//VARIAVEL PARA A ESCOLHA DO MENU 
 do { 
 menu(); 
 scanf_s("%d", &opcao); //COMANDO PARA LER A OPÇÃO DO USUARIO 
 switch (opcao) { 
 case 1: { 
 coletadedados(); //EXECUTA O PROCEDIMENTO PARA EXIBIR O CADASTRO DO CONSUMIDOR 
 break; 
 } 
 case 2: { 
 
 
 
 
 exibirconsumomaior(); //EXECUTA O PROCEDIMENTO PARA EXIBIR O MAIOR CONSUMO 
 break; 
 } 
 case 3: { 
 exibirconsumomenor(); //EXECUTA O PROCEDIMENTO PARA EXIBIR O MENOR CONSUMO 
 break; 
 } 
 case 4: { 
 exibirconsumoacima(170); //EXECUTA O PROCEDIMENTO PARA EXIBIR O CONSUMO ACIMA PEDIDO NO EXERCICIO 
 break; 
 } 
 case 5: { 
 exibirmediacidade(); //EXECUTA O PROCEDIMENTO PARA EXIBIR A MEDIA DO CONSUMO DA CIDADE 
 break; 
 } 
 case 6: { 
 goto sair; //FINALIZA O SISTEMA 
 } 
 default: { 
 printf_s("Opcao invalida, tente novamente.\n"); //MOSTRA A OPÇÃO INVALIDA 
 system("pause"); 
 } 
 } 
 } while (opcao != 6); 
sair: 
 return 0; 
} 
 
 
 
 
 
 
 
 
 
 
 
 
 
Imagem do código funcionando no computador:Exercício 3: 
Dizemos que uma matriz quadrada inteira é um quadrado mágico se a soma dos elementos de cada linha, a soma dos elementos 
de cada coluna e a soma dos elementos das diagonais principal e secundária são todas iguais. Dada uma matriz quadrada dimen-
são MxM, verifique se ela é um quadrado mágico através de um algoritmo. 
Exemplo de matriz quadrado mágico: 
 [8 0 7] 
 [4 5 6] 
 [3 10 2] 
 
Solução do aluno: 
#include <stdio.h>//BIBLIOTECA PADRAO DE ENTRADA E SAIDA 
#include <stdlib.h>//BIBLIOTECA PARA FAZER A PARADA NO FINAL DO CODIGO 
 
#define TMATRIZ 3 //DEFINE O TAMANHO DA MATRIZ 
 
void somalin(int matriz[TMATRIZ][TMATRIZ] , int linha) //PROCESSO DE SOMA POR LINHA 
{ 
 int indice , soma = 0; 
 for (indice = 0; indice < TMATRIZ; indice++) 
 { 
 soma += matriz[linha][indice]; 
 } 
 printf_s("%d", soma); 
} 
 
void somacol(int matriz[TMATRIZ][TMATRIZ], int coluna) // PROCESSO DE SOMA POR COLUNA 
{ 
 int indice, soma = 0; 
 for (indice = 0; indice < TMATRIZ; indice++) 
 { 
 soma += matriz[indice][coluna]; 
 } 
 printf_s("%d", soma); 
} 
 
 
 
 
void somaDP(int matriz[TMATRIZ][TMATRIZ])//PROCESSO PARA SOMA DA DIAGONAL PRINCIPAL 
{ 
 int coluna, linha, soma = 0; 
 for (linha = 0; linha < TMATRIZ; linha++) 
 { 
 for (coluna = 0; coluna < TMATRIZ; coluna++) 
 { 
 if (linha == coluna) 
 { 
 soma += matriz[linha][coluna]; 
 } 
 } 
 } 
 printf_s("%d", soma); 
} 
void somaDS(int matriz[TMATRIZ][TMATRIZ])//PROCESSO PARA SOMA DA DIAGONAL SECUNDARIA 
{ 
 int coluna, linha, soma = 0; 
 for (linha = TMATRIZ; linha >= 0; linha--) 
 { 
 for (coluna = 0; coluna < TMATRIZ; coluna++) 
 { 
 if ((linha + coluna) == (TMATRIZ - 1)) 
 { 
 soma += matriz[linha][coluna]; 
 } 
 } 
 } 
 printf_s("%d", soma); 
} 
void quadradomagico(int matriz[TMATRIZ][TMATRIZ])//VERIFICAÇÃO SE A MATRIZ É DO TIPO QUADRADO MÁGICO 
{ 
 int soma , linha = 0, coluna = 0 , compara = 0; 
 do {//VERIFICAÇÃO SE AS SOMAS DAS LINHA SÃO IGUAIS 
 soma = 0;//É PRECISO ZERAR A SOMA 
 for (coluna = 0; coluna < TMATRIZ; coluna++)//SOMA DAS COLUNAS POR LINHA 
 { 
 soma += matriz[linha][coluna]; 
 } 
 if (!compara ) 
 
 
 
 
 { 
 compara = soma;//DEFININDO UM VALOR PARA A VARIAVEL DE COMPARAÇÃO 
 } 
 else//AGORA FAZEMOS A COMPARAÇÃO COM A NOVA SOMA 
 { 
 if (soma != compara) 
 { 
 printf_s("\nNao forma quadrado magico\n");//SE AS SOMAS FOREM DIFERENTES IMPRIMI A MENSAGEM PARA O USUARIO 
 goto final;//SE FOR DIFERENTE VAI PARA O FINAL 
} 
 else //SE FOR IGUAL CONTINUA PARA A PROXIMA ETAPA 
 { 
 linha++; 
 } 
 } 
} 
 while (linha < TMATRIZ); 
//PROCESO DE VERIFICAÇÃO PARA VER SE A SOMA DAS LINHAS SÃO IGUAIS 
 coluna = 0; 
 do { 
 soma = 0; 
 for (linha = 0; linha < TMATRIZ; linha++) //SOMA COLUNA POR COLUNA 
 { 
 soma += matriz[linha][coluna]; 
 } 
 if (soma != compara) 
 { 
 printf_s("\nNao forma quadrado magico\n");//SE AS SOMAS FOREM DIFERENTES IMPRIMI A MENSAGEM PARA O USUARIO 
 goto final;//SE FOR DIFERENTE VAI PARA O FINAL 
 } 
 else {//SE FOR IGUAL CONTINUA PARA A PROXIMA ETAPA 
 coluna++; 
 } 
} 
 while (coluna < TMATRIZ);//COMPARAÇÃO DA DIAGONAL PRINCIPAL 
 soma = 0;//É PRECISO ZERAR A SOMA 
 for (linha = 0; linha < TMATRIZ; linha++) 
 { 
 for (coluna = 0; coluna < TMATRIZ; coluna++) 
 { 
 
 
 
 
 if (linha == coluna) 
 { 
 soma += matriz[linha][coluna]; 
 } 
 } 
 } 
 if (soma != compara) 
 { 
 printf_s("\nNao forma quadrado magico\n");//SE AS SOMAS FOREM DIFERENTES IMPRIMI A MENSAGEM PARA O USUARIO 
 goto final;//SE FOR DIFERENTE VAI PARA O FINAL 
 } 
 soma = 0;//É PRECISO ZERAR A SOMA 
 for (linha = TMATRIZ; linha >= 0; linha--) //COMPARAÇÃO DA DIAGONAL SECUNDÁRIA 
 { 
 for (coluna = 0; coluna < TMATRIZ; coluna++) 
 { 
 if ((linha + coluna) == (TMATRIZ - 1)) 
 { 
 soma += matriz[linha][coluna]; 
 } 
 } 
 } 
 if (soma != compara) 
 { 
 printf_s("\nNao forma quadrado magico\n");//SE AS SOMAS FOREM DIFERENTES IMPRIMI A MENSAGEM PARA O USUARIO 
 goto final;//SE FOR DIFERENTE VAI PARA O FINAL 
 } 
 printf_s("\nForma quadrado magico");//SE TODAS AS SOMAS FOREM IGUAIS, IMPRIMI A MENSAGEM PARA O USUARIO 
 final:; 
} 
int main() 
{ 
int matriz[TMATRIZ][TMATRIZ];//DECLARA O TAMANHO DO VETOR DA MATRIZ 
int linha, coluna;//VARIAVEL DO TIPO INTEIRO PARA LINHA E COLUNA 
//COLETA OS DADOS PARA FORMAR A MATRIZ 
 for (linha = 0; linha < TMATRIZ; linha++) 
 { 
 for (coluna = 0; coluna < TMATRIZ; coluna++) 
 { 
 printf_s("Digite o valor da posicao %d, %d: ", linha, coluna); 
 
 
 
 
 scanf_s("%d", &matriz[linha][coluna]); 
 } 
 } 
//MOSTRA PARA O USUARIO A MATRIZ CRIADA 
 printf_s("\n *** MATRIZ *** \n"); 
 for (linha = 0; linha < TMATRIZ; linha++) 
 { 
 for (coluna = 0; coluna < TMATRIZ; coluna++) 
 { 
 if (coluna == 0) 
 { 
 printf_s("\n|"); 
 } 
 printf_s("%02d", matriz[linha][coluna]); 
 if (coluna < TMATRIZ -1) 
 { 
 printf_s("\t"); 
 } 
 if (coluna + 1 == TMATRIZ) 
 { 
 printf_s("|"); 
 } 
 } 
 } 
 printf_s("\n"); 
 //SOMA DAS LINHAS 
 for (linha = 0; linha < TMATRIZ; linha++) 
 { 
 printf_s("\nSoma da linha %d: ", linha + 1); 
 somalin(matriz, linha); 
 } 
 printf_s("\n"); 
 //SOMA DAS COLUNAS 
 for (coluna = 0; coluna < TMATRIZ; coluna++) 
 { 
 printf_s("\nSoma da coluna %d: ", coluna + 1); 
 somacol(matriz, coluna); 
 } 
 printf_s("\n\nSoma da diagonal principal: "); 
 somaDP(matriz); 
 
 
 
 
 printf_s("\n\nSoma da diagonal secundaria: "); 
 somaDS(matriz); 
 printf_s("\n"); 
 //VERIFICA SE É QUADRADO MÁGICO 
 quadradomagico(matriz); 
 printf_s("\n"); 
system("pause"); 
return 0; 
} 
 
Imagem do código funcionando no computador: 
 
 
 
 
 
Exercício 4: 
Escrever uma função que receba como parâmetro duas strings, bem como um valor inteiro que representa uma posição. A função 
deve, portanto, inserir a segunda string no na posição indicada da primeira. 
Escreva um programa que receba estas duas strings do usuário, o valor da posição desejada, e chame a função anteriormente 
implementada e exiba o resultado ao usuário na tela. 
Para imprimir na tela e tirar o print screen, mostre o resultado utilizando o seu primeiro nome como string 1 e o seu último nome 
como string 2, e a posição de teste deverá ser o último digito do seu RU 
 
 
 
 
Solução do aluno: 
#include <stdio.h>//BIBLIOTECA PADRAO DE ENTRADA E SAIDA 
#include <string.h>//BILIOTECA PARA MANIPULAR STRINS 
#include <stdlib.h>//BIBLIOTECA PARA FAZER A PARADA NO FINAL DO CODIGO 
#include <locale.h>//BIBLIOTECA PARA ACEITAR CARACTERES ESPECIAIS DA LINGUA PORTUGUESA E ACENTUÇÃO 
 
 
#define TAMANHO_STRING 50// DEFININDO O TAMANHO DO VETOR 
#define TAMANHO_TOTAL_STRINGS TAMANHO_STRING * 2 + 1 // DEFININDO O TAMANHO DAS STRINGS 
char* resposta(const char* nome, const char* sobrenome, int n);//FUNÇÃO QUE RETORNARA A RESPOSTA 
//PROCESSO PARA INCIAR A JUNÇÃO DAS STRINGS 
void juntarString() 
{ 
 char nome[TAMANHO_STRING], sobrenome[TAMANHO_STRING]; 
 int RU = 0; 
 //COLETA DE DADOS DO USUARIO 
 printf("\nDigite o primeiro nome: "); 
 scanf_s("%s", nome, TAMANHO_STRING); 
 printf("\nDigite o sobrenome: "); 
 scanf_s("%s", sobrenome, TAMANHO_STRING); 
 //LOOPING DO-WHILE PARA QUE O USUARIO DIGITE UM NUMERO VALIDO DE 0 A 9 
 do 
 
 
 
 
 { 
 printf("\nDigite o Ultimo numero do RU UNINTER: "); 
 scanf_s("%d", &RU); 
 if ((RU < 0) || (RU > 9)) 
 { 
 printf("\nNumero invalido. Digite um valor entre 0 E 9.\n"); 
 system("pause"); 
 } 
 } while (((RU < 0) || (RU > 9))); 
 //IMPRIME OS RESULTADOS NA TELA DO USUARIO 
 printf_s("\n"); 
 printf_s("********************************************************\n"); 
 printf_s("\n"); 
 printf_s("O nome completo é: %s %s\n", nome, sobrenome); 
 printf_s("\nO resultado da junção das strings: %s\n", resposta(nome, sobrenome,RU)); 
 printf_s("\n"); 
 printf_s("********************************************************\n");printf_s("\n"); 
 system("pause"); 
} 
//INICIANDO O PROGRAMA COM UM MENU 
int main(int argc, char* argv[]) { 
 int status = 0; 
 setlocale(LC_ALL, "Portuguese"); //CONFIGURAÇÃO PARA EXIBIR CARACTERES ESPECIAIS DA LINGUA PORTUGUESA 
 
 system("cls");//LIMPA TELA 
 //INICIA LOOP DO-WHHILE 
 do { 
 //INICIANDO O MENU PARA INICIAR OU SAIR DO PROGRAMA 
 printf("\nMENU OPÇÃO"); 
 printf("\n************\n"); 
 printf("\nIniciar (1) , Sair (0)\n--> "); 
 scanf_s("%d", &status); 
 //INICIO DO COMANDO SWITCH 
 switch (status){ 
 //ESCOLHA DA OPÇÃO 1 
 case 1: { 
 juntarString(); 
 break; 
 } 
 
 
 
 
 default: 
{ 
 //ESCOLHA DA OPÇÃO 0(SAIR) 
 if (status != 0) { 
 printf("Opção inválida\n"); 
 system("pause"); 
 } 
 break; 
 } 
 } 
 } while (status != 0); 
 system("cls"); 
 system("pause");//LIMPA TELA 
 return 0; 
} 
//FUNÇÃO PARA RETORNAR A UNÇÃO DE 2 STRINGS 
char* resposta(const char* nome, const char* sobrenome, int pos) 
{ 
 short int i = 0, j = 0, tam1 = 0, tam2 = 0, tam3 = 0; 
 char vetor;//DECLAREI VETOR, PARA RETORNAR O VETOR SOBRENOME[J] 
 tam1 = strlen(nome); 
 tam2 = strlen(sobrenome); 
 tam3 = tam1 + tam2; 
 char* nova = (char*)malloc(TAMANHO_TOTAL_STRINGS * sizeof(char));//DECLAREI UM VETOR DE STRING PARA JUNÇÃO 
 if (nova == NULL)//SE NÃO ALOCAR NA MEMORIA, SERA EXIBIDO A MENSAGEM DE ERRO 
 { 
 puts("Falha na memória..."); 
 exit(1); 
 } 
 //INCIO DA ESTRUTURA DE DECISÃO , PARA SABER EM QUAL POSIÇÃO SERÁ INSERIDA A STRING 
 if (pos == 0) { 
 pos = 1; 
 } 
 else { 
 if (pos > tam1) { 
 pos = tam1 + 1; 
 } 
 } 
 while (i < tam3) { 
 if (i == pos - 1) { 
 
 
 
 
 while (sobrenome[j] != '\0') {//SE O ULTIMO CARACTERE FOR NULO , O LOOP VAI ATÉ O ULTIMO CARACTERE VALIDO. 
 vetor = '\0'; 
 vetor = sobrenome[j];//RECEBE A LETRA NA POSIÇÃO SOBRENOME[J] 
 nova[i] = vetor;//NOVA RECEBE NA POSIÇÃO INDICADA 'I' A LETRA DO SOBRENOME NA POSIÇÃO INDICADA 'J' 
 i++;//SOMA 'I+1' 
 j++;//SOMA 'J+1' 
 } 
 } 
 else { 
 nova[i] = nome[i - j]; 
 i++; 
 } 
 } 
 nova[tam3] = '\0'; 
 return nova;//RETORNA A JUNÇÃO DA STRING 
} 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Imagem do código funcionando no computador: