Lab2 - Versão Final

/**
 * @author Lucas Pereira Torres de Araújo, 384364
 * Universidade Federal do Ceará - Tecnicas de Programacao I, 2017.1
 */

public class Lab2 {

    public static void main(String[] args) {

      //Dez primeiros numeros naturais
      Conjunto n1 = new Conjunto(10);
      n1.inserirValor(0);
      n1.inserirValor(1);
      n1.inserirValor(2);
      n1.inserirValor(3);
      n1.inserirValor(4);
      n1.inserirValor(5);
      n1.inserirValor(6);
      n1.inserirValor(7);
      n1.inserirValor(8);
      n1.inserirValor(9);

      //Cinco primeiros numeros pares
      Conjunto n2 = new Conjunto(5);
      n2.inserirValor(2);
      n2.inserirValor(4);
      n2.inserirValor(6);
      n2.inserirValor(8);
      n2.inserirValor(10);

      //Cinco primeiros numeros impares
      Conjunto n3 = new Conjunto(5);
      n3.inserirValor(1);
      n3.inserirValor(3);
      n3.inserirValor(5);
      n3.inserirValor(7);
      n3.inserirValor(9);

      //Dez primeiros numeros primos
      Conjunto n4 = new Conjunto(10);
      n4.inserirValor(2);
      n4.inserirValor(3);
      n4.inserirValor(5);
      n4.inserirValor(7);
      n4.inserirValor(11);
      n4.inserirValor(13);
      n4.inserirValor(17);
      n4.inserirValor(19);
      n4.inserirValor(23);
      n4.inserirValor(29);

      Conjunto p1 = new Conjunto(3);
      p1.inserirValor(1);
      p1.inserirValor(2);
      p1.inserirValor(3);
      Conjunto p2 = new Conjunto(3);
      p2.inserirValor(4);
      p2.inserirValor(5);
      p2.inserirValor(6);

      //Imprimo os conjuntos
      System.out.println("Conjunto 1:"); n1.imprimirVetor();
      System.out.println("Conjunto 2:"); n2.imprimirVetor();
      System.out.println("Conjunto 3:"); n3.imprimirVetor();
      System.out.println("Conjunto 4:"); n4.imprimirVetor();

      System.out.println("\n--------------- ITEM A ---------------");
        //Se o conjunto 4 E subconjunto de si mesmo
        switch (n4.verificarSubconjunto(n4)) {
            case 1:
                System.out.println ("E subconjunto de si mesmo.");
                break;
            case 0:
                System.out.println ("Nao e subconjunto de si mesmo.");
                break;
            default:
                System.out.println ("O subconjunto e maior que o conjunto comparado.");
                break;
        }

      System.out.println("\n--------------- ITEM B ---------------");
      //A pertinencia dos conjuntos 2, 3 e 4 no conjunto 1
      System.out.println("-------------- ITEM B.1 --------------");
      System.out.println ("A pertinencia do conjunto 2 no conjunto 1:");
        switch (n1.verificarSubconjunto(n2)) {
            case 1:
                System.out.println ("E subconjunto.");
                break;
            case 0:
                System.out.println ("Nao e subconjunto.");
                break;
            default:
                System.out.println ("O subconjunto e maior que o conjunto comparado.");
                break;
        }

      System.out.println("-------------- ITEM B.2 --------------");
      System.out.println ("A pertinencia do conjunto 3 no conjunto 1:");
        switch (n1.verificarSubconjunto(n3)) {
            case 1:
                System.out.println ("E subconjunto.");
                break;
            case 0:
                System.out.println ("Nao e subconjunto.");
                break;
            default:
                System.out.println ("O subconjunto e maior que o conjunto comparado.");
                break;
        }

      System.out.println("-------------- ITEM B.3 --------------");
      System.out.println ("A pertinencia do conjunto 4 no conjunto 1:");
        switch (n1.verificarSubconjunto(n4)) {
            case 1:
                System.out.println ("E subconjunto.");
                break;
            case 0:
                System.out.println ("Nao e subconjunto.");
                break;
            default:
                System.out.println ("O subconjunto e maior que o conjunto comparado.");
                break;
        }

      System.out.println("\n--------------- ITEM C ---------------");
      //Se a uniao de 2 e 3 E igual ao conjunto 1;
      Conjunto union = n2.uniaoConjunto(n3);
      System.out.println("Uniao - Conjunto 2 e 3:"); union.imprimirVetor();

      System.out.println("\n--------------- ITEM D ---------------");
      //Se a interseccao dos conjuntos 1 e 2 E vazia
      Conjunto inter = n1.interConjunto(n2);
      if (inter.quantidade > 0) {
          System.out.println("A interseccao nao e vazia.");
      } else {
          System.out.println("A interseccao e vazia.");
      }
      System.out.println("Interseccao - Conjunto 1 e 2:"); inter.imprimirVetor();

      System.out.println("\n--------------- ITEM E ---------------");
      //Qual a diferenca entre os conjuntos 1 e 2
      Conjunto difer = n1.diferencaConjunto(n2);
      System.out.println("Diferenca - Conjunto 1 e 2:"); difer.imprimirVetor();

      System.out.println("--------------- FIM ---------------\n");

      System.out.println("Conjunto A:"); p1.imprimirVetor();
      System.out.println("Conjunto B:"); p2.imprimirVetor();
      Conjunto cartesiano = p1.produtoCartesiano(p2);
      System.out.println("Conjunto Cartesiano de A e B:"); cartesiano.imprimirVetor();
      Conjunto potencia_a = p1.conjuntoPotencia();
      System.out.println("Conjunto Potencia de A:"); potencia_a.imprimirVetor();
      Conjunto potencia_b = p2.conjuntoPotencia();
      System.out.println("Conjunto Potencia de B:"); potencia_b.imprimirVetor();

      //Conjunto Universo
      Conjunto universo = new Conjunto(50);
      for (int numero = 0; numero <= 49; numero++) {
          universo.inserirValor(numero);
      }
      System.out.println("\nConjunto Universo:"); universo.imprimirVetor();

      //Conjuntos Base
      Conjunto DeMorganUniao = n2.uniaoConjunto(n3);
      Conjunto DeMorganInter = n2.interConjunto(n3);

      Conjunto ComplementoDeMorganUniao = universo.diferencaConjunto(DeMorganUniao);
      Conjunto ComplementoDeMorganInter = universo.diferencaConjunto(DeMorganInter);

      Conjunto ComplementoA = universo.diferencaConjunto(n2);
      Conjunto ComplementoB = universo.diferencaConjunto(n3);

      Conjunto ComplementoInter = ComplementoA.interConjunto(ComplementoB);
      Conjunto ComplementoUniao = ComplementoA.uniaoConjunto(ComplementoB);

      System.out.println("\nDeMorgan Uniao:"); ComplementoDeMorganUniao.igualdadeConjunto(ComplementoInter);
      System.out.println("DeMorgan Interseccao:"); ComplementoDeMorganInter.igualdadeConjunto(ComplementoUniao);

    }

}

public class Conjunto {
    Object[] vetor;
    int tamanho;
    int ponteiro;
    int quantidade;

    Conjunto (int tamanho) {
      this.vetor = new Object[tamanho];
      this.tamanho = tamanho;
      this.quantidade = 0;
      this.ponteiro = -1;
    }

    boolean inserirValor(Object valor) {
      if (this.ponteiro < (this.tamanho-1)) {
        this.quantidade++;
        this.ponteiro++;
        this.vetor[this.ponteiro] = valor;
        return true;
      } else {
        System.out.println ("Conjunto cheio.");
        return false;
      }
    }

    boolean verificarValor(Object valor) {
      int verificador = 0;
      while (verificador <= this.ponteiro) {
        if (this.vetor[verificador] == valor) {
          verificador = -1;
          break;
        }
        verificador++;
      }

      if (verificador == -1) {
        //System.out.println ("O valor pertence ao conjunto.");
        return true;
      } else {
        //System.out.println ("O valor nao pertence ao conjunto.");
        return false;
      }
    }

    int verificarSubconjunto(Conjunto c) {

      if (c.quantidade > this.quantidade) {
        //System.out.println ("O subconjunto e maior que o conjunto comparado.");
        return -1;
      } else {

        int check = c.ponteiro;
        int flag = c.quantidade;
        int contador = 0;
        while (flag > 0) {
          if (this.verificarValor(c.vetor[check])) {
            contador++;
          }
          flag--;
          check--;
        }

        if (contador == c.quantidade) {
          //System.out.println ("E subconjunto.");
          return 1;
        } else {
          //System.out.println ("Nao e subconjunto.");
          return 0;
        }
      }
    }

    Conjunto uniaoConjunto(Conjunto c) {
      if (this.verificarSubconjunto(c) == 0) {

          Conjunto uniao_teste = new Conjunto(this.quantidade + c.quantidade);

          int t1 = this.ponteiro;
          int t2 = c.ponteiro;

          for (int x = this.quantidade; x > 0; x--) {
            if (!uniao_teste.verificarValor(this.vetor[t1])) {
              uniao_teste.inserirValor(this.vetor[t1]);
              t1--;
            }
          }

          for (int x = c.quantidade; x > 0; x--) {
            if(!uniao_teste.verificarValor(c.vetor[t2])) {
              uniao_teste.inserirValor(c.vetor[t2]);
            }
            t2--;
          }

          Conjunto uniao = new Conjunto(uniao_teste.quantidade);

          t1 = this.ponteiro;
          t2 = c.ponteiro;

          for (int x = this.quantidade; x > 0; x--) {
            if (!uniao.verificarValor(this.vetor[t1])) {
              uniao.inserirValor(this.vetor[t1]);
              t1--;
            }
          }

          for (int x = c.quantidade; x > 0; x--) {
            if(!uniao.verificarValor(c.vetor[t2])) {
              uniao.inserirValor(c.vetor[t2]);
            }
            t2--;
          }
          return uniao;
      } else {
        return this;
      }
    }

    Conjunto interConjunto(Conjunto c) {

      Conjunto inter_teste = new Conjunto(this.quantidade + c.quantidade);

      int contador;

      for (int i = 0; i < this.quantidade; i++) {
        for (int j = 0; j < c.quantidade; j++) {
          if (this.vetor[i].equals(c.vetor[j]) && !inter_teste.verificarValor(this.vetor[i])) {
            inter_teste.inserirValor(this.vetor[i]);
          }
        }
      }

      if (inter_teste.quantidade == 0) {
          contador = 1;
      } else {
          contador = inter_teste.quantidade;
      }

      Conjunto intersec = new Conjunto(contador);

      for (int i = 0; i < inter_teste.quantidade; i++) {
          intersec.inserirValor(inter_teste.vetor[i]);
      }

      return intersec;

    }

    Conjunto diferencaConjunto(Conjunto c) {

      Conjunto auxiliar = this.interConjunto(c);

      if (this.verificarSubconjunto(auxiliar) == 0) {

          Conjunto diferenca = new Conjunto(1);
          return diferenca;

      }

      if (this.quantidade == auxiliar.quantidade) {

          Conjunto diferenca = new Conjunto(1);
          return diferenca;
      }

      Conjunto diferenca = new Conjunto(this.quantidade - auxiliar.quantidade);

      for (int i = 0; i < this.quantidade; i++) {
          if (!auxiliar.verificarValor(this.vetor[i])) {
              diferenca.inserirValor(this.vetor[i]);
          }
      }

      return diferenca;

    }

    Conjunto produtoCartesiano(Conjunto c) {

        if (this.quantidade > 0 && c.quantidade > 0) {

            Conjunto cartesiano = new Conjunto(this.quantidade * c.quantidade);

            for (int contA = 0; contA < this.quantidade; contA++) {
                for (int contB = 0; contB < c.quantidade; contB++) {
                    cartesiano.inserirValor("("+this.vetor[contA]+","+c.vetor[contB]+")");
                }
            }

            return cartesiano;

        } else {
            Conjunto cartesiano = new Conjunto(1);
            cartesiano.inserirValor("NULO");
            return cartesiano;
        }
    }

    Conjunto conjuntoPotencia() {

        double s = Math.pow(2, this.quantidade);
        Conjunto potencia = new Conjunto((int) s);

        Conjunto valoresBinarios = new Conjunto(potencia.tamanho);

        for (int i = 0; i < potencia.tamanho; i++) {
            String binario = Integer.toBinaryString(i);
            for (int j = binario.length(); j < this.quantidade; j++) {
                binario = "0"+binario;
            }

            valoresBinarios.inserirValor(binario);
            //System.out.println(binario);
        }
        //System.out.println(valoresBinarios.vetor[0].getClass().getName());
        //valoresBinarios.imprimirVetor();

        for (int i = 0; i < valoresBinarios.quantidade; i++) {
            String msg = "(";
            for (int j = 0; j < this.quantidade; j++) {
                String bin = (String) valoresBinarios.vetor[i];
                char teste = bin.charAt(j);
                if (teste == '1') {
                    msg += this.vetor[j] + ",";
                }
            }
            msg += ")";
            potencia.inserirValor(msg);
        }

        return potencia;
    }

    //Checa se um conjunto é igual ao outro
    boolean igualdadeConjunto(Conjunto c) {
        if (this.quantidade == c.quantidade) {
            int contador = 0;

            for (int i = 0; i < this.quantidade; i++) {
                if (this.verificarValor(c.vetor[i])) {
                    contador++;
                }
            }

            if (contador == this.quantidade) {
                System.out.println ("Os conjuntos sao iguais.");
                return true;
            } else {
                System.out.println ("Os conjuntos sao diferentes. (2)");
                return false;
            }

        } else {
            System.out.println ("Os conjuntos sao diferentes. (1)");
            return false;
        }
    }

    //Retorna o tamanho do conjunto
    int getLength() {
      return this.tamanho;
    }

    //Imprime o Conjunto
    void imprimirVetor() {
      String msg = "[";
      for (int x = 0; x <= getLength()-1; x++) {
        if (x == getLength()-1)
          msg += this.vetor[x] + "]";
        else
          msg += this.vetor[x] + ",";
      }

      System.out.println(msg);
    }

}