public class ConjuntoTabla implements Conjunto {
//Descripción general: Implementación en forma de tabla de enteros

private int _tablaInt[];

/*Tabla de enteros ordenada de forma creciente
La longitud de la tabla siempre coincide con el número de
elementos del conjunto que representa */

public ConjuntoTabla() {
    this._tablaInt = new int [0];
}

public void setElem(int i, int n) {
   this. _tablaInt[i] = n;
}

public int getElem(int i) {
    return this._tablaInt[i];
}

//Se ha añadido n al conjunto ordenadamente
public void añadir(int n) {
    if (!this.pertenece(n)) {
        int i = this.nelem();
        int aux[] = new int[i+1];
        for (int j=0; j < i; j++) {
            aux[j] = getElem(j);
        }
        while (i > 0 && n < getElem(i-1)) {
            aux[i] = getElem(i-1);
            i--;
        }
        aux[i] = n;
        _tablaInt = aux;
}


public boolean pertenece(int n) {
    int medio, izq = 0, der = this.nelem()-1;
    boolean encontrado = false;
    while (!encontrado && izq <= der) {
        medio = (izq + der)/2;
        if (n < getElem(medio)) der = medio -1;
        else if (n > getElem(medio)) izq = medio + 1;
        else encontrado = true;
    }
    return encontrado;
}

public boolean vacio() {
    return (this.nelem() == 0);
}

public Conjunto union(Conjunto c) {
    ConjuntoTabla aux;
    aux = (ConjuntoTabla)c;
    if (aux.vacio()) return this;
    else if (this.vacio()) return c;
    else {
        ConjuntoTabla union = new ConjuntoTabla();
        for (int i=0; i < this.nelem(); i++) {
            union.añadir(getElem(i));
        }
        for (int i=0; i < c.nelem(); i++) {
            union.añadir(aux.getElem(i));
        }
    return union;
    }
}

public Conjunto interseccion(Conjunto c) {
    ConjuntoTabla interseccion = new ConjuntoTabla();
    ConjuntoTabla aux;
    aux = (ConjuntoTabla)c;
    if (!this.vacio() && !aux.vacio()) {
        for (int i=0; i < this.nelem(); i++) {
            for (int j=0; j < aux.nelem(); j++) {
                int n = this.getElem(i);
                if (n==aux.getElem(j)) {
                    interseccion.añadir(n);
                }
            }
        }
    }
    return interseccion;
}

public Conjunto diferencia(Conjunto c) {
    ConjuntoTabla diferencia = new ConjunoTabla();
    ConjuntoTabla aux;
    aux = (ConjuntoTabla)c;
    if (!aux.vacio()) {
        for (int i=0; i<this.nelem(); i++) {
            int n= this.getElem(i);
            if (!aux.pertenece(n)) {
                diferencia.añadir(n);
            }
        }
    }
    return diferencia;
}

public int nelem() {
    return (_tablaInt.length);
}

public int elem(int i) {
    int n = getElem(i-nelem());
    return n;
}

@Override // Heredado de Object
public String toString() {
String s = "";
for (int i=0; i < nelem(); i++) {
        int n = getElem(i);
        if (i==0) s = s + n;
        else s = s + "," + n;
}
return "[" + s + "]";
}
}

//Interfaz, no puedo modificarla

public interface Conjunto {
// Descripción general: conjunto (concepto matemático) de enteros

public void añadir(int n);
// Pre : ---
// Post: Se ha añadido  n  al conjunto

public boolean pertenece(int n);
// Pre : ---
// Post: Dice si  n  pertenece al conjunto

public boolean vacio();
// Pre : ---
// Post: Dice si el conjunto es vacío

public Conjunto union(Conjunto c);
// Pre : ---
// Post: Devuelve la unión de este conjunto con c

public Conjunto interseccion(Conjunto c);
// Pre : ---
// Post: Devuelve la intersección de este conjunto con c

public Conjunto diferencia(Conjunto c);
// Pre : ---
// Post: Devuelve la diferencia de este conjunto con c

public int nelem();
// Pre : ---
// Post: Dice cuantos elementos tiene el conjunto

public int elem(int i);
// Pre : 1 <= i <= nelem()
// Post: Devuelve el i-éssimo elemento de este conjunto según orden numérico
}

//Programa principal, no puedo modificarlo:

import java.util.Scanner;

public class TestConjuntoTabla {
// Descripción general: Pequeño test de la clase ConjuntoTabla.
//
// Lee dos secuencias consecutivas de enteros (posiblemente con
// elementos repetidos) separadas por '#', las pone en dos conjuntos,
// y muestra su unión, intersección y diferencia.

public static void main(String argv[]) throws Exception {
Scanner s = new Scanner(System.in);
Conjunto c1 = new ConjuntoTabla();
Conjunto c2 = new ConjuntoTabla();

System.out.println("Introducir dos secuencias de enteros, separadas por el símbolo #");

while (s.hasNextInt())
    c1.añadir(s.nextInt());

s.next(); // Salta '#'

while (s.hasNextInt())
    c2.añadir(s.nextInt());

    System.out.println("nc1: " + c1);
System.out.println("c2: " + c2);
System.out.println("c1 unión c2: " + c1.union(c2));
System.out.println("c1 intersección c2: " + c1.interseccion(c2));
System.out.println("c1 menos c2: " + c1.diferencia(c2));
}

}