Teoria dos conjuntos (Projeto Interdisciplinar)

O primeiro projeto interdisciplinar deste semestre (2º), foi um programa em C que classificava conjuntos entre simétrica, assimétrica, transitiva, reflexiva, de ordem e/ou de equivalência.
Abaixo está o executável (arquivo .exe para Windows) e o código fonte.

	#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;
	}

view raw teoriadosconjuntos.c hosted with ❤ by GitHub