Manual de xsEasyC
Como utilizar Conjuntos

La librería xssets de xsEasyC proporciona funciones para el manejo de las operaciones fundamentales del Álgebra de Conjuntos. Los Tipos De Datos posibles que se permiten manejar en los elementos de un Conjunto son los ya vistos anteriormente: TIPO_CADENA, TIPO_CARACTER, TIPO_ENTERO y TIPO_DOBLE. Es importante mencionar que los Conjuntos no permiten elementos repetidos.

A continuación se presentan las Funciones que incluye la librería en el orden sugerido de uso. Los ejemplos de Código son tomados del directorio de ejemplos de la librería.

  • conjuntoInicializar
    Función para inicializar un Conjunto para su uso.
    Esta función utiliza 1 parámetro:
    Conjunto *conjunto. Este parámetro es correspondiente a una variable de Tipo Conjunto la cual se inicializará.

    Lo primero que debe de hacerse es declarar una variable de Tipo Conjunto e inicializarla.
    El siguiente ejemplo muestra como declarar una variable de Tipo Conjunto e Inicializarla para su posterior uso.
    Ejemplo:

    // Variable para la pila
    Conjunto conjuntoA;

    // Inicializa los conjuntos
    Imprimir("Inicializando el Conjunto A ...");
    conjuntoInicializar(&conjuntoA);
    CL;

     El Ejemplo anterior primeramente define la variable conjuntoA del Tipo Conjunto; y posteriormente utiliza la función para Inicializarla.


  • conjuntoInsertar
    Función para Insertar un Elemento en el Conjunto.
    Esta función utiliza 3 parámetros:
    Conjunto *conjunto. Este parámetro es correspondiente a una variable de Tipo Conjunto del cual se recibe su dirección de memoria.
    Entero tipo. Este parámetro es para indicar el Tipo de Dato que se va a insertar en el Conjunto. Los valores posible para este parámetro son: TIPO_CADENA, TIPO_ENTERO, TIPO_CARACTER y TIPO DOBLE.
    .... Este parámetro es para indicar el dato que se va a asignar a el Valor del Elemento del Conjunto, el cual puede ser de los 4 posibles tipos de datos indicados en el parámetro previo.

    El siguiente ejemplo muestra como insertar elementos a un Conjunto.
    Ejemplo:

    // Variable para los Conjuntos
    Conjunto a;
    Conjunto b;

    // Inicializa los Conjuntos
    Imprimir("Inicializando los conjuntos ...");
    CL;
    conjuntoInicializar(&a);
    conjuntoInicializar(&b);

    // Inserta Elementos en los Conjuntos
    Imprimir("Insertando Elementos en los conjuntos ...");
    CL;

    conjuntoInsertar(&a,TIPO_ENTERO,10);
    conjuntoInsertar(&a,TIPO_ENTERO,20);
    conjuntoInsertar(&a,TIPO_ENTERO,30);
    conjuntoInsertar(&a,TIPO_ENTERO,30);

    conjuntoInsertar(&a,TIPO_CADENA,"xsEasyC");
    conjuntoInsertar(&a,TIPO_CADENA,"xsEasyC");
    conjuntoInsertar(&a,TIPO_CARACTER,'a');
    conjuntoInsertar(&a,TIPO_CARACTER,'b');
    conjuntoInsertar(&a,TIPO_CARACTER,'c');
    conjuntoInsertar(&a,TIPO_CARACTER,'c');

    conjuntoInsertar(&a,TIPO_DOBLE,130.22);
    conjuntoInsertar(&a,TIPO_DOBLE,133.44);
    conjuntoInsertar(&a,TIPO_DOBLE,133.44);

    conjuntoInsertar(&b,TIPO_ENTERO,50);
    conjuntoInsertar(&b,TIPO_ENTERO,50);
    conjuntoInsertar(&b,TIPO_ENTERO,40);
    conjuntoInsertar(&b,TIPO_ENTERO,30);

    conjuntoInsertar(&b,TIPO_CADENA,"xsEasyC");
    conjuntoInsertar(&b,TIPO_CARACTER,'a');
    conjuntoInsertar(&b,TIPO_CARACTER,'e');
    conjuntoInsertar(&b,TIPO_CARACTER,'i');
    conjuntoInsertar(&b,TIPO_CARACTER,'i');

    conjuntoInsertar(&b,TIPO_DOBLE,130.22);
    conjuntoInsertar(&b,TIPO_DOBLE,133.44);
    conjuntoInsertar(&b,TIPO_DOBLE,133.44);

    // Desplegando los Conjuntos
    Imprimir("Conjunto a");
    conjuntoImprimir(a);
    CL;

    Imprimir("Conjunto b");
    conjuntoImprimir(b);
    CL;

     El Ejemplo anterior primeramente se definen las variables a,b del Tipo Conjunto y se inicializan. Posteriormente se insertan varios elementos de diferentes tipos a cada uno de los Conjuntos, y en algunos casos se intenta repetir un elemento; pero se observa como esto no lo permite la función; ya que no debe de haber elementos repetidos en los Conjuntos. Finalmente se imprimen cada uno de los conjuntos para observar sus elementos.

    La siguiente imagen muestra la ejecución del Código en donde se observa la impresión de la Lista mostrando los elementos insertados.

    conjunto Insertar

  • conjuntoInterseccion
    Función para obtener la Intersección entre 2 conjuntos
    Esta función utiliza 2 parámetros:
    Conjunto conjuntoA. Este parámetro es correspondiente al primer conjunto.
    Conjunto conjuntoB. Este parámetro es correspondiente al segundo conjunto.

    El siguiente ejemplo muestra como obtener la intersección entre 2 conjuntos y asignar el resultado en un tercer conjunto.
    Ejemplo:

    // Variables para conjuntos
    Conjunto a;
    Conjunto b;

    // Inicializa Conjuntos
    conjuntoInicializar(&a);
    conjuntoInicializar(&b);

    // Imprimir
    Imprimir("Agregando elementos a los Conjuntos");

    conjuntoInsertar(&a,TIPO_ENTERO,1);
    conjuntoInsertar(&a,TIPO_ENTERO,2);
    conjuntoInsertar(&a,TIPO_ENTERO,3);
    conjuntoInsertar(&a,TIPO_ENTERO,4);
    conjuntoInsertar(&a,TIPO_CADENA,"rojo");
    conjuntoInsertar(&a,TIPO_CADENA,"verde");
    conjuntoInsertar(&a,TIPO_CARACTER,'X');
    conjuntoInsertar(&a,TIPO_DOBLE,3.14);
    Imprimir("Conjunto a");
    conjuntoImprimir(a);
    CL;

    conjuntoInsertar(&b,TIPO_ENTERO,1);
    conjuntoInsertar(&b,TIPO_ENTERO,3);
    conjuntoInsertar(&b,TIPO_ENTERO,5);
    conjuntoInsertar(&b,TIPO_ENTERO,7);
    conjuntoInsertar(&b,TIPO_CADENA,"negro");
    conjuntoInsertar(&b,TIPO_CADENA,"verde");
    conjuntoInsertar(&b,TIPO_CADENA,"blanco");
    conjuntoInsertar(&b,TIPO_CARACTER,'X');
    conjuntoInsertar(&b,TIPO_DOBLE,3.14);
    Imprimir("Conjunto b");
    conjuntoImprimir(b);
    CL;

    // Definimos un nuevo conjuntoA
    Conjunto c;

    // Obtenemos la Intersección y se la asignamos al conjunto c
    Imprimir("Obtenemos la Interseccion del conjunto a y del conjunto b; y la colocamos en el conjunto c");

    c = conjuntoInterseccion(a,b);
    Imprimir("Conjunto c");
    conjuntoImprimir(c);
    CL;

     El Ejemplo anterior primeramente define los conjuntos a,b; se inicializan y se les agregan elementos; algunos de ellos comunes en ambos conjuntos. A continuación se define un conjunto c; y a este se le asigna la llamada a la función de la Intersección. Al imprimir este tercer conjunto, se observan los resultados de la Intersección. La siguiente imagen muestra la ejecución del Código.

    conjunto Interseccion

  • conjuntoDiferencia
    Función para obtener la Diferencia entre 2 conjuntos
    Esta función utiliza 2 parámetros:
    Conjunto conjuntoA. Este parámetro es correspondiente al primer conjunto.
    Conjunto conjuntoB. Este parámetro es correspondiente al segundo conjunto.

    El siguiente ejemplo muestra como obtener la Diferencia entre 2 conjuntos y asignar el resultado en un tercer conjunto.
    Ejemplo:

    // Variables para conjuntos
    Conjunto a;
    Conjunto b;

    // Inicializa Conjuntos
    conjuntoInicializar(&a);
    conjuntoInicializar(&b);

    // Imprimir
    Imprimir("Agregando elementos a los Conjuntos");
    conjuntoInsertar(&a,TIPO_ENTERO,1);
    conjuntoInsertar(&a,TIPO_ENTERO,2);
    conjuntoInsertar(&a,TIPO_ENTERO,3);
    conjuntoInsertar(&a,TIPO_ENTERO,4);
    conjuntoInsertar(&a,TIPO_CADENA,"rojo");
    conjuntoInsertar(&a,TIPO_CADENA,"verde");
    conjuntoInsertar(&a,TIPO_CADENA,"azul");
    Imprimir("Conjunto a");
    conjuntoImprimir(a);
    CL;

    conjuntoInsertar(&b,TIPO_ENTERO,1);
    conjuntoInsertar(&b,TIPO_ENTERO,3);
    conjuntoInsertar(&b,TIPO_ENTERO,5);
    conjuntoInsertar(&b,TIPO_ENTERO,7);
    conjuntoInsertar(&b,TIPO_CADENA,"negro");
    conjuntoInsertar(&b,TIPO_CADENA,"verde");
    conjuntoInsertar(&b,TIPO_CADENA,"blanco");
    Imprimir("Conjunto b");
    conjuntoImprimir(b);
    CL;

    // Declara otra variable para resultado
    Conjunto c;
    conjuntoInicializar(&c);

    // Obtiene la diferencia de A y B
    Imprimir("Obtiene la diferencia entre a y b y la deposita en c");
    c = conjuntoDiferencia(a,b);
    Imprimir("Conjunto c");
    conjuntoImprimir(c);
    CL;

    // Obtiene la diferencia de B y A
    Imprimir("Obtiene la diferencia entre b y a y la deposita en c");
    c = conjuntoDiferencia(b,a);
    Imprimir("Conjunto c");
    conjuntoImprimir(c);
    CL;
     El Ejemplo anterior primeramente define los conjuntos a,b; se inicializan y se les agregan elementos; algunos de ellos comunes en ambos conjuntos. A continuación se define un conjunto c; y a este se le asigna la llamada a la función de la Diferencia. Al imprimir este tercer conjunto, se observan los resultados de la Diferencia. La siguiente imagen muestra la ejecución del Código.

    conjunto Diferencia

  • conjuntoDiferenciaSimetrica
    Función para obtener la Diferencia Simétrica entre 2 conjuntos
    Esta función utiliza 2 parámetros:
    Conjunto conjuntoA. Este parámetro es correspondiente al primer conjunto.
    Conjunto conjuntoB. Este parámetro es correspondiente al segundo conjunto.

    El siguiente ejemplo muestra como obtener la Diferencia Simétrica entre 2 conjuntos y asignar el resultado en un tercer conjunto.
    Ejemplo:

    // Variables para conjuntos
    Conjunto a;
    Conjunto b;

    // Inicializa Conjuntos
    conjuntoInicializar(&a);
    conjuntoInicializar(&b);

    // Imprimir
    Imprimir("Agregando elementos a los Conjuntos");
    conjuntoInsertar(&a,TIPO_ENTERO,1);
    conjuntoInsertar(&a,TIPO_ENTERO,2);
    conjuntoInsertar(&a,TIPO_ENTERO,3);
    conjuntoInsertar(&a,TIPO_ENTERO,4);
    conjuntoInsertar(&a,TIPO_ENTERO,5);
    conjuntoInsertar(&a,TIPO_ENTERO,6);
    Imprimir("Conjunto a");
    conjuntoImprimir(a);
    CL;

    conjuntoInsertar(&b,TIPO_ENTERO,4);
    conjuntoInsertar(&b,TIPO_ENTERO,5);
    conjuntoInsertar(&b,TIPO_ENTERO,6);
    conjuntoInsertar(&b,TIPO_ENTERO,7);
    conjuntoInsertar(&b,TIPO_ENTERO,8);
    conjuntoInsertar(&b,TIPO_ENTERO,9);

    Imprimir("Conjunto b");
    conjuntoImprimir(b);
    CL;

    // Declara otra variable para resultado
    Conjunto c;
    conjuntoInicializar(&c);

    // Obtiene la diferencia Simétrica de A y B
    Imprimir("Obtiene la diferencia Simetrica entre a y b y la deposita en c");
    c = conjuntoDiferenciaSimetrica(a,b);
    Imprimir("Conjunto c");
    conjuntoImprimir(c);
    CL;

    // Obtiene la diferencia de A y B
    Imprimir("Obtiene la diferencia Simetrica entre b y a y la deposita en c");
    c = conjuntoDiferenciaSimetrica(b,a);
    Imprimir("Conjunto c");
    conjuntoImprimir(c);
    CL;

     El Ejemplo anterior primeramente define los conjuntos a,b; se inicializan y se les agregan elementos; algunos de ellos comunes en ambos conjuntos. A continuación se define un conjunto c; y a este se le asigna la llamada a la función de la Diferencia Simétrica. Al imprimir este tercer conjunto, se observan los resultados de la Diferencia Simétrica. La siguiente imagen muestra la ejecución del Código.

    conjunto Diferencia Simetrica

  • conjuntoDisjunto
    Función para verificar sin 2 Conjuntos Disjuntos
    Esta función utiliza 2 parámetros:
    Conjunto conjuntoA. Este parámetro es correspondiente al primer conjunto.
    Conjunto conjuntoB. Este parámetro es correspondiente al segundo conjunto.

    El siguiente ejemplo muestra como verificar si 2 conjuntos son Disjuntos.
    Ejemplo:

    // Variables para conjuntos
    Conjunto a;
    Conjunto b;

    // Inicializa Conjuntos
    conjuntoInicializar(&a);
    conjuntoInicializar(&b);

    // Imprimir
    Imprimir("Agregando elementos a los Conjuntos");
    conjuntoInsertar(&a,TIPO_ENTERO,1);
    conjuntoInsertar(&a,TIPO_ENTERO,2);
    conjuntoInsertar(&a,TIPO_ENTERO,13);
    conjuntoInsertar(&a,TIPO_ENTERO,4);
    conjuntoInsertar(&a,TIPO_CADENA,"rojo");
    conjuntoInsertar(&a,TIPO_CADENA,"verde");
    conjuntoInsertar(&a,TIPO_CADENA,"azul");
    Imprimir("Conjunto a");
    conjuntoImprimir(a);
    CL;

    conjuntoInsertar(&b,TIPO_ENTERO,11);
    conjuntoInsertar(&b,TIPO_ENTERO,3);
    conjuntoInsertar(&b,TIPO_ENTERO,5);
    conjuntoInsertar(&b,TIPO_ENTERO,7);
    conjuntoInsertar(&b,TIPO_CADENA,"negro");
    conjuntoInsertar(&b,TIPO_CADENA,"cafe");
    conjuntoInsertar(&b,TIPO_CADENA,"blanco");
    Imprimir("Conjunto b");
    conjuntoImprimir(b);
    CL;

    // Verifica si son disjuntos
    si (conjuntoDisjunto(a,b))
       Imprimir("Los conjuntos a y b son disjuntos");
    deOtroModo
       Imprimir("Los conjuntos a y b No son disjuntos");
    CL;

    // Agregamos un elemento común
    Imprimir("Agregamos un elemento comun, el 1 al conjunto b");
    conjuntoInsertar(&b,TIPO_ENTERO,1);
    conjuntoImprimir(a);
    conjuntoImprimir(b);
    CL;

    Imprimir("Verificamos ahora");
    // Verifica si son disjuntos
    si (conjuntoDisjunto(a,b))
       Imprimir("Los conjuntos a y b son disjuntos");
    deOtroModo
       Imprimir("Los conjuntos a y b No son disjuntos");

     El Ejemplo anterior primeramente define los conjuntos a,b; se inicializan y se les agregan elementos; algunos de ellos comunes en ambos conjuntos. Finalmente se llama a la función para verificar si los 2 conjuntos son Disjuntos y se despliega el mensaje correspondiente.

    conjunto Disjunto

  • conjuntoElemento
    Función para obtener un elemento de un Conjunto
    Esta función utiliza 2 parámetros:
    Conjunto conjunto. Este parámetro es correspondiente al Conjunto.
    Entero indice. Este parámetro es correspondiente al índice del elemento que se desea obtener.

    El siguiente ejemplo muestra como obtener 1 elemento del Conjunto.
    Ejemplo:

    // Variable para el Conjunto
    Conjunto a;

    // Inicializa la Conjunto
    conjuntoInicializar(&a);

    // Imprimir
    Imprimir("Insertando Elementos en el Conjunto a");
    CL;

    // Mete elementos en la Conjunto
    conjuntoInsertar(&a,TIPO_ENTERO,41);
    conjuntoInsertar(&a,TIPO_ENTERO,19);
    conjuntoInsertar(&a,TIPO_ENTERO,6513);
    conjuntoInsertar(&a,TIPO_CARACTER,'A');
    conjuntoInsertar(&a,TIPO_CARACTER,'Z');
    conjuntoInsertar(&a,TIPO_CADENA,"xsEasyC");

    // Desplegando los Elementos del Conjunto
    conjuntoImprimir(a);

    // Declara variable para elemento de la conjunto
    ElementoConjunto elemento;

    // Imprimir
    Imprimir("Obteniendo el Elemento 6");

    // Saca un Elemento de la Conjunto
    elemento = conjuntoElemento(a,6);

    // Imprime según el tipo
    evaluar (elemento.tipo)
    {
       siEs TIPO_ENTERO:
          imprimirEntero(elemento.dato.entero,FORMATO_DEFAULT,CON_CAMBIO_LINEA);
          salirEvaluar;

       siEs TIPO_CARACTER:
          imprimirCaracter(elemento.dato.caracter,"'%c'",CON_CAMBIO_LINEA);
          salirEvaluar;

       siEs TIPO_DOBLE:
          imprimirDoble(elemento.dato.doble,FORMATO_DEFAULT,CON_CAMBIO_LINEA);
          salirEvaluar;

       siEs TIPO_CADENA:
          imprimirCaracter('"',FORMATO_DEFAULT,SIN_CAMBIO_LINEA);
          imprimirCadena(elemento.dato.cadena,FORMATO_DEFAULT,SIN_CAMBIO_LINEA);
          imprimirCaracter('"',FORMATO_DEFAULT,CON_CAMBIO_LINEA);
          salirEvaluar;

    }
     El Ejemplo anterior primeramente define un conjunto; y después obtiene el elemento que se encuentra en la posición 6.

    conjunto Elemento

  • conjuntoEliminar
    Función para eliminar un elemento de un Conjunto
    Esta función utiliza 2 parámetros:
    Conjunto conjunto. Este parámetro es correspondiente al Conjunto.
    Entero indice. Este parámetro es correspondiente al índice del elemento que se desea eliminar.

    El siguiente ejemplo muestra como eliminar 1 elemento del Conjunto.
    Ejemplo:

    // Variable para el Conjunto
    Conjunto a;

    // Inicializa la Conjunto
    conjuntoInicializar(&a);

    // Imprimir
    Imprimir("Insertando Elementos en el Conjunto a");
    CL;

    // Mete elementos en la Conjunto
    conjuntoInsertar(&a,TIPO_ENTERO,41);
    conjuntoInsertar(&a,TIPO_ENTERO,19);
    conjuntoInsertar(&a,TIPO_ENTERO,6513);
    conjuntoInsertar(&a,TIPO_CARACTER,'A');
    conjuntoInsertar(&a,TIPO_CARACTER,'Z');
    conjuntoInsertar(&a,TIPO_CADENA,"xsEasyC");

    // Desplegando los Elementos del Conjunto
    conjuntoImprimir(a);

    // Eliminando el Elemento en posición 6
    Imprimir("Eliminando el elemento 6 ...");
    si (conjuntoEliminar(&a,6))
       Imprimir("Se logra eliminar el elemento en posicion 6");
    deOtroModo
       Imprimir("No se logra eliminar el elemento en posicion 6");
    CL;

    // Desplegando los Elementos del Conjunto
    conjuntoImprimir(a);

     El Ejemplo anterior primeramente define un conjunto; y después obtiene el elemento que se encuentra en la posición 6.

    conjunto Eliminar

  • conjuntoImprimir
    Función para imprimir los elementos de un Conjunto
    Esta función utiliza 1 parámetro:
    Conjunto conjunto. Este parámetro es correspondiente al Conjunto del que se van a imprimir sus elementos.

    En los anterior códigos de ejemplo, ha quedado demostrado el uso de esta función por lo que no se muestra un ejemplo específico en esta sección.

  • conjuntoImprimirElemento
    Función para imprimir el Valor de un elemento de un Conjunto
    Esta función utiliza 1 parámetro:
    ElementoConjunto elemento. Este parámetro es correspondiente al elemento a ser impreso.

    El siguiente ejemplo muestra como imprimir la información de un elemento.
    Ejemplo:

    // Variable para los Conjuntos
    Conjunto a;
    Conjunto b;

    // Inicializa los Conjuntos
    Imprimir("Inicializando los conjuntos ...");
    CL;

    conjuntoInicializar(&a);
    conjuntoInicializar(&b);

    // Inserta Elementos en los Conjuntos
    Imprimir("Insertando Elementos en los conjuntos ...");
    CL;

    conjuntoInsertar(&a,TIPO_ENTERO,10);
    conjuntoInsertar(&a,TIPO_ENTERO,20);
    conjuntoInsertar(&a,TIPO_ENTERO,30);
    conjuntoInsertar(&b,TIPO_ENTERO,50);
    conjuntoInsertar(&b,TIPO_ENTERO,40);
    conjuntoInsertar(&b,TIPO_ENTERO,30);

    // Desplegando los Conjuntos
    Imprimir("Imprimiendo el Conjunto a");
    conjuntoImprimir(a);
    CL;

    Imprimir("Imprimiendo el Conjunto b");
    conjuntoImprimir(b);
    CL;

    Imprimir ("Obteniendo e Imprimiendo el Elemento 2 del Conjunto a ...");
    ElementoConjunto elemento;
    elemento = conjuntoElemento(a,2);
    conjuntoImprimirElemento(elemento);
    CL;

    Imprimir ("Obteniendo e Imprimiendo el Elemento 3 del Conjunto b ...");
    elemento = conjuntoElemento(b,3);
    conjuntoImprimirElemento(elemento);
    CL;

     El Ejemplo anterior primeramente define 2 conjuntos en los cuales inserta varios elementos; y después obtiene el elemento que se encuentra en la posición 2 del primer conjunto y el 3 del segundo conjunto e imprime su valor.

    conjunto Imprimir Elemento

  • conjuntoLongitud
    Función para obtener el número de elementos que tiene un Conjunto
    Esta función utiliza 1 parámetro:
    Conjunto conjunto. Este parámetro es correspondiente al Conjunto del que se va a obtener su longitud.

    El siguiente ejemplo muestra obtener la longitud de un Conjunto.
    Ejemplo:

    // Variable para el Conjunto
    Conjunto a;

    // Inicializa los Conjuntos
    Imprimir("Inicializando el Conjunto ...");
    CL;

    conjuntoInicializar(&a);
    // Inserta Elementos en los Conjuntos
    Imprimir("Insertando Elementos en los conjuntos ...");
    CL;

    conjuntoInsertar(&a,TIPO_ENTERO,10);
    conjuntoInsertar(&a,TIPO_ENTERO,20);
    conjuntoInsertar(&a,TIPO_ENTERO,30);
    conjuntoInsertar(&a,TIPO_ENTERO,30);

    conjuntoInsertar(&a,TIPO_CADENA,"xsEasyC");
    conjuntoInsertar(&a,TIPO_CADENA,"xsEasyC");

    conjuntoInsertar(&a,TIPO_CARACTER,'a');
    conjuntoInsertar(&a,TIPO_CARACTER,'b');
    conjuntoInsertar(&a,TIPO_CARACTER,'c');
    conjuntoInsertar(&a,TIPO_CARACTER,'c');

    conjuntoInsertar(&a,TIPO_DOBLE,130.22);
    conjuntoInsertar(&a,TIPO_DOBLE,133.44);
    conjuntoInsertar(&a,TIPO_DOBLE,133.44);

    // Desplegando los Conjuntos
    Imprimir("Conjunto a");
    conjuntoImprimir(a);
    CL;

    // Define una variable para obtener la longitud
    Entero longitud;

    // Obtiene la longitud del Conjunto
    longitud = conjuntoLongitud(a);

    // Mensaje
    Imprimir("La longitud del Conjunto es:");
    ImprimirE(longitud);

     El Ejemplo anterior primeramente define un conjunto al cual inserta varios elementos. A continuación define la variable longitud de Tipo Entero; y posteriormente le asigna a esta variable el resultado de la función que obtiene la longitud del Conjunto para posteriormente imprimirla.

    conjunto Longitud

  • conjuntoProductoCartesiano
    Función para obtener el Producto Cartesiano entre 2 conjuntos
    Esta función utiliza 2 parámetros:
    Conjunto conjuntoA. Este parámetro es correspondiente al primer conjunto.
    Conjunto conjuntoB. Este parámetro es correspondiente al segundo conjunto.

    El siguiente ejemplo muestra como obtener el Producto Cartesiano entre 2 conjuntos y asignar el resultado en un tercer conjunto.
    Ejemplo:

    // Variables para conjuntos
    Conjunto a;
    Conjunto b;

    // Inicializa Conjuntos
    conjuntoInicializar(&a);
    conjuntoInicializar(&b);

    // Imprimir
    Imprimir("Agregando elementos a los Conjuntos");
    conjuntoInsertar(&a,TIPO_ENTERO,10);
    conjuntoInsertar(&a,TIPO_ENTERO,20);
    conjuntoInsertar(&a,TIPO_ENTERO,30);
    Imprimir("Conjunto a");
    conjuntoImprimir(a);
    CL;

    conjuntoInsertar(&b,TIPO_ENTERO,50);
    conjuntoInsertar(&b,TIPO_ENTERO,60);
    conjuntoInsertar(&b,TIPO_ENTERO,70);
    Imprimir("Conjunto b");
    conjuntoImprimir(b);
    CL;

    // Definimos un nuevo conjuntoA
    Conjunto c;

    // Obtenemos el Producto Cartesiano y se la asignamos al conjunto c
    Imprimir("Obtenemos el Producto Cartesiano del conjunto a y del conjunto b; y la colocamos en el conjunto c");
    c = conjuntoProductoCartesiano(a,b);
    Imprimir("Conjunto c");
    conjuntoImprimir(c);
    CL;

     El Ejemplo anterior primeramente define los conjuntos a,b; se inicializan y se les agregan elementos. A continuación se define el conjunto c y a este conjunto se le asigna el producto cartesiano entre el conjunto a y b.

    conjunto Producto Cartesiano

  • conjuntoTipo
    Función para obtener el Tipo de un Conjunto
    Esta función utiliza 1 parámetro:
    Conjunto conjunto. Este parámetro es correspondiente al conjunto.

    El siguiente ejemplo muestra como obtener el Tipo de Dato del Conjunto.
    Ejemplo:

    // Variable para el conjunto
    Conjunto a;

    // Inicializa el conjunto
    conjuntoInicializar(&a);

    // Mensaje
    Imprimir("Insertando los elementos 41,19 y 6513 en el Conjunto a");

    // Mete elementos en la Conjunto
    conjuntoInsertar(&a,TIPO_ENTERO,41);
    conjuntoInsertar(&a,TIPO_ENTERO,19);
    conjuntoInsertar(&a,TIPO_ENTERO,6513);
    CL;

    // Imprime la Conjunto
    Imprimir("Desplegando los Elementos del Conjunto a");
    conjuntoImprimir(a);
    CL;

    // Variable para el Tipo de Conjunto
    Entero tipoConjunto;

    // Obtiene el Tipo de la Conjunto
    tipoConjunto = conjuntoTipo(a);

    // Despliega según el tipo
    evaluar (tipoConjunto)
    {
       siEs TIPO_ENTERO:
          Imprimir("El conjunto es de Tipo Entero");
          salirEvaluar;

       siEs TIPO_CARACTER:
          Imprimir("El conjunto es de Tipo Caracter");
          salirEvaluar;

       siEs TIPO_DOBLE:
          Imprimir("El conjunto es de Tipo Doble");
          salirEvaluar;

       siEs TIPO_CADENA:
          Imprimir("El conjunto es de Tipo Cadena");
          salirEvaluar;
    }
    CL;

     El Ejemplo anterior primeramente define un conjunto al cual se le insertan elementos de Tipo Entero. Posteriormente se llama a la función; la cual devuelve el valor correspondiente a TIPO_ENTERO; ya que todos los elementos en el conjunto son Enteros.

    conjunto Tipo

  • conjuntoUnion
    Función para obtener la Unión entre 2 conjuntos
    Esta función utiliza 2 parámetros:
    Conjunto conjuntoA. Este parámetro es correspondiente al primer conjunto.
    Conjunto conjuntoB. Este parámetro es correspondiente al segundo conjunto.

    El siguiente ejemplo muestra como obtener la Unión entre 2 conjuntos y asignar el resultado en un tercer conjunto.
    Ejemplo:

    // Variables para conjuntos
    Conjunto a;
    Conjunto b;

    // Inicializa Conjuntos
    conjuntoInicializar(&a);
    conjuntoInicializar(&b);

    // Imprimir
    Imprimir("Agregando elementos a los Conjuntos");
    conjuntoInsertar(&a,TIPO_ENTERO,10);
    conjuntoInsertar(&a,TIPO_ENTERO,20);
    conjuntoInsertar(&a,TIPO_ENTERO,30);
    conjuntoInsertar(&a,TIPO_ENTERO,30);

    conjuntoInsertar(&a,TIPO_CADENA,"xsEasyc");
    conjuntoInsertar(&a,TIPO_CADENA,"xsEasyc");

    conjuntoInsertar(&a,TIPO_CARACTER,'a');
    conjuntoInsertar(&a,TIPO_CARACTER,'b');
    conjuntoInsertar(&a,TIPO_CARACTER,'c');
    conjuntoInsertar(&a,TIPO_CARACTER,'c');

    conjuntoInsertar(&a,TIPO_DOBLE,130.22);
    conjuntoInsertar(&a,TIPO_DOBLE,133.44);
    conjuntoInsertar(&a,TIPO_DOBLE,133.44);
    Imprimir("Conjunto a");
    conjuntoImprimir(a);
    CL;

    conjuntoInsertar(&b,TIPO_ENTERO,50);
    conjuntoInsertar(&b,TIPO_ENTERO,50);
    conjuntoInsertar(&b,TIPO_ENTERO,40);
    conjuntoInsertar(&b,TIPO_ENTERO,30);

    conjuntoInsertar(&b,TIPO_CADENA,"xsEasyc");
    conjuntoInsertar(&b,TIPO_CARACTER,'a');
    conjuntoInsertar(&b,TIPO_CARACTER,'e');
    conjuntoInsertar(&b,TIPO_CARACTER,'i');
    conjuntoInsertar(&b,TIPO_CARACTER,'i');

    conjuntoInsertar(&b,TIPO_DOBLE,130.22);
    conjuntoInsertar(&b,TIPO_DOBLE,133.44);
    conjuntoInsertar(&b,TIPO_DOBLE,133.44);

    conjuntoInsertar(&b,TIPO_ENTERO,1);
    conjuntoInsertar(&b,TIPO_ENTERO,3);
    conjuntoInsertar(&b,TIPO_ENTERO,5);
    conjuntoInsertar(&b,TIPO_ENTERO,7);
    conjuntoInsertar(&b,TIPO_CADENA,"negro");
    conjuntoInsertar(&b,TIPO_CADENA,"verde");
    conjuntoInsertar(&b,TIPO_CADENA,"blanco");
    Imprimir("Conjunto b");
    conjuntoImprimir(b);
    CL;

    // Definimos un nuevo conjuntoA
    Conjunto c;

    // Obtenemos la Unión y se la asignamos al conjunto c
    Imprimir("Obtenemos la Union del conjunto a y del conjunto b; y la colocamos en el conjunto c");
    c = conjuntoUnion(a,b);
    Imprimir("Conjunto c");
    conjuntoImprimir(c);
    CL;

     El Ejemplo anterior primeramente define los conjuntos a,b; se inicializan y se les agregan elementos; algunos de ellos comunes en ambos conjuntos. A continuación se define un conjunto c; y a este se le asigna la llamada a la función de la Unión. Al imprimir este tercer conjunto, se observan los resultados de la Unión. La siguiente imagen muestra la ejecución del Código.

    conjunto Union

  • conjuntoVaciar
    Función para eliminar todos los elementos de un Conjunto
    Esta función utiliza 1 parámetro:
    Conjunto *conjunto. Este parámetro es correspondiente a una variable de Tipo Conjunto de la cual se eliminarán sus elemento.

    El siguiente ejemplo muestra como vaciar un Conjunto eliminando todos sus elementos

    Ejemplo:

    // Variable para la conjunto
    Conjunto a;

    // Inicializa la Conjunto
    conjuntoInicializar(&a);

    // Imprimir
    Imprimir("Insertando los elementos 41,19 y 6513 en el Conjunto");
    CL;

    // Mete elementos en la Conjunto
    conjuntoInsertar(&a,TIPO_ENTERO,41);
    conjuntoInsertar(&a,TIPO_ENTERO,19);
    conjuntoInsertar(&a,TIPO_ENTERO,6513);

    // Imprime la Conjunto
    Imprimir("Desplegando los Elementos del Conjunto a");
    conjuntoImprimir(a);
    CL;

    Imprimir("Se esta vaciando el Conjunto");
    conjuntoVaciar(&a);
    CL;

    Imprimir("Imprimiendo el conjunto despues de vaciar");
    conjuntoImprimir(a);

     El Ejemplo anterior primeramente define un conjunto al cual se le agregan algunos elementos los cuales son desplegados. Posteriormente se ejecuta la función de Vaciar el Conjunto; y se vuelve a desplegar el mismo, observando que ya no contiene elemento alguno. La siguiente imagen muestra la ejecución del Código

    conjunto Vaciar

  • conjuntoVacio
    Función para verificar si un Conjunto está vacío
    Esta función utiliza 1 parámetro:
    Conjunto conjunto. Este parámetro es correspondiente a una variable de Tipo Conjunto.

    El siguiente ejemplo muestra como verificar si un Conjunto está vacío.

    Ejemplo:

    // Variable para la conjunto
    Conjunto a;

    // Inicializa la Conjunto
    conjuntoInicializar(&a);

    // Verificando si el conjunto está vacío al inicializar
    si (conjuntoVacio(a))
       Imprimir("El Conjunto se encuentra vacio");
    deOtroModo
       Imprimir("El Conjunto No se encuentra vacio");
    CL;

    // Imprimir
    Imprimir("Insertando los elementos 41,19 y 6513 en el Conjunto");
    CL;

    // Mete elementos en la Conjunto
    conjuntoInsertar(&a,TIPO_ENTERO,41);
    conjuntoInsertar(&a,TIPO_ENTERO,19);
    conjuntoInsertar(&a,TIPO_ENTERO,6513);

    // Imprime la Conjunto
    Imprimir("Desplegando los Elementos del Conjunto a");
    conjuntoImprimir(a);
    CL;

    // Verificando si el conjunto está vacío despues de Insertar
    si (conjuntoVacio(a))
       Imprimir("El Conjunto se encuentra vacio");
    deOtroModo
       Imprimir("El Conjunto No se encuentra vacio");
    CL;

    Imprimir("Se esta vaciando el Conjunto");
    conjuntoVaciar(&a);
    CL;

    Imprimir("Imprimiendo el conjunto despues de vaciar");
    conjuntoImprimir(a);

    // Verificando si el conjunto está vacío despues de vaciar
    si (conjuntoVacio(a))
       Imprimir("El Conjunto se encuentra vacio");
    deOtroModo
       Imprimir("El Conjunto No se encuentra vacio");
    CL;

     El Ejemplo anterior primeramente define un conjunto el cual se inicializa. Al inicializar se llama a la función que verifica si está vacío el Conjunto. Posteriormente se agregan elementos al Conjunto y se vuelve a verificar si el Conjunto estpa vacío. Finalmente el Conjunto se vacía y de nueva cuenta se vuelve a verificar si se encuentra vacío. La siguiente imagen muestra la ejecución del Código

    conjunto Vaciar