/*
Sabiendo que los elementos que puede contener un Conjunto están en el rango [1,n], 
desarrolle una implementación completa del TAD del ejercicio 2 parte (b) (TAD Conjunto acotado de naturales)
usando una estructura de memoria estática, de tal manera que el tiempo de ejecución de las operaciones 
de unión,intersección y diferencia sea O(n) en el peor caso.
*/
#include <stdio.h>

/*TAD Conjunto acotado*/

// Crea un Conjunto vacío de tamano n
Conjunto crearConjunto(int n);

// Devuelve true si solo si el Conjunto esta lleno, en otro caso devuelve false
bool llenoConjunto(conjunto c);

//Incluye un elemento x en un conjunto c
//PRE: el elemento x no pertenece al conjunto c 
//PRE: el conjunto no esta lleno (no es necesaria esta pre porque si no pertenece el elemento es que hay al menos un lugar)
void insertarConjunto(int x, Conjunto &c);

// Devuelve true si solo si un Conjunto es vacío, en otro caso devuelve false
bool esVacioConjunto(conjunto c);

//Excluye un elemento x de un conjunto c
//PRE: el elemento x pertenece al conjunto c
void excluirConjunto(int x, Conjunto &c);

//Devuelve true si el elemento x pertenece al conjunto c
bool perteneceConjunto(int x, Conjunto c);

//Recibe dos conjuntos c1 y c2 y retorna la uniendo de ambos
Conjunto union(Conjunto c1, Conjunto c2);

//Recibe dos conjuntos c1 y c2 y retorna la interseccion de ambos
Conjunto interseccion(Conjunto c1, Conjunto c2);

//Recibe dos conjuntos c1 y c2 y retorna la diferencia de ambos
Conjunto diferencia(Conjunto c1, Conjunto c2);

struct rep_conjunto{
    bool* arreglo;
    int cota;
    int cantidad;
}

typedef rep_conjunto* Conjunto;

Conjunto crearConjunto(int n){
    Conjunto nuevo = new rep_conjunto;
    nuevo->cantidad=0;
    nuevo->cota=n;
    nuevo->arreglo= new bool[n+1];
    for (int i=1; i<=n; i++){
       nuevo->arreglo[i]= false;
    }
    return nuevo;
}

bool llenoConjunto(conjunto c){
    return c->cantidad==c->cota;
}

bool esVacioConjunto(conjunto c);
    return c->cantidad==0;
}


void insertarConjunto(int x, Conjunto &c){
    if (1<=x && x<=c->cota){
        c->arreglo[x]=true;
        c->cantidad++;
    }
}


void excluirConjunto(int x, Conjunto &c){
    c->arreglo[i]=false;
    c->cantidad--;
}

bool perteneceConjunto(int x, Conjunto c){
    if (1<=x && x<=c->cota){
        return c->arreglo[x];
    }else{
        return false;
    }
}

//Recibe dos conjuntos c1 y c2 y retorna la uniendo de ambos
Conjunto union(Conjunto c1, Conjunto c2{
    Conjunto nuevo = crearConjunto(c1->cota);
    for (int i=1;i<=c1->cota;i++){
        nuevo->arreglo[i]= (c1->arreglo[i] || c2->arreglo[i]);
        if (nuevo->arreglo[i]){
            nuevo->cantidad++;
        }
    }
    return nuevo;
}

//Recibe dos conjuntos c1 y c2 y retorna la interseccion de ambos
Conjunto interseccion(Conjunto c1, Conjunto c2){
    Conjunto nuevo = crearConjunto(c1->cota);
    for (int i=1;i<=c1->cota;i++){
        nuevo->arreglo[i]= (c1->arreglo[i] && c2->arreglo[i]);
        if (nuevo->arreglo[i]){
            nuevo->cantidad++;
        }
    }
    return nuevo;
}

//Recibe dos conjuntos c1 y c2 y retorna la diferencia de ambos
Conjunto diferencia(Conjunto c1, Conjunto c2){
    Conjunto nuevo = crearConjunto(c1->cota);
    for (int i=1;i<=c1->cota;i++){
        nuevo->arreglo[i]= (c1->arreglo[i] && !c2->arreglo[i]);
        if (nuevo->arreglo[i]){
            nuevo->cantidad++;
        }
    }
    return nuevo;
}

void destruir (Conjunto &c){
    delete [] c->arreglo;
    delete c;
}




int main()
{
    printf("Hello World");

    return 0;
}