AlgoritmoDeEuclides

/*
Algoritmo desenvolvido como solução ao problema apresentado em sala de aula na
 disciplina Matemática Discreta ministrada pelo professor André Almeida, onde
 o mesmo propôs que o Algoritmo de Euclides fosse implementado em alguma línguagem
 de programação.

 Alunos:
   Dhian Kelson de Oliveira Leite
   Lucas Henrique Martins Soares
   Maria Eliana da Silva Holanda
*/

#include <stdio.h>
#include <stdlib.h>
#include <locale.h>

// A constante  "LINHAS" define um tamanho padrão de linhas na matriz.
#define LINHAS 3

int main() {
    // Faz com que o prompt permita acentuações.
    setlocale(LC_ALL, "");
/*
    As variáveis "dividendo" e "divisor" armazenam o valor informado pelo usuário
     até o fim da execução do programa, pois esses valores são utilizados em
     diferentes partes do código.
    As variáveis "divisorTemp" e "dividendoTemp" serão usadas para armazenar os
     sucessivos valores calculados à partir dos valores em "dividendo" e "divisor".
    A variável "temp" será usada para armazenar os valores que serão passados de
     uma variável a outra durante a execução.
    A variável "contador" será usada para calcular e definir as colunas da matriz.
    As variáveis "x", "y" e "z" são usadas para acessar os campos da matriz.
    A variável "divInt" será usada para armazenar a divisão inteira que é usada
     no algoritmo.
*/
    int dividendo, divisor, dividendoTemp = 0, divisorTemp = 0, temp, contador, x, y, z, divInt;
// É usado para verificar se o usuário quer continuar a execução do pograma.
    char opcao;

// Define o tamanho da tela.
    system("mode con cols=100 lines=26");

    do {
    // Limpa a tela.
        system("cls");
    // Define a cor padrão.
        system("color 1F");

        /*
            É incrementado 2 ao "contador" por que sempre existem duas colunas para armazenar
             a primeira conta.
        */
        contador = 2;

        printf("\n\t\t######### Algoritmo de Euclides #########\n\n");

    // Recebe e valida o primeiro algarismo.
        do {
            printf("\n  Informe o primeiro algarismo: ");
        // Lê o valor informado pelo usuário.
            scanf("%d", &dividendo);

        // Se o valor informado for igual a zero...
            if (dividendo == 0) {
            // Limpa a tela.
                system("cls");
                printf("\n\nO dividendo deve ser diferente de zero!\n\n");
            }
    // O laço repetirá enquanto o valor informado for igual a zero.
        } while (dividendo == 0);

    // Recebe e valida o segundo algarismo.
        do {
            printf("  Informe o segundo algarismo: ");
        // Lê o valor informado pelo usuário.
            scanf("%d", &divisor);

        // Se o valor informado for igual a zero...
            if (divisor == 0) {
            // Limpa a tela.
                system("cls");
                printf("\n\nO dividendo deve ser diferente de zero!\n\n");
            }
    // O laço repetirá enquanto o valor informado for igual a zero.
        } while (divisor == 0);

    // Verifica se o divisor é maior que o dividendo, caso sim, inverte seus valores.
        if (divisor > dividendo) {
            temp = divisor;
            divisor = dividendo;
            dividendo = temp;
        }

    /*
        Os valores são atribuídos às variáveis temporárias para iniciar o cálculo do
         número de colunas necessário e preservando o valor informado inicialmente pelo
         usuário.
    */
        dividendoTemp = dividendo;
        divisorTemp = divisor;

    /*
        Esse laço é usado para calcular quantas colunas serão necessárias para formar
         a matriz que armazenará os valores obtidos no algoritmo, o número de colunas
         será armazenado em "contador".
        A ideia é simular as sucessivas operações até que o resto da divisão seja 0 e
         ir incrementando a variável "contador" para cada nova operação, permitindo
         saber quantas colunas serão necessárias para a matriz ao atingir um resto 0.
    */
        while((dividendoTemp % divisorTemp) != 0) {
            contador++;
            temp = divisorTemp;
            divisorTemp = dividendoTemp % divisorTemp;
            dividendoTemp = temp;
        }

    /*
        O número de linhas é uma constante LINHAS por que é a quantidade necessária no
         Algoritmo de Euclides. A coluna é variável por que depende de quantos cálculos
         serão necessários até se encontrar o resultado esperado.
    */
        int matriz[LINHAS][contador];

    /*
        Os valores são atribuídos às variáveis temporárias novamente para iniciar de fato
          os sucessivos cálculos do algoritmo.
    */
        dividendoTemp = dividendo;
        divisorTemp = divisor;

    /*
        Esse laço é usado para zerar todas as posições da matriz, pois alguns endereço
         podem armazenar lixo, alterando algum resultado esperado nas posições matriz[0][0]
         e matriz[N][N] (sendo N o valor máximo usado na conta).
    */
        for (x = 0; x < LINHAS; x++) {
            for (y = 0; y < contador; y++) {
                matriz[x][y] = 0;
            }
        }

    /*
        Nesse laço os valores são calculados e armazenados na matriz em suas respectivas
         posições.
    */
        for (x = 0; x < (contador - 1); x++) {
            divInt = dividendoTemp / divisorTemp;
            matriz[0][x+1] = divInt;
            matriz[1][x] = dividendoTemp;
            temp = divisorTemp;
            divisorTemp = dividendoTemp % divisorTemp;
            matriz[2][x] = divisorTemp;
            dividendoTemp = temp;
            matriz[1][x+1] = dividendoTemp;
        }

        printf("\n\t");

    // Imprime linhas usadas para formar uma tabela.
        for (z = 0; z < contador; z++) {
            printf("----------------");
        }

        printf("\n\t");

    // Nesse laço os valores calculados são exibidos em tela.
        for (x = 0; x < LINHAS; x++) {
            for (y = 0; y < contador; y++) {
                if (((x == 0) && (y == 0)) || (((x + 1) == LINHAS) && ((y + 1) == contador))) {
                    printf("|\t\t");
                } else {
                    printf("|\t%d\t", matriz[x][y]);
                }
                if ((y + 1) == contador) {
                    printf("|");
                }
            }

            printf("\n\n\t");

            for (z = 0; z < contador; z++) {
            // Imprime linhas usadas para formar uma tabela.
                printf("----------------");
            }

            printf("\n\t");
        }

    // O MDC é igual ao último valor calculado em "dividendoTemp"
      printf("\n\tO MDC entre %d e %d é %d!\n\n", dividendo, divisor, dividendoTemp);

    /*
        Se o último valor encontrado for o número 1, quer dizer que os números são
         primos entre si.
    */
        if (dividendoTemp == 1) {
            printf("\n\tPortanto, os números %d e %d são primos entre si!\n\n", dividendo, divisor);
            system("color 4C");
        } else {
            printf("\n\tPortanto, os númeos %d e %d não são primos entre si!\n\n", dividendo, divisor);
            system("color 2A");
        }

        printf("\n  Deseja continuar? (Pressione C e confirme): ");
    // Recebe a opção que o usuário deseja.
        scanf("%s", &opcao);

// Repete enquanto o usuário informar "C" ou "c".
    } while((opcao == 'c') || (opcao == 'C'));

    return 0;
}