Projeto Interdisciplinar - Matemática Discreta e Grafos, Programação de Computadores

teoriadosconjuntos.c

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

/*
Projeto Interdisciplinar - Matemática Discreta e Grafos, Programação de Computadores
09/2017

Alunos @ Eng. de Computacao:
					Eduardo Rodrigues Pereira RA: 002.2017.xxxxx
					Joao Marcos Santos        RA: 002.2017.xxxxx
					Renner Belo de Souza      RA: 002.2017.xxxxx
							
*/

void imprimeConjA(char *A, int tam_A){
	//função que imprime o conjunto A
    int i;
    printf("\n-----------Conjunto A-----------\n");
    
    for(i=0;i<tam_A;i++){
        printf("(%c)\n",A[i]);     
	}
}

void imprimeConjR(char **R, int tam_R){
    //função que imprime o conjunto R
    int i;
    
    printf("-----------Relação  R-----------\n");
    
    for(i=0;i<tam_R;i++){
        printf("(%c,%c)\n",R[i][0],R[i][1]);
    }

}
 /*--------------------------------------SIMETRICA-------------------------------*/
int simetrica(char *A, int tam_A, char **R, int tam_R){ 
    /*Função utilizada para averiguar a existencia de simetria entre 
    os pares do conjunto.Ex: (a,b) e (b,a) */
	
    int i, j, temp = 0;
    //Verificação para ver se é simetrica
    
    for(i = 0; i < tam_R; i++){
        if(R[i][0] != R[i][1]){
            temp=2;
            for(j = 0; j < tam_R; j++){
                if((R[i][0] == R[j][1]) && (R[i][1] == R[j][0])){
                    temp = 1;
                    break;
                }
            }
            if(temp == 2)
            	break;
        }
    }  
    
	if(temp<2){
     	//É simetrica
        return 1;
	}
	
        return 0;
}

 /*--------------------------------------ASSIMETRICA--------------------------------------*/
int assimetrica(char *A, int tam_A, char **R, int tam_R){
    /*Função utilizada  */
    int i, j, temp = 2;
    
    //Verificação para ver se é assimetrica.
    for(i = 0; i < tam_R; i++){
        if(R[i][0] != R[i][1]){
            temp=1;
            
            for(j = 0; j < tam_R; j++){
                if(R[i][0] == R[j][1] && R[i][1] == R[j][0]){
                    temp = 2;
                    break;
                }
            }
            if(temp == 2)
                break;
        }
           
        if(temp<2){
          	//É assimetrica
            return 1;
      	}
    }
    return 0;
}

/*--------------------------------------TRANSITIVA--------------------------------------*/           
int transitiva(char *A, int tam_A, char **R, int tam_R){
    int i, j, k, temp = 0;
    
    for(i = 0; i < tam_R; i++)
    {
        if(R[i][0] != R[i][1])
        {
            for(j = 0; j < tam_R; j++)
            {
                if(R[i][1] == R[j][0] && R[j][1] != R[i][0]) // achou 2 elementos
                {
                    for(k = 0; k< tam_R; k++)
                    {
                        if(R[i][0] == R[k][0] && R[j][1] == R[k][1]) // achou 3 elementos
                        {
                        temp = 2;
                        break;
                        }
                     if(j== tam_R-1)
                        {return 0;} // não é transitiva
                    }
                }
            }
        }
    if(i==tam_R-1)
     //   printf("\nTransitiva");
        return 1;
    }
    return 0;
}

/*--------------------------------------REFLEXIVA--------------------------------------*/             
int reflexiva(char *A, int tam_A, char **R, int tam_R){
    //Verificação para ver se é reflexiva.
    int i,j,temp = 0; 
           
    for(i=0; i<tam_A; i++){   
        for(j=0; j<tam_R; j++){   
            if(A[i] == R[j][0] && A[i] == R[j][1]){           
                temp++;
                break;
            }
        }
    }
        
    if(temp == tam_A){
      	// É reflexiva   
        return 1;
	}
	
	
    return 0;
}

/*----------------------------------FUNCAO DE ORDEM ----------------------------------*/
 int ordem(char *A, int tam_A, char **R, int tam_R)   {               
   //Relação de Ordem: Reflexiva, assimétrica e transitiva
    int vOrdem;            
                
    vOrdem = assimetrica(A, tam_A,R, tam_R);
    if(vOrdem == 0){
        return 0;
    }
                         
    vOrdem = reflexiva(A, tam_A,R, tam_R);
    if(vOrdem == 0){
        return 0;
    }
    
    vOrdem = transitiva(A, tam_A,R, tam_R);
    if(vOrdem == 0){
        return 0;
    }                 
 
    return 1;
}
                 
/*----------------------FUNCAO DE EQUIVALENCIA -----------------------*/

 int equivalencia(char *A, int tam_A, char **R, int tam_R)   {             
 	//Relação de Equivalência: Reflexiva, simétrica e transitiva
    int vEquivalencia;            
                
    vEquivalencia = simetrica(A, tam_A,R, tam_R);
    if(vEquivalencia == 0){
        return 0;
    }
                         
    vEquivalencia = reflexiva(A, tam_A,R, tam_R);
    if(vEquivalencia == 0){
        return 0;
    }

	vEquivalencia = transitiva(A, tam_A,R, tam_R);
    if(vEquivalencia == 0){
        return 0;
    }

    return 1;
}    

/*--------------------FUNCAO PRINCIPAL--------------------*/                   
int main(){	
    
    char *A,**R;  
    int i,j,k; 
    int aux,tam_A,tam_R;
    
    setlocale(LC_ALL, "Portuguese");
 
    printf("Digite a quantidade de elementos do conjunto A:  ");
    scanf("%i", &tam_A);
    
    //Alocação de memoria do vetor A 
    A = (char*)malloc(tam_A * sizeof(char));
    
    for(i = 0; i < tam_A; i++){ 
        printf("Digite o %io elemento:  ",i+1);
        //fflush usado para limpar o buffer e evitar erros.
        fflush(stdin);
        scanf("%c", &A[i]);
           
        for(j=0;j<i;j++){
       		if(A[i]==A[j]){
       			while(A[i]==A[j]){
       				printf("%io elemento duplicado.Digite novamente: ",i+1);
       				fflush(stdin);
                	scanf("%c",&A[i]);
			   }
		   }
	   }
    }
    
    printf("\nDigite a quantidade de pares do conjunto relação R: ");
    scanf("%i", &tam_R);
    while (tam_R > (tam_A * tam_A)){
        printf("Erro! A quantidade de pares deve ser menor que o " 
               "quadrado do número de elementos. Digite novamente:  ");
        scanf("%i", &tam_R);
    }
           
    //Alocação de memoria da matriz R
    R = (char **) malloc(tam_R*sizeof (char*));
    
    for(i = 0;i < tam_R;i++){
        R[i] = (char **) malloc (2*sizeof (char*));
        for(j=0; j<2; j++){
            printf("Digite o %io elemento do %io do par ordenado: ",j+1,i+1);
            fflush(stdin);
            scanf("%c",&R[i][j]);
        }
        
        for(k=0; k<i; k++){
            //resposta para valor repetido
            if(R[i][0] == R[k][0] && R[i][1] == R[k][1]){
                while(R[i][0] == R[k][0] && R[i][1] == R[k][1]){
                    printf("Duplicado, digite o 1o elemento do %io par novamente:  ",i+1);
                    fflush(stdin);
                    scanf("%c", & R[i][0]);
                           
                    printf("Duplicado, digite o 2o elemento do %io par novamente:  ",i+1);
                    fflush(stdin);
                    scanf("%c", & R[i][1]);
                }
            }
        }
    
    }
            
   	//Chamando as funções
       imprimeConjA(A, tam_A);
       imprimeConjR(R, tam_R);
       printf("--------------------------------");
       
    if((simetrica(A, tam_A,R, tam_R)) == 1){
        printf("\nEssa é uma relação simétrica.");
    }
     
    if((assimetrica(A, tam_A, R, tam_R)) == 1){
        printf("\nEssa é uma relação assimétrica.");
    }   
    
    if((transitiva(A, tam_A, R, tam_R)) == 1){
        printf("\nEssa é uma relação transitiva.");
    }
    
    if((reflexiva(A, tam_A, R, tam_R)) == 1){
        printf("\nEssa é uma relação reflexiva.");
    }
    
    if((ordem(A, tam_A, R, tam_R)) == 1){
        printf("\nEssa é uma relação de ordem.");
    }
    
    if((equivalencia(A, tam_A, R, tam_R)) == 1){
        printf("\nEssa é uma relação de equivalência.");
    }
    
   //liberação da memoria
    free(A);
    A = NULL;
    
    free(R);
    R = NULL;
    
    return 0;
}