From cec1d71d172569097b4f8bdcebfe9d42661be2d7 Mon Sep 17 00:00:00 2001 From: hcb13 Date: Mon, 27 Jan 2014 01:20:01 -0200 Subject: [PATCH] =?UTF-8?q?Adicionando=20propriedades=20e=20mais=204=20rel?= =?UTF-8?q?a=C3=A7=C3=B5es?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Adicionando propriedades e mais 4 relações, verificação da relação 3 que não era transitiva --- main.c | 8 +- propriedades.h | 101 ++++++++--- relacoes.h | 478 ++++++++++++++++++++++++++++++++++++++++++++----- 3 files changed, 516 insertions(+), 71 deletions(-) diff --git a/main.c b/main.c index e2b90ad..74880f0 100644 --- a/main.c +++ b/main.c @@ -23,7 +23,7 @@ int main(){ //Menu de opções [por @fonzaex] - int opcao; + int opcao = 1; while(opcao>=1){ printf("\n=======================================================\n"); @@ -49,6 +49,10 @@ int main(){ relacao_01(); relacao_02(); relacao_03(); + relacao_04(); + relacao_05(); + relacao_06(); + relacao_07(); break; default: opcao=-5; @@ -58,7 +62,7 @@ int main(){ printf("=======================================================\n"); break; } - } + }; return 0; } diff --git a/propriedades.h b/propriedades.h index 3a6877c..edfd38c 100644 --- a/propriedades.h +++ b/propriedades.h @@ -1,33 +1,88 @@ #ifndef _PROPRIEDADES_H #define _PROPRIEDADES_H -//Função ehReflexiva [por @fonzaex] -//[Adaptada por @bispojr] -int ehReflexiva(int rho2[][2]); -int ehReflexiva(int rho2[][2]){ // funcao para verificar se eh reflexiva, return 0 = falso, return 1 = verdade. - - //AINDA FALTA PASSAR O VALOR DO CONJS POR REFERENCIA E VERIFICAR SE TODO X PERTENCE AO COJUNTO S; - //MOSTRANDO OS SUBCONJUNTOS, EM FORMA DE MATRIZ - - //UNICA LOGICA QUE ACHEI FOI ESSA, DEVE-SE IMPLEMENTAR EM CIMA NOS LAÇOS FOR - if(rho2[0][0]==rho2[0][1] && rho2[1][0]==rho2[1][1] && rho2[2][0]==rho2[2][1]){ - return 1; - } - else{ - return 0; - } +//@hcb13 +int ehReflexiva(int conjS[], int tam_conj, int rho[][2], int qtd_pares ){ + int i;//percorrer o conjunto + int j;//percorrer rho + int c;//simular os pares + for( i = 0; i < tam_conj; i++ ){ + c = conjS[i]; + for( j = 0; j < qtd_pares; j++){ + if( (rho[j][0] == c ) && ( rho[j][1] == c ) ){ + break;//axou um par reflexivo + } + } + if( j == qtd_pares ){ + return 0;//nao encontrou par reflexivo + } + } + return 1;//eh reflexiva a relacao } -int ehSimetrica(){ // funcao para verificar se eh simetrica, return 0 = falso, return 1 = verdade. - return 1; + +int ehSimetrica(int conjS[], int rho[][2], int qtd_pares ){ + int i, j, x, y; + for( i = 0; i < qtd_pares; i++ ){ + x = rho[i][0]; + y = rho[i][1]; + for( j = 0; j < qtd_pares; j++ ){ + if( ( x == rho[j][1] ) && ( y == rho[j][0] ) ){ + break;//axou o par simetrico + } + } + if( j == qtd_pares ){ + return 0;//nao axou par simetrico a x e y + } + } + return 1; } -int ehTransitiva(){ // funcao para verificar se eh transitiva, return 0 = falso, return 1 = verdade. - return 0; + +int ehTransitiva( int conjS[], int rho[][2], int qtd_pares){ + int i, j, p, x1, y1, y2, z2; + for( i = 0; i < qtd_pares; i++){ + x1 = rho[i][0]; + y1 = rho[i][1]; + for( j = 0; j < qtd_pares; j++ ){ + y2 = rho[j][0]; + if( y1 == y2 ){ + z2 = rho[j][1]; + for( p = 0; p < qtd_pares; p++ ){ + if( ( x1 == rho[p][0] ) && ( z2 == rho[p][1] ) ){ + break;//encontrou par transitivo + } + } + if( p == qtd_pares ){ + return 0;//nao encontrou + } + } + } + } + return 1;//eh transitiva } -int ehAntiSimetrica(){ // funcao para verificar se eh anti-simetrica, return 0 = falso, return 1 = verdade. - return 1; + +int ehAntiSimetrica( int conjS[], int rho[][2], int qtd_pares){ + int i, j, x, y; + for( i = 0; i < qtd_pares; i++ ){ + x = rho[i][0]; + y = rho[i][1]; + for( j = 0; j < qtd_pares; j++ ){ + if( ( x == rho[j][1] ) && ( y == rho[j][0] ) ){ + if( x == y ){ + break;//encontrou o par anti-simétrico + }else{ + return 0; + } + } + } + } + return 1; + } -int ehEquivalencia(){ // funcao para verificar se eh anti-simetrica, return 0 = falso, return 1 = verdade. - return 0; + +int ehEquivalencia(int conjS[], int tam_conj, int rho[][2], int qtd_pares){ + if( (ehReflexiva(conjS, tam_conj, rho, qtd_pares) ) && ( ehSimetrica(conjS, rho, qtd_pares) ) && ( ehTransitiva(conjS, rho, qtd_pares) ) ){ + return 1; + } } #endif diff --git a/relacoes.h b/relacoes.h index f33a093..571eb96 100644 --- a/relacoes.h +++ b/relacoes.h @@ -17,21 +17,58 @@ void relacao_01(){ printf("\n"); - if(ehReflexiva(rho) != reflexiva){ - printf("ERRO: [%s] - Problema na propriedade reflexiva!\n", nome); - } - if(ehSimetrica() != simetrica){ - printf("ERRO: [%s] - Problema na propriedade simetrica!\n", nome); - } - if(ehTransitiva() != transitiva){ - printf("ERRO: [%s] - Problema na propriedade transitiva!\n", nome); - } - if(ehAntiSimetrica() != anti_simetrica){ - printf("ERRO: [%s] - Problema na propriedade anti-simetrica!\n", nome); - } - if(ehEquivalencia() != equivalencia){ - printf("ERRO: [%s] - Problema na verifiacao da equivalencia!\n", nome); - } + if(ehReflexiva( conjS, 3, rho, 3) != reflexiva){ + printf("ERRO: [%s] - Problema na propriedade reflexiva!\n", nome); + }else{ + printf("Sucesso: [%s] Bate com a propriedade reflexiva!\n", nome ); + } + if(ehSimetrica(conjS, rho, 3) != simetrica){ + printf("ERRO: [%s] - Problema na propriedade simetrica!\n", nome); + }else{ + printf("Sucesso: [%s] Bate com a propriedade simetrica!\n", nome ); + } + if(ehTransitiva(conjS, rho, 3) != transitiva){ + printf("ERRO: [%s] - Problema na propriedade transitiva!\n", nome); + }else{ + printf("Sucesso: [%s] Bate com a propriedade transitiva!\n", nome ); + } + if(ehAntiSimetrica(conjS, rho, 3) != anti_simetrica){ + printf("ERRO: [%s] - Problema na propriedade anti-simetrica!\n", nome); + }else{ + printf("Sucesso: [%s] Bate com a propriedade anti-simetrica!\n", nome ); + } + if(ehEquivalencia(conjS, 3, rho, 3) != equivalencia){ + printf("ERRO: [%s] - Problema na verifiacao da equivalencia!\n", nome); + }else{ + printf("Sucesso: [%s] Bate com a propriedade de equivalencia!\n", nome ); + } + + printf("\nLogo, a relacao %s\n", nome); + if( reflexiva ){ + printf("\teh reflexiva\n"); + }else{ + printf("\tnao eh reflexiva\n"); + } + if( transitiva ){ + printf("\teh transtiva\n"); + }else{ + printf("\tnao eh transtiva\n"); + } + if( simetrica ){ + printf("\teh simetrica\n"); + }else{ + printf("\tnao eh simetrica\n"); + } + if( anti_simetrica ){ + printf("\teh anti-simetrica\n"); + }else{ + printf("\tnao eh anti-simetrica\n"); + } + if( equivalencia ){ + printf("\teh equivalente\n"); + }else{ + printf("\tnao eh equivalente\n"); + } } //Relação 02 [por @bispojr] @@ -49,21 +86,58 @@ void relacao_02(){ printf("\n"); - if(ehReflexiva(rho) != reflexiva){ - printf("ERRO: [%s] - Problema na propriedade reflexiva!\n", nome); - } - if(ehSimetrica() != simetrica){ - printf("ERRO: [%s] - Problema na propriedade simetrica!\n", nome); - } - if(ehTransitiva() != transitiva){ - printf("ERRO: [%s] - Problema na propriedade transitiva!\n", nome); - } - if(ehAntiSimetrica() != anti_simetrica){ - printf("ERRO: [%s] - Problema na propriedade anti-simetrica!\n", nome); - } - if(ehEquivalencia() != equivalencia){ - printf("ERRO: [%s] - Problema na verifiacao da equivalencia!\n", nome); - } + if(ehReflexiva( conjS, 3, rho, 5) != reflexiva){ + printf("ERRO: [%s] - Problema na propriedade reflexiva!\n", nome); + }else{ + printf("Sucesso: [%s] Bate com a propriedade reflexiva!\n", nome ); + } + if(ehSimetrica(conjS, rho, 5) != simetrica){ + printf("ERRO: [%s] - Problema na propriedade simetrica!\n", nome); + }else{ + printf("Sucesso: [%s] Bate com a propriedade simetrica!\n", nome ); + } + if(ehTransitiva(conjS, rho, 5) != transitiva){ + printf("ERRO: [%s] - Problema na propriedade transitiva!\n", nome); + }else{ + printf("Sucesso: [%s] Bate com a propriedade transitiva!\n", nome ); + } + if(ehAntiSimetrica(conjS, rho, 5) != anti_simetrica){ + printf("ERRO: [%s] - Problema na propriedade anti-simetrica!\n", nome); + }else{ + printf("Sucesso: [%s] Bate com a propriedade anti-simetrica!\n", nome ); + } + if(ehEquivalencia(conjS, 3, rho, 5) != equivalencia){ + printf("ERRO: [%s] - Problema na verifiacao da equivalencia!\n", nome); + }else{ + printf("Sucesso: [%s] Bate com a propriedade de equivalencia!\n", nome ); + } + + printf("\nLogo, a relacao %s\n", nome); + if( reflexiva ){ + printf("\teh reflexiva\n"); + }else{ + printf("\tnao eh reflexiva\n"); + } + if( transitiva ){ + printf("\teh transtiva\n"); + }else{ + printf("\tnao eh transtiva\n"); + } + if( simetrica ){ + printf("\teh simetrica\n"); + }else{ + printf("\tnao eh simetrica\n"); + } + if( anti_simetrica ){ + printf("\teh anti-simetrica\n"); + }else{ + printf("\tnao eh anti-simetrica\n"); + } + if( equivalencia ){ + printf("\teh equivalente\n"); + }else{ + printf("\tnao eh equivalente\n"); + } } //Relação 03 [por @bispojr] @@ -75,27 +149,339 @@ void relacao_03(){ int reflexiva = 0; //Valor 0: Relação NÃO é reflexiva int simetrica = 1; //Valor 1: Relação É simétrica - int transitiva = 1; //Valor 1: Relação É transitiva + // int transitiva = 1; //Valor 1: Relação É transitiva + int transitiva = 0; //essa relação não eh transitiva pois não há par (2,1) int anti_simetrica = 0; //Valor 0: Relação NÃO É anti-simétrica int equivalencia = 0; //Valor 0: Relação NÃO é uma equivalência printf("\n"); - if(ehReflexiva(rho) != reflexiva){ - printf("ERRO: [%s] - Problema na propriedade reflexiva!\n", nome); - } - if(ehSimetrica() != simetrica){ - printf("ERRO: [%s] - Problema na propriedade simetrica!\n", nome); - } - if(ehTransitiva() != transitiva){ - printf("ERRO: [%s] - Problema na propriedade transitiva!\n", nome); - } - if(ehAntiSimetrica() != anti_simetrica){ - printf("ERRO: [%s] - Problema na propriedade anti-simetrica!\n", nome); - } - if(ehEquivalencia() != equivalencia){ - printf("ERRO: [%s] - Problema na verifiacao da equivalencia!\n", nome); - } + if(ehReflexiva( conjS, 3, rho, 6) != reflexiva){ + printf("ERRO: [%s] - Problema na propriedade reflexiva!\n", nome); + }else{ + printf("Sucesso: [%s] Bate com a propriedade reflexiva!\n", nome ); + } + if(ehSimetrica(conjS, rho, 6) != simetrica){ + printf("ERRO: [%s] - Problema na propriedade simetrica!\n", nome); + }else{ + printf("Sucesso: [%s] Bate com a propriedade simetrica!\n", nome ); + } + if(ehTransitiva(conjS, rho, 6) != transitiva){ + printf("ERRO: [%s] - Problema na propriedade transitiva!\n", nome); + }else{ + printf("Sucesso: [%s] Bate com a propriedade transitiva!\n", nome ); + } + if(ehAntiSimetrica(conjS, rho, 6) != anti_simetrica){ + printf("ERRO: [%s] - Problema na propriedade anti-simetrica!\n", nome); + }else{ + printf("Sucesso: [%s] Bate com a propriedade anti-simetrica!\n", nome ); + } + if(ehEquivalencia(conjS, 3, rho, 6) != equivalencia){ + printf("ERRO: [%s] - Problema na verifiacao da equivalencia!\n", nome); + }else{ + printf("Sucesso: [%s] Bate com a propriedade de equivalencia!\n", nome ); + } + + printf("\nLogo, a relacao %s\n", nome); + if( reflexiva ){ + printf("\teh reflexiva\n"); + }else{ + printf("\tnao eh reflexiva\n"); + } + if( transitiva ){ + printf("\teh transtiva\n"); + }else{ + printf("\tnao eh transtiva\n"); + } + if( simetrica ){ + printf("\teh simetrica\n"); + }else{ + printf("\tnao eh simetrica\n"); + } + if( anti_simetrica ){ + printf("\teh anti-simetrica\n"); + }else{ + printf("\tnao eh anti-simetrica\n"); + } + if( equivalencia ){ + printf("\teh equivalente\n"); + }else{ + printf("\tnao eh equivalente\n"); + } +} + +void relacao_04(){ + + char nome[4] = "R04"; + int conjS[3] = {1,2,3}; + int rho[3][2] = { {1,2}, {3,2}, {1,1} }; + + int reflexiva = 0; + int simetrica = 0; + int transitiva = 1; + int anti_simetrica = 1; + int equivalencia = 0; + + printf("\n"); + + if(ehReflexiva( conjS, 3, rho, 3) != reflexiva){ + printf("ERRO: [%s] - Problema na propriedade reflexiva!\n", nome); + }else{ + printf("Sucesso: [%s] Bate com a propriedade reflexiva!\n", nome ); + } + if(ehSimetrica(conjS, rho, 3) != simetrica){ + printf("ERRO: [%s] - Problema na propriedade simetrica!\n", nome); + }else{ + printf("Sucesso: [%s] Bate com a propriedade simetrica!\n", nome ); + } + if(ehTransitiva(conjS, rho, 3) != transitiva){ + printf("ERRO: [%s] - Problema na propriedade transitiva!\n", nome); + }else{ + printf("Sucesso: [%s] Bate com a propriedade transitiva!\n", nome ); + } + if(ehAntiSimetrica(conjS, rho, 3) != anti_simetrica){ + printf("ERRO: [%s] - Problema na propriedade anti-simetrica!\n", nome); + }else{ + printf("Sucesso: [%s] Bate com a propriedade anti-simetrica!\n", nome ); + } + if(ehEquivalencia(conjS, 3, rho, 3) != equivalencia){ + printf("ERRO: [%s] - Problema na verifiacao da equivalencia!\n", nome); + }else{ + printf("Sucesso: [%s] Bate com a propriedade de equivalencia!\n", nome ); + } + + printf("\nLogo, a relacao %s\n", nome); + if( reflexiva ){ + printf("\teh reflexiva\n"); + }else{ + printf("\tnao eh reflexiva\n"); + } + if( transitiva ){ + printf("\teh transtiva\n"); + }else{ + printf("\tnao eh transtiva\n"); + } + if( simetrica ){ + printf("\teh simetrica\n"); + }else{ + printf("\tnao eh simetrica\n"); + } + if( anti_simetrica ){ + printf("\teh anti-simetrica\n"); + }else{ + printf("\tnao eh anti-simetrica\n"); + } + if( equivalencia ){ + printf("\teh equivalente\n"); + }else{ + printf("\tnao eh equivalente\n"); + } +} + +void relacao_05(){ + char nome[4] = "R05"; + int conjS[5] = {1,2}; + int rho[10][2] = { {2,1}, {1,2}, {2,2}, {1,1} }; + + int reflexiva = 1; + int simetrica = 1; + int transitiva = 1; + int anti_simetrica = 0; + int equivalencia = 1; + + printf("\n"); + + if(ehReflexiva( conjS, 5, rho, 10) != reflexiva){ + printf("ERRO: [%s] - Problema na propriedade reflexiva!\n", nome); + }else{ + printf("Sucesso: [%s] Bate com a propriedade reflexiva!\n", nome ); + } + if(ehSimetrica(conjS, rho, 10) != simetrica){ + printf("ERRO: [%s] - Problema na propriedade simetrica!\n", nome); + }else{ + printf("Sucesso: [%s] Bate com a propriedade simetrica!\n", nome ); + } + if(ehTransitiva(conjS, rho, 10) != transitiva){ + printf("ERRO: [%s] - Problema na propriedade transitiva!\n", nome); + }else{ + printf("Sucesso: [%s] Bate com a propriedade transitiva!\n", nome ); + } + if(ehAntiSimetrica(conjS, rho, 10) != anti_simetrica){ + printf("ERRO: [%s] - Problema na propriedade anti-simetrica!\n", nome); + }else{ + printf("Sucesso: [%s] Bate com a propriedade anti-simetrica!\n", nome ); + } + if(ehEquivalencia(conjS, 5, rho, 10) != equivalencia){ + printf("ERRO: [%s] - Problema na verifiacao da equivalencia!\n", nome); + }else{ + printf("Sucesso: [%s] Bate com a propriedade de equivalencia!\n", nome ); + } + + printf("\nLogo, a relacao %s\n", nome); + if( reflexiva ){ + printf("\teh reflexiva\n"); + }else{ + printf("\tnao eh reflexiva\n"); + } + if( transitiva ){ + printf("\teh transtiva\n"); + }else{ + printf("\tnao eh transtiva\n"); + } + if( simetrica ){ + printf("\teh simetrica\n"); + }else{ + printf("\tnao eh simetrica\n"); + } + if( anti_simetrica ){ + printf("\teh anti-simetrica\n"); + }else{ + printf("\tnao eh anti-simetrica\n"); + } + if( equivalencia ){ + printf("\teh equivalente\n"); + }else{ + printf("\tnao eh equivalente\n"); + } +} + +void relacao_06(){ + + char nome[4] = "R06"; + int conjS[3] = {1,2,3}; + int rho[2][2] = { {1,2}, {3,2} }; + + int reflexiva = 0; + int simetrica = 0; + int transitiva = 1; + int anti_simetrica = 1; + int equivalencia = 0; + + printf("\n"); + + if(ehReflexiva( conjS, 3, rho, 2) != reflexiva){ + printf("ERRO: [%s] - Problema na propriedade reflexiva!\n", nome); + }else{ + printf("Sucesso: [%s] Bate com a propriedade reflexiva!\n", nome ); + } + if(ehSimetrica(conjS, rho, 2) != simetrica){ + printf("ERRO: [%s] - Problema na propriedade simetrica!\n", nome); + }else{ + printf("Sucesso: [%s] Bate com a propriedade simetrica!\n", nome ); + } + if(ehTransitiva(conjS, rho, 2) != transitiva){ + printf("ERRO: [%s] - Problema na propriedade transitiva!\n", nome); + }else{ + printf("Sucesso: [%s] Bate com a propriedade transitiva!\n", nome ); + } + if(ehAntiSimetrica(conjS, rho, 2) != anti_simetrica){ + printf("ERRO: [%s] - Problema na propriedade anti-simetrica!\n", nome); + }else{ + printf("Sucesso: [%s] Bate com a propriedade anti-simetrica!\n", nome ); + } + if(ehEquivalencia(conjS, 3, rho, 2) != equivalencia){ + printf("ERRO: [%s] - Problema na verifiacao da equivalencia!\n", nome); + }else{ + printf("Sucesso: [%s] Bate com a propriedade de equivalencia!\n", nome ); + } + + printf("\nLogo, a relacao %s\n", nome); + if( reflexiva ){ + printf("\teh reflexiva\n"); + }else{ + printf("\tnao eh reflexiva\n"); + } + if( transitiva ){ + printf("\teh transtiva\n"); + }else{ + printf("\tnao eh transtiva\n"); + } + if( simetrica ){ + printf("\teh simetrica\n"); + }else{ + printf("\tnao eh simetrica\n"); + } + if( anti_simetrica ){ + printf("\teh anti-simetrica\n"); + }else{ + printf("\tnao eh anti-simetrica\n"); + } + if( equivalencia ){ + printf("\teh equivalente\n"); + }else{ + printf("\tnao eh equivalente\n"); + } +} + + +void relacao_07(){ + + + char nome[4] = "R07"; + int conjS[3] = {5,4,6}; + int rho[9][2] = { {6,4},{4,6}, {6,6}, {4,5},{6,5},{4,4}, {5,4}, {5,6}, {5,5} }; + + int reflexiva = 1; + int simetrica = 1; + int transitiva = 1; + int anti_simetrica = 0; + int equivalencia = 1; + + printf("\n"); + + if(ehReflexiva( conjS, 3, rho, 9) != reflexiva){ + printf("ERRO: [%s] - Problema na propriedade reflexiva!\n", nome); + }else{ + printf("Sucesso: [%s] Bate com a propriedade reflexiva!\n", nome ); + } + if(ehSimetrica(conjS, rho, 9) != simetrica){ + printf("ERRO: [%s] - Problema na propriedade simetrica!\n", nome); + }else{ + printf("Sucesso: [%s] Bate com a propriedade simetrica!\n", nome ); + } + if(ehTransitiva(conjS, rho, 9) != transitiva){ + printf("ERRO: [%s] - Problema na propriedade transitiva!\n", nome); + }else{ + printf("Sucesso: [%s] Bate com a propriedade transitiva!\n", nome ); + } + if(ehAntiSimetrica(conjS, rho, 9) != anti_simetrica){ + printf("ERRO: [%s] - Problema na propriedade anti-simetrica!\n", nome); + }else{ + printf("Sucesso: [%s] Bate com a propriedade anti-simetrica!\n", nome ); + } + if(ehEquivalencia(conjS, 3, rho, 9) != equivalencia){ + printf("ERRO: [%s] - Problema na verifiacao da equivalencia!\n", nome); + }else{ + printf("Sucesso: [%s] Bate com a propriedade de equivalencia!\n", nome ); + } + + printf("\nLogo, a relacao %s\n", nome); + if( reflexiva ){ + printf("\teh reflexiva\n"); + }else{ + printf("\tnao eh reflexiva\n"); + } + if( transitiva ){ + printf("\teh transtiva\n"); + }else{ + printf("\tnao eh transtiva\n"); + } + if( simetrica ){ + printf("\teh simetrica\n"); + }else{ + printf("\tnao eh simetrica\n"); + } + if( anti_simetrica ){ + printf("\teh anti-simetrica\n"); + }else{ + printf("\tnao eh anti-simetrica\n"); + } + if( equivalencia ){ + printf("\teh equivalente\n"); + }else{ + printf("\tnao eh equivalente\n"); + } } + #endif