Un conjunto es una colección de objetos relacionados. Cada objeto en un conjunto es llamado miembro o elemento del conjunto.
Aunque en matemáticas no hay restricciones para que los objetos puedan ser elementos de un conjunto, Pascal sólo ofrece una forma restringida de conjuntos, por lo que :
Representación de conjuntos:
|
Elementos |
Notación Matemática |
Pascal |
|
1,2,3,4,5 |
{1,2,3,4,5} |
[1,2,3,4,5] |
|
a,b,c |
{a,b,c} |
['a','b','c'] |
Aunque se puede utilizar notación de tipo subrango para especificar secuencia de valores que pertenezcan a un conjunto, los elementos del conjunto no tienen una ordenación interna particular. La única relación entre los miembros de un conjunto es: existe o no existe en el conjunto.
[5,5] y [5] son equivalentes (contienen un sólo elemento)
Ejemplos de conjuntos:
|
[1,3,5] |
conjunto de tres enteros |
|
[1..3,8..10] |
conjunto de seis enteros [1,2,3,8,9,10] |
|
[ ] |
conjunto vacío (ningún elemento) |
|
['a','b','A'..'D'] |
conjunto de seis elementos ['a','b','A','B','C','D'] |
Un conjunto especial, denominado conjunto vacío, es aquel que no contiene ningún elemento.
El formato para la definición de un tipo conjunto es :
type
<identificador> = set of <tipo_base>
|
Ejemplos :
Type
dias_mes = set of 0..31;
mayusculas = set of 'A'..'Z';
caracteres = set of char;
equipos = (Chivas,Santos,Pumas,
Toluca,Tigres,America,
Leon);
futbol = set of equipos;
Var
GrupoA,GrupoB : futbol;
En Turbo Pascal, el máximo número de elementos permitidos en un conjunto es 256, y los valores ordinales del tipo base deben estar en el rango de 0 a 255 .
Los elementos se ponen en los conjuntos utilizando una sentencia de asignación.
GrupoA := [Chivas,Santos,Toluca];
GrupoB := [Tigres..Leon];
Si dos tipos de conjuntos son compatibles (tienen los tipos de base compatibles: igual tipo de dato, o uno subrango de otro, o ambos del mismo tipo patrón), sus variables representativas se pueden utilizar en sentencias de asignación.
GrupoA := GrupoB;
GrupoB := [];{asignación del conjunto vacío}
El operador relacional In y una expresión relacional nos permite conocer si un elemento dado pertenece a un conjunto dado.
Formato:
|
elemento in [ lista de elementos ] |
El resultado de evaluar la expresión relacional puede ser true o false. El tipo de datos de elemento y la lista de elementos deben ser compatibles.
Ejemplo:
Program Hasta_Si;
{El siguiente programa obtiene del teclado un nombre
hasta que se presiona la tecla 's' o 'S' o Esc}
Uses Crt;
Const
Esc =#27;
Var
nombre : string[30];
tecla : char;
begin
Repeat
ClrScr;
Write('Escribe tu nombre : ');
ReadLn(nombre);
Write('Desea Salir S/N ? : ');
Tecla:=Readkey
Until tecla in['s','S',Esc];
ClrScr
end.
Una vez creados los conjuntos y las variables tipo conjunto es posible realizar tres operaciones binarias sobre ellos: unión, intersección y diferencia. La siguiente tabla resume el funcionamiento de las operaciones con conjuntos A y B.
|
Operaciones sobre dos conjuntos A y B |
||
|
Operación |
Notación
|
Conjunto resultante |
| Unión |
+ |
A+B es el conjunto que contiene todos los elementos que están en A, en B o en ambos. |
|
Intersección |
* |
A*B es el conjunto cuyos elementos pertenecen a A y B simultáneamente. |
|
Diferencia |
- |
A-B es el conjunto cuyos elementos son de A pero no de B. |
Ejemplo:
|
Operación |
Resultado |
|
[1,3,4,5]+[1,2,4] |
[1,2,3,4,5] |
|
[1,3,4,5]*[1,2,4] |
[1,4] |
|
[1,3,4,5]-[1,2,4] |
[3,5] |
|
[1,2,3]+[ ] |
[1,2,3] |
|
[1,2,4]*[3,5,6] |
[ ] |
|
[1,2,3]-[ ] |
[ ] |
Reglas de prioridad
Cuando una expresión de conjuntos contiene dos o más operadores de conjunto, éstos se evalúan de acuerdo a la siguiente prioridad:
|
* |
Prioridad más alta |
|
+,- |
Prioridad más baja |
En caso de operaciones con igual prioridad se evalúan de izquierda a derecha.
Los conjuntos se pueden comparar entre sí mediante el uso de los operadores relacionales (==, <>,<=,>=). Los operandos deben ser del mismo tipo base. El resultado de la comparación es un valor lógico: true o false.
|
Operadores de relación de conjuntos A y B |
||
|
Operador |
Nombre del operador |
Resultado |
|
< = |
Subconjunto |
El valor de A< = B es true. Si cada elemento de A es también de B. En caso contrario es false. |
|
= |
Igualdad |
El valor de A = B es true si cada elemento de A está en B y cada elemento de B está en A. En caso contrario A = B es falso, A=B equivale a (A<=B) and (B<=A). |
|
< > |
Desigualdad |
El valor de A < > B es true si el valor de A = B es false y viceversa. |
|
> = |
Superconjunto |
A < > B equivale a not (A = B), A >= B es true si B<=A es true. |
Ejemplos :
|
Comparación |
Resultado |
|
[3,5] = [3,5] |
true |
|
[ ] = [1] |
false |
|
[ ] <= [1,5] |
true |
|
[1,2] >= [1,2,3,4] |
false |
|
[ ] >= [1,2] |
false |
|
[1,4,5] = [4,5,1] |
true |
Prioridad de operadores :
|
Operador |
Prioridad |
|
not |
1 (más alta) |
|
*,/,div,mod,and |
2 |
|
+,-,or |
3 |
|
=,<>,<,<=,>,>=,in |
4 (más baja) |
Algunas operaciones no se pueden ejecutar sobre variables de conjunto. Por ejemplo, no se puede leer cinco ciudades en un conjunto Mundo con la siguiente sentencia:
ReadLn(Mundo)
La razón es que la computadora no puede saber cuantos elementos existen en el conjunto.
Si se desea leer y almacenar datos en un conjunto se debe utilizar un bucle.
for elemento:=1 to 5 do begin
{leer un dato}
{almacenar el valor en el siguiente elemento del conjunto}
end;
|
|
Reglas :
|
Los valores de conjuntos no se pueden visualizar con la sentencia Write.
Para visualizar los elementos de un conjunto A se debe utilizar el siguiente algoritmo:
1. Copiar los elementos de A en un conjunto auxiliar Aux que tenga un tipo base compatible con el de A.
2. Declarar x una variable del tipo base de Aux e inicializar x al primer elemento de esté tipo base.
3.
Mientras
x es diferente
del último elemento de esté tipo base y Aux
no está vacía, hacer :
I. Si x
pertenece a Aux,
entonces visualizar x
y eliminarlo de Aux
II. Sustituir x con su sucesor.
Ejemplo:
Program Impares;
{El siguiente programa encuentra y muestra todos los
números impares menores o igual a un número dado n
que esté entre el límite 1..255}
Uses Crt;
Type
numeros = set of 1..255;
Var
impares,Aux :numeros;
x,MaxNum,i :byte;
begin
ClrScr;
Write('Escribe un número entero : ');
ReadLn(MaxNum);
impares:=[]; {inicializa a conjunto vacío}
for i:=1 to MaxNum do
begin
if odd(i) then
impares:=impares + [i]
{añadir elementos al conjunto}
end;
{visualizar elementos del conjunto}
Aux:=impares;
x:=1;
while (x<>MaxNum+1) and (Aux<>[]) do
begin
if x in Aux then
begin
WriteLn(x);
Aux:=Aux-[x]
end;
x:=succ(x)
end;
ReadKey;
ClrScr
end.