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:
Copiar los elementos de A en un
conjunto auxiliar Aux
que tenga un tipo base compatible con el de A.
Declarar x una
variable del tipo base de Aux
e inicializar x
al primer elemento de esté tipo base.
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.
| Página siguiente |