PROBLEMA: CONJUNTOS CON NUMEROS

Este problema consiste en lo siguiente: Se tienen 2 conjuntos A y B

de números, cada uno con M y N elementos respectivamente. A partir
de estos conjuntos se quiere efectuar las siguientes 4 operaciones:

- A Unión B,
- Diferencia A menos B,
- Diferencia B menos A e
- A Intersección B.

Unión: Son los números que están en ambos conjuntos, pero nos es
simplemente juntar los de ambos ya que tendríamos repetidos.

Diferencia A–B: Son los números que están en el conjunto A pero

no en B

Diferencia B–A: Son los números que están en el conjunto B pero

no en A

Intersección: Son los números (elementos) que están en ambos

conjuntos

Un conjunto no necesita estar ordenado pero, no debe tener

elementos repetidos.

Por ejemplo: Si tenemos los conjuntos A y B

A={2, 6, 4, 8, 0, 3, 5} y M=7 (A es un conjunto de 7 números)

B={3, 1, 7, 4, 2} y N=5 (B es un conjunto de 5 números)

El resultado de las 4 operaciones sería la siguiente:

A Intersección B = {2, 4, 3}
A menos B = {6, 8, 0, 5}
B menos A = {1, 7}
A unión B = {2, 6, 4, 8, 0, 3, 5, 1, 7}

Que gráficamente se vería más o menos así:

LA SOLUCION EN PROGRAMACION ??

Pues pasa primero por ver: ¿cómo podremos representar un

conjunto en la memoria del computador, en función a todo
aquello que ya conocemos ?

La respuesta es un conjunto puede ser representado con un vector.

Luego necesitamos inicialmente 2 vectores A y B con M y N
elementos respectivamente.

EL PROGRAMA ???
Se puede proponer un sub-programa para cada una de las 4
operaciones y entonces el programa principal cargaría los 2 conjuntos
y mandaría a ejecutar cada una de las 4 operaciones:

En lo que sigue se tiene inicialmente el programa principal que hace

uso del sub-programa cargaVector() para obtener cada uno de los
conjuntos, con M y N leídos antes, desde teclado. Para leer M y N
respectivamente, haremos uso del sub-programa LeerEnteroPQ()
visto anteriormente.
Programa CONJUNTOS()
Int A(20), B(20), M, N
INICIO
M  LeerEnteroPQ(5,20) //pedimos un entero entre 5 y 20
N  LeerEnteroPQ(5, 20) //pedimos otro entero entre 5 y 20
cargaVector(A, M) // pedimos cargar A con M elementos
cargaVector(B, N) // pedimos cargas B con N elementos
AinterB(A, M, B, N) //mandamos a calcular la intersección
AmenosB(A, M, B, N) // mandamos a calcular A - B
BmenosA(A, M, B, N) // mandamos a calcular B - A
AunionB(A, M, B, N) // mandamos a calcular la unión
FIN
Debemos tener en cuenta que cargaVector() no nos asegura que el
vector no tiene elementos repetidos, pero que se puede resolver esta
parte invocando al sub-programa que copie sin repetidos que
también ya se lo tiene realizado. Por ahora supondremos que A y B se
cargan sin repetidos.

El siguiente paso es desarrollar los 4 sub-programas que hagan las 4

operaciones. De los cuales se tienen 2 y los otros 2 se deja de
tarea.
Operación A menos B: La solución está en base a la respuesta a la
siguiente pregunta: ¿ Como saber si un elemento de A no está en B ?

Y la respuesta es ¿después de comparar este elemento con cada uno

de los de B? Solo si no es igual a ningún elemento de B podemos
estar seguros de que este elemento no está en B.

Por lo que, la solución estaría dada por 2 Paras anidados, el Para

exterior maneja los elementos del Conjunto A y el Para interior
maneja los elementos del Conjunto B. Luego, comparamos cada
elemento de A con todos los de B y así sucesivamente.

También usamos la variable bandera R para marcar cuando

encontramos un elemento del conjunto A igual a otro del conjunto de
B. Los no marcados se copian al vector Z (que contendrá el
resultado).

Nuestro sub-programa AmenosB() recibirá 2 vectores A y B de

números enteros y además 2 números enteros M y N
respectivamente que indican cuantos elementos hay en cada vector.
Dice que recibe Recibe el entero M, que
el indica cuantos elementos
Vector A hay en A

Procedimiento AmenosB(int A[ ], int M, int B[ ], int N)

Int Z(20), I, J, K : String R
INICIO
//Haremos la comparación de cada elemento de A con todos los de B
K0
Para I=0, M-1, 1
R “no” // inicialmente no es igual a ninguno
Para J=0, N-1, 1
Si A(I) = B(J) // encontramos otro igual en el vector B
Entonces R  “si” : J=N-1 // marcamos como repetido,
FinSi
FinPara
Si R = “no” // solo si no ha sido marcado
Entonces Z(K)  A(I):K  K +1 // copiamos al vector Z, con índice K
FinSi
FinPara
muestraVector(Z, K) // pedimos mostrar el vector Z con K elementos
FIN
Operación A interseccion B: Cuya solución es parecida a la
anterior y se copia a Z solo si el elemento de A es igual al de B (no
necesitamos marcar).

Procedimiento AinterB(int A[], int M, int B[], int N)

Int Z(20), I, J, K : String R
INICIO
//Haremos la comparación de cada elemento de A con todos los de B
K0
Para I=0, M-1, 1
Para J=0, N-1, 1
Si A(I) = B(J) // encontramos uno igual en B
Entonces Z(K)  A(I):K  K +1:J=N-1// copiamos a Z, con indice K
FinSi
FinPara
FinPara
muestraVector(Z, K) // pedimos mostrar el vector Z con K elementos
FIN

Para ver si un elemento de A esta en B, apenas lo encontramos ya lo

copiamos, no requerimos comparar con todo el vector (aquí no
necesitamos de la variable bandera para marcar).

En los últimos sub-programas se tiene la asignación J=N-1, que hace

esta asignación ¿?. La respuesta es que esta asignación le
ahorraría al computador algún trabajo ya innecesario que
hace, porque no se da cuenta.

Y cual es ese trabajo innecesario que efectúa ¿?

Suponga el siguiente ejemplo:

En el aula se está tomando un examen (a 150 estudiantes) pero no

se puede interrumpir el mismo, aunque buscan con urgencia a “Pablo
Sotelo” que se supone estaría en el grupo y dicen que no es muy
conocido. Que hacer ¿?

Se podría permitir que sin distraer a los alumnos se busque pupitre

por pupitre, preguntando si alguno de ellos es “Pablo Sotelo”, si se
procede de esta forma se pueden dar 2 situaciones:

Situación 1.- Se recorre todos los pupitres y no se lo encuentra.

Termino la búsqueda.

Situación 2.- En el recorrido pupitre por pupitre, se lo encuentra y

luego que ¿?. Se continua la búsqueda o se suspende ?. ¡SE
SUSPENDE!. Porque de lo contrario, si se prosigue con la búsqueda,
se estaría haciendo algo YA! innecesario.
Por lo tanto, la asignación J=N-1 de líneas arriba, se aplica cuando
se encuentra una Situación 2 como la del ejemplo descrito (que se
da en el programa). Las líneas del programa en el condicional dicen:

Si A(I) = B(J)
Entonces …. : ….. : J=N-1

Y hacen eso que quisiéramos (por lo menos así debe entenderse).

Al cumplirse la condición del condicional se ejecuta la acción y en

ella le estamos diciendo (indirectamente) que acabe la búsqueda,
aunque lo hacemos engañando al Para (le asignamos a J el ultimo
valor que debía tomar para que crea que ya acabo la ejecución del
Para).

Luego con esta acción, cuando el Para re-evalua sus valores supone
que ya acabo su ejecución y obliga a salir de ese bloque Para. Es
decir, suspende la ejecución de ese Para, a fin de no seguir
haciendo una búsqueda innecesaria.

Esta asignación se usara en muchos casos con vectores (problemas)

para acortar cálculos innecesarios.

COMPLETAR LAS OTRAS 2 OPERACIONES CON LOS

RESPECTIVOS SUB-PROGRAMAS.