You are on page 1of 4

PROBLEMA : CONJUNTOS

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:
Unión, Diferencia A menos B, Diferencia B menos A e Intersección.

Intersección: Son los números que están en ambos conjuntos


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
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.
Un conjunto no necesita estar ordenado pero no debe tener
elementos repetidos.

Por ejemplo:
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 Interseccion 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}

LA SOLUCION ??
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 simple un
conjunto puede ser un vector. Luego necesitamos
inicialmente 2 vectores A y B con M y N elementos
respectivamente.

LA PROGRAMACION ???
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, B, M, N) // mandamos a calcular la intersección
AmenosB(A, B, M, N) // mandamos a calcular A - B
BmenosA(A, B, M, N) // mandamos a calcular B - A
AunionB(A, B, M, N) // mandamos a calcular la unión
FIN

Debemos tener en cuenta que cargaVector() no nos asegura que el


vector no tenga elementos repetidos, pero que se puede resolver
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 harán 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.

Luego, la solución está 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 un
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 uno del conjunto de
B. Los no marcados se copian al vector Z.

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 un entero,


Procedimiento AmenosB(int A[ ], int M, int B[ ], int N)
recibe el que indica cuantos
Int Z(20), I, J, K : String R
INICIO Vector A elementos hay en
//Haremos la comparación de cada elemento A 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” // 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// 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).

COMPLETE LAS OTRAS 2 OPERACIONES CON LOS


RESPECTIVOS SUB-PROGRAMAS.

You might also like