INSTITUTO FEDERAL DE EDUCAÇÃO, CIÊNCIA E TECNOLOGIA DA BAHIA – IFBA

ENGENHARIA ELÉTRICA

ANDRÉ OLIVEIRA SOUZA

KIARA BONELLA SCARAMUSSA
LUCIANE SILVA SANTOS

CODER

VITÓRIA DA CONQUISTA
FEVEREIRO/2019
 ANDRÉ OLIVEIRA SOUZA
KIARA BONELLA SCARAMUSSA
LUCIANE SILVA SANTOS

CODER

Artigo apresentado como requisito parcial para

obtenção de aprovação na disciplina de Técnicas
de Programação, do Curso Superior de
Bacharelado em Engenharia Elétrica, no Instituto
Federal de Educação, Ciência e Tecnologia da
Bahia, no Campus Vitória da Conquista.

Profª. Viviane Lelis

VITÓRIA DA CONQUISTA
FEVEREIRO/2019
 1. INTRODUÇÃO

O presente relatório apresenta o desenvolvimento de um algoritmo na linguagem C++ de um programa

que realiza a criptografia de mensagens através de matriz. O software, que foi nomeado de CODER, se baseia
em princípios matemáticos que ao multiplicar um número pelo seu inverso obteremos um elemento neutro, no
caso de matriz, é obtido a matriz identidade. Uma matriz identidade ou unidade é uma matriz que apresenta em
sua diagonal principal o elemento 1 e o restante dos elementos são formados por zeros, a matriz identidade é
uma matriz quadrada e também é uma matriz diagonal. Uma matriz é diagonal quando os elementos que não
pertencem a diagonal principal são nulos. E uma matriz é quadrada quando o número de linhas e colunas são
iguais. Como equivalência de letra para número a ser usada na criptografia foi utilizado a Tabela Ascii.

2. METODOLOGIA

O projeto consiste na proposta de um programa para encriptar matrizes e funciona da seguinte maneira:
ao inserirmos uma matriz qualquer no programa, como é solicitado no menu principal, o programa irá nos dar
uma chave decodificadora que será fundamental futuramente no programa, a chave decodificadora é a inversa
da matriz digitada. Após isso, aparecerá um segundo menu com as opções de inserir a palavra a ser encriptada,
visualizar as palavras já inseridas e uma terceira opção para desencriptação.
Ao escolher a opção de inserir palavra, o programa pede para digitarmos a palavra desejada contando
que a mesma tenha 9 caracteres, caso a palavra desejada não tenha 9 letras, o programa oferece como dica
adicionar exclamações (!) a palavra até que a mesma chegue a quantidade de 9 caracteres. Com isso, o
programa irá transformar a sua palavra em matriz (matriz palavra), tendo como base a tabela Ascii.
Multiplicando a matriz inserida no primeiro momento com a matriz palavra, temos a matriz palavra encriptada.
Transformando a matriz palavra encriptada em palavra novamente é obtido a palavra embaralhada que será
armazenada na memória do programa.
Ao voltar para o menu secundário e escolher a opção “minhas palavras” são listadas para o usuário todas
as palavras inseridas até o momento junto de um índice de decodificação equivalente a ordem em que a palavra
foi inserida.
Ainda no menu secundário, quando escolhido a opção “desencriptar”, o programa irá solicitar o índice
de decodificação da palavra desejada, logo após é necessário inserir a chave decodificadora obtida no menu
principal, se a chave decodificadora estiver certa e a matriz inserida tiver matriz inversa perfeita, a palavra
inserida será revelada.

3. IMPLEMENTAÇÃO
 Com vistas à modularização e usabilidade, a implementação aqui apresentada se vale dos conceitos de
modularização, algo típico de linguagens de programação procedurais como a linguagem C++.
No quadro a seguir, é apresentado o código-fonte do programa:
#include<iostream>
#include<stdlib.h>
#define L 3
#define C 6
#define U 9
using namespace std;
struct pala{
char palavra[U];
};
void cabecario();
void menu(int &op);
void menu_2(int &op);
void frase(char *palavra);
void desenvolvedores();
void sobre();
void palavra_matriz(char *palavra, int *matriz);
void escrever_palavra_matriz(int *matriz);
void palavra_matriz(char *palavra, int *matriz);
void palavra_matriz_final(pala vetor[U], int *matriz, int i);
void matriz_palavra(pala vetor[U], int *mtriz, int i);
void matriz_palavra_embaralhada(char vetor[U], int *matriz);
void ler_matriz(int p[L][L]);
void escrever_matriz(int p[L][L]);
void concatenar_matriz(float *p_2, int *p);
void escalonamento(float matriz_2[L][C]);
void multiplica_matriz(int matriz_p[L][L],int matriz[L][L], int m__p2[L][L]);
void inversa_final(float inv[][L], float m[][C]);
void multiplica_matriz_final(int matriz_p[L][L],int matriz[L][L], int m__p2[L][L]);
void inversa_final(int inv[][L], float m[][C]);
int main(){

int m[L][L],m_3[L][L],i[L][L],o,o_o,p_m[L][L],valor=0,dec,p_m_2[L][L],indice=0,m_p_f[L]
[L],m_inv[L][L];
pala a[U];
char f[U];
float m_2[L][C];
do{
cabecario();
menu(o);
switch(o){

case 1: if(valor==0){
ler_matriz(m);
cout<<"\nSua matriz eh: "<<endl;
cout<<"----------------------------"<<endl;
escrever_matriz(m);
concatenar_matriz(m_2[0],m[0]);
escalonamento(m_2);
inversa_final(m_inv,m_2);
 valor++;
cout<<"\n\n"<<endl;
system("PAUSE");
}

do{ menu_2(o_o);
switch(o_o){
case 1:
frase(f);
palavra_matriz(f,p_m[0]);
escrever_palavra_matriz(p_m[0]);
multiplica_matriz(p_m,m,p_m_2);
cout<<"\n\nMatriz palavra encriptada: "<<endl;
cout<<"----------------------------"<<endl;
escrever_matriz(p_m_2);
matriz_palavra(a,p_m_2[0],indice);
cout<<"\n\nSua palavra embaralhada eh: ";
for(int cont=0;cont<U;cont++){
cout<<a[indice].palavra[cont];
}
cout<<"\n\n";
indice++;
system("pause");
break;
case 2: cout<<"\n\t\tSUAS PALAVRAS: \n"<<endl;
for(int l=0;l<indice;l++){
cout<<"\t\t";
for(int c=0;c<U;c++){
cout<<a[l].palavra[c];
}
cout<<"\t\tIndice de decodificacao: "<<l;
cout<<"\n\n";
}
break;
case 3: cout<<"\n\t\tINSIRA O INDICE DE DECODIFICACAO: "<<endl;
cin>>dec;
palavra_matriz_final(a,p_m[0],dec);
cout<<"\n\t\tLEMBRA DA CHAVE DECOFICADORA??\n\n\t\tHORA DE USA-
LA!!"<<endl;
ler_matriz(m_3);
multiplica_matriz(p_m,m_3,m_p_f);
matriz_palavra_embaralhada(f,m_p_f[0]);
cout<<"\n\nSua Palavra Decodificada eh: ";
for(int cont=0;cont<U;cont++){
cout<<f[cont];
}
cout<<"\n\n";
break;
case 4: cout<<"\n\n\t\tVOLTANDO...";
break;
default: cout<<"\n\n\t\tSE LIGA VEI, ESSA OPCAO NAO TEM!!!\n\n";
break;
}
 }while(o_o!=4);
break;
case 2: sobre();
break;
case 3: desenvolvedores();
break;
case 4: cout<<"\n\t\t\t\tMUITO OBRIGADO POR TER CONHECIDO O CODER!!!!"<<endl;
break;
default: cout<<"\n\n\t\tSE LIGA VEI, ESSA OPCAO NAO TEM!!!\n\n";
break;

}
system("PAUSE>>NULL");
}while(o!=4);

void cabecario(){
cout<<"\n";
cout<<"\t\t\t\t SEJA MUITO BEM VINDO AO CODER!!!\n\n\t\t\t ESTE PROGRAMA
ULTILIZA MATRIZ PARA ENCRIPTAR PALAVRAS.\n"<<endl;

void menu(int &op){

cout<<"\t\t*****************************************************************************
**"<<endl;
cout<<"\t\t*****************************************************************************
**"<<endl;
cout<<"\t\t************ ************"<<endl;
cout<<"\t\t************ MENU ************"<<endl;
cout<<"\t\t************ ************"<<endl;
cout<<"\t\t*****************************************************************************
**"<<endl;
cout<<"\t\t************|===========|*************************************|=====|
**********"<<endl;
cout<<"\t\t************| ENCRIPTAR |*************************************| 1 |
**********"<<endl;
cout<<"\t\t************|===========|*************************************|=====|
**********"<<endl;
cout<<"\t\t*****************************************************************************
**"<<endl;
cout<<"\t\t************|===========|*************************************|=====|
**********"<<endl;
cout<<"\t\t************| SOBRE |*************************************| 2 |
**********"<<endl;
cout<<"\t\t************|===========|*************************************|=====|
**********"<<endl;
cout<<"\t\t*****************************************************************************
**"<<endl;
cout<<"\t\t************|=====================|***************************|=====|
**********"<<endl;
cout<<"\t\t************| DESENVOLVEDORES |***************************| 3 |
**********"<<endl;
cout<<"\t\t************|=====================|***************************|=====|
**********"<<endl;
cout<<"\t\t*****************************************************************************
**"<<endl;
cout<<"\t\t************|===========|*************************************|=====|
**********"<<endl;
cout<<"\t\t************| SAIR |*************************************| 4 |
**********"<<endl;
cout<<"\t\t************|===========|*************************************|=====|
**********"<<endl;
cout<<"\t\t*****************************************************************************
**"<<endl;
cin>>op;

}
void menu_2(int &op){
cout<<"\t\t*****************************************************************************
**"<<endl;
cout<<"\t\t*****************************************************************************
**"<<endl;
cout<<"\t\t************ ************"<<endl;
cout<<"\t\t************ OPCOES ************"<<endl;
cout<<"\t\t************ ************"<<endl;
cout<<"\t\t*****************************************************************************
**"<<endl;
cout<<"\t\t************|=================|*******************************|=====|
**********"<<endl;
cout<<"\t\t************| INSERIR PALAVRA |*******************************| 1 |
**********"<<endl;
cout<<"\t\t************|=================|*******************************|=====|
**********"<<endl;
cout<<"\t\t*****************************************************************************
**"<<endl;
cout<<"\t\t************|=====================|***************************|=====|
**********"<<endl;
cout<<"\t\t************| MINHAS PALAVRAS |***************************| 2 |
**********"<<endl;
cout<<"\t\t************|=====================|***************************|=====|
**********"<<endl;
 cout<<"\t\t*****************************************************************************
**"<<endl;
cout<<"\t\t************|=====================|***************************|=====|
**********"<<endl;
cout<<"\t\t************| DESENCRIPTAR |***************************| 3 |
**********"<<endl;
cout<<"\t\t************|=====================|***************************|=====|
**********"<<endl;
cout<<"\t\t*****************************************************************************
**"<<endl;
cout<<"\t\t************|===========|*************************************|=====|
**********"<<endl;
cout<<"\t\t************| VOLTAR |*************************************| 4 |
**********"<<endl;
cout<<"\t\t************|===========|*************************************|=====|
**********"<<endl;
cout<<"\t\t*****************************************************************************
**"<<endl;
cin>>op;

void frase(char vetor[U]){

cout<<"\nA palavra que sera encriptada devera ter 9 caracteres.\n\nDICA: Se necessario use pontos como
'!!' para completar a palavra."<<endl;
cout<<"Insira a palavra: "<<endl;
for(int cont=0;cont<U;cont++){
cin>>vetor[cont];
}
}
void desenvolvedores(){
cout<<"\t\t*****************************************************************************
**"<<endl;
cout<<"\t\t*****************************************************************************
**"<<endl;
cout<<"\t\t*****************************************************************************
**"<<endl;
cout<<"\t\t************ ************"<<endl;
cout<<"\t\t************ IFBA - INSTITUTO FEDERAL DA BAHIA
************"<<endl;
cout<<"\t\t************ ************"<<endl;
cout<<"\t\t************ CAMPUS VITORIA DA CONQUISTA
************"<<endl;
cout<<"\t\t************ ************"<<endl;
cout<<"\t\t*****************************************************************************
**"<<endl;
cout<<"\t\t*****************************************************************************
**"<<endl;
cout<<"\t\t************ ************"<<endl;
cout<<"\t\t************ ANDRE OLIVEIRA SILVA - GRADUANDO EM ENG. ELETRICA
************"<<endl;
cout<<"\t\t************ ************"<<endl;
cout<<"\t\t*****************************************************************************
**"<<endl;
cout<<"\t\t*****************************************************************************
**"<<endl;
cout<<"\t\t************ ************"<<endl;
cout<<"\t\t************ KIARA BONELLA SCARAMUSSA - GRADUANDA EM ENG. ELETRICA
************"<<endl;
cout<<"\t\t************ ************"<<endl;
cout<<"\t\t*****************************************************************************
**"<<endl;
cout<<"\t\t*****************************************************************************
**"<<endl;
cout<<"\t\t************ ************"<<endl;
cout<<"\t\t************ LUCIANE SILVA SANTOS - GRADUANDA EM ENG. ELETRICA
************"<<endl;
cout<<"\t\t************ ************"<<endl;
cout<<"\t\t*****************************************************************************
**"<<endl;
cout<<"\t\t*****************************************************************************
**"<<endl;
cout<<"\t\t*****************************************************************************
**\n\n"<<endl;

void sobre(){
cout<<"\n\n\t O PROGRAMA SURGIU COM A IDEIA DE RELACIONAR DUAS MATERIAS
IMPORTANTES NOS CURSOS DE ENGENHARIA.";
cout<<"\n\n\t EXISTE UMA IDEIA DE QUE OS TEMAS ENSINADOS NO ENSINO MEDIO SOBRE
MATEMATICA E ALGERBA NAO TERIAM";
cout<<"\n\tUMA ULTILIADE REAL, SERVIRIAM APENAS PARA AS PESSOAS QUE SEGUIRAM
NO MUNDO MATEMATICO. O CODER VEIO";
cout<<"\n\tPARA DESMESTIFICAR ESSA IDEIA, EXISTEM MILHOES DE MANEIRAS DE
RELACIONAR A ALGEBRA COM O NOSSO COT-";
cout<<"\n\tIDIANO, UMA DELAS E A ENCRIPTACAO. TUDO HOJE EM DIA USA
ENCRIPTACAO, ATE AS MENSAGENS TROCADAS POR";
cout<<"\n\tWHATSAPP SAO CRIPTOGRAFADAS.";
cout<<"\n\n\t O CODER E ACIMA DE TUDO DIDATICO, DEMONSTRANDO QUE ATRAVES DA
MULTIPLICAO DE MATRIZES E ALGUM-";
 cout<<"\n\tAS SOLUCOES ELEMENTARES E POSSIVEL FAZER ALGO TAO COMPLEXO
QUANTO ENCRIPTOGRAFAR UMA PALAVRA. ";
cout<<"\n\n\t O CODER PODE SER ULTILIZADO TANTO POR PROFESSORES DE ALGEBRA,
COM INTUITO DE DEMONSTRAR ULTIZ-";
cout<<"\n\tACOES PRATICAS DO ASSUNTO AOS SEUS ALUNOS, QUANTO POR PROFESSORES
DE PROGRAMACAO BASICA, REALIZAN-";
cout<<"\n\tDO O MESMO ENTENDIMENTO PRATCO DA MATERIA.\n\n"<<endl;

void palavra_matriz(char vetor[U], int *matriz){

int cont;
for(cont=0;cont<U;cont++){
*matriz=vetor[cont];
matriz++;
}

}
void palavra_matriz_final(pala vetor[U], int *matriz, int i){
int cont;
for(cont=0;cont<U;cont++){
*matriz=vetor[i].palavra[cont];
matriz++;
}

}
void matriz_palavra(pala vetor[U], int *mtriz, int i){
int cont;
for(cont=0;cont<U;cont++){
vetor[i].palavra[cont] = *mtriz;
mtriz++;
}
}
void matriz_palavra_embaralhada(char vetor[U], int *matriz){
int cont;
for(cont=0;cont<U;cont++){
vetor[cont] = *matriz;
matriz++;
}
}

void escrever_palavra_matriz(int *matriz){

int cont;
cout<<"\nSua Palavra Transformada em Matriz"<<endl;
cout<<"----------------------------"<<endl;
for(cont=0;cont<9;cont++){
if(cont==3||cont==6||cont==9)
cout<<"\n";
cout<<"\t"<<*matriz;

matriz++;
 }

void ler_matriz(int p[L][L]){

int l,c;
for(l=0;l<L;l++){
for(c=0;c<L;c++){
cout<<"\nINSIRA A MATRIZ["<<l+1<<"]["<<c+1<<"]: "<<endl;
cin>> p[l][c];
}
}
}
void escrever_matriz(int p[L][L]){
for(int l=0;l<3;l++){
for(int c=0;c<3;c++){
cout<<"\t"<<p[l][c];
}
cout<<"\n";
}
}
void concatenar_matriz(float *p_2, int *p){
int l,c,cont,identidade[L][L],k,q;
int t=C*L;
for(l=0;l<L;l++){
for(c=0;c<L;c++){
if(c==l)
identidade[l][c]=1;
Else
identidade[l][c]=0;
}

}
for(cont=0,c=0,k=0,q=0;cont<t;cont++){
if(c<3){
*p_2=*p;
p++;
}
else {
*p_2=identidade[k][q];
q++;
if(q==3){
q=0;
k++;
}}
p_2++;
c++;
if(c==6){
c=0;}
}
}
void escalonamento(float matriz_2[L][C]){
int l,c,k;
float aux;
//Escalonamento
if(matriz_2[0][0]!=0){
aux=matriz_2[0][0];
for(c=0;c<6;c++){
matriz_2[0][c]=matriz_2[0][c]/aux;
}}
if(matriz_2[1][0]!=0){
aux=matriz_2[1][0];
for(c=0;c<C;c++){
matriz_2[1][c]=matriz_2[1][c]/aux;
}
for(c=0;c<C;c++){
matriz_2[1][c]=matriz_2[1][c]-matriz_2[0][c];
}}
if(matriz_2[2][0]!=0){
aux=matriz_2[2][0];
for(c=0;c<C;c++){
matriz_2[2][c]=matriz_2[2][c]/aux;
}for(c=0;c<C;c++){
matriz_2[2][c]=matriz_2[2][c]-matriz_2[0][c];
}}

//Zerei os da primeira coluna

if(matriz_2[1][1]!=0){
aux=matriz_2[1][1];
for(c=0;c<C;c++){
matriz_2[1][c]=matriz_2[1][c]/aux;
}}
if(matriz_2[2][1]!=0){
aux=matriz_2[2][1];
for(c=0;c<C;c++){
matriz_2[2][c]=matriz_2[2][c]/aux;
}for(c=0;c<C;c++){
matriz_2[2][c]=matriz_2[2][c]-matriz_2[1][c];
}}

if(matriz_2[2][2]==0){
cout<<"\nA SUA MATRIZ NAO POSSUI INVERSA!!"<<endl;
}
else{
aux=matriz_2[2][2];
for(c=0;c<C;c++){
matriz_2[2][c]=matriz_2[2][c]/aux;
}
if(matriz_2[1][2]!=0){
 aux=matriz_2[1][2];
for(c=0;c<C;c++){
matriz_2[2][c]=matriz_2[2][c]*aux;
}
for(c=0;c<C;c++){
matriz_2[1][c]=matriz_2[1][c]-matriz_2[2][c];
}
for(c=0;c<C;c++){
matriz_2[2][c]=matriz_2[2][c]/aux;
}
}
if(matriz_2[0][1]!=0){
aux=matriz_2[0][1];
for(c=0;c<C;c++){
matriz_2[1][c]=matriz_2[1][c]*aux;
}
for(c=0;c<C;c++){
matriz_2[0][c]=matriz_2[0][c]-matriz_2[1][c];
}
for(c=0;c<C;c++){
matriz_2[1][c]=matriz_2[1][c]/aux;
}
}
if(matriz_2[0][2]!=0){
aux=matriz_2[0][2];
for(c=0;c<C;c++){
matriz_2[2][c]=matriz_2[2][c]*aux;
}
for(c=0;c<C;c++){
matriz_2[0][c]=matriz_2[0][c]-matriz_2[2][c];
}
for(c=0;c<C;c++){
matriz_2[2][c]=matriz_2[2][c]/aux;
}
}
cout<<"\nNAO ESQUECA SUA CHAVE, POIS SEM ELA VOCE NAO CONSEGUIRA RECUPERAR
SUA PALAVRA!!!"<<endl;
}

}
void multiplica_matriz(int matriz_p[L][L],int matriz[L][L], int m__p2[L][L]){
int c,l,k,le=0,ce=0;
for(l=0;l<L;l++){
for(c=0;c<L;c++){
m__p2[l][c]=0;
}
}
for(ce=0,k=0;k<L;ce++,k++){
for(le=0,l=0;l<L;le++,l++){
for(c=0;c<L;c++){
m__p2[le][ce]=m__p2[le][ce]+matriz_p[c][k]*matriz[l][c];
}}}
}
void inversa_final(int inv[][L], float m[][C]){
for(int l=0;l<L;l++){
for(int c=0, k=3;c<L;c++,k++){
inv[l][c]=m[l][k];
}
}
cout<<"SUA CHAVE DECODIFICADORA EH: "<<endl;
cout<<"----------------------------"<<endl;
for(int l=0;l<L;l++){
for(int c=0;c<L;c++){
cout<<"\t"<<inv[l][c];
} cout<<"\n";
}

}
void multiplica_matriz_final(int matriz_p[L][L],int matriz[L][L], int m__p2[L][L]){
int c,l,k,le=0,ce=0;
for(l=0;l<L;l++){
for(c=0;c<L;c++){
m__p2[l][c]=0
;
}
}
for(ce=0,k=0;k<L;ce++,k++){
for(le=0,l=0;l<L;le++,l++){
for(c=0;c<L;c++){
m__p2[le][ce]=m__p2[le][ce]+matriz_p[c][k]*matriz[l][c];
}}}
}
4. CONCLUSÃO

A finalidade do programa é utilizar de duas matérias fundamentais do curso de engenharia que são a
álgebra e a matemática para aplicar os conhecimentos adquiridos na área de programação na prática. O
CODER foi pensado para, acima de tudo, demonstrar que podemos fazer muito com a ajuda da
matemática.
O software pode ser utilizado tanto por professores de álgebra, matemática e programação com intuito
de demonstrar em prática utilização do assunto aos seus alunos para melhor entendimento da matéria.