МНОЖЕСТВА.

Множество - это неупорядоченный набор однотипных элементов. У элемента в множестве нет определенного места; понятие "индекс элемента множества" вообще не имеет смысла. Элемент может либо принадлежать множеству, либо нет - третьего не дано. Где он при этом располагается, не имеет никакого значения.
Отсюда следует, что каждый элемент входит в множество ровно 1 раз, и повторное его добавление ничего не изменит.
Множеством, например, являются "все положительные числа, делящиеся на 50 нацело". Этому множеству принадлежат такие элементы, как

[0,50,100,150...]
Это бесконечное множество, т.к. количество чисел, удовлетворяющих условию, бесконечно.
Множество не обязательно задается каким-то условием. Можно просто объединить несколько элементов без видимой закономерности:

[12,3,64,13,8]
и это тоже будет множество. Число 12, например, входит в это множество, а число 57 - нет. Что будет, если к этому множеству еще раз добавить 12? А ничего. Ведь 12 и так там уже было.

Итак, множество делит некую группу объектов на два класса: принадлежащие множеству и нет.
Множества, применяемые в программах на языке Паскаль, должны удовлетворять нескольким ограничениям:
1. Количество элементов в множестве (еще говорят мощность множества) не должно превышать 255.
2. Числовой эквивалент элементов не должен превышать 255 (под числовым эквивалентом понимается число, возвращаемое функцией ord).
3. Все элементы должны быть одного типа.
4. Разрешается использовать только символьные, булевские, целые и перечислимые типы, удовлетворяющие условию 2.

Объявление типа множества имеет вид
set of <тип элементов>

Из приведенных ограничений следует, что <тип элементов> может быть одним из следующих:
- byte
- char
- boolean
- любой перечислимый размером меньше 255 элементов
- ограниченные символьные типы размером меньше 255 элементов
- ограниченные целые типы размером меньше 255 элементов, разрешаются только числа в диапазоне 0..255.

Чаще всего применяется byte или char. Обратите внимание, что integer применять нельзя, так как он состоит из 65536 элементов, а это немного больше, чем 255.
Когда применяются множества? Когда необходимо разделить какой-то класс объектов по некоторому набору признаков на обладающие этим набором и нет.
Например, среди всех символов надо выделить символы цифр. Или среди всех чисел первой сотни все числа, кратные 3-м.
В таких случаях, один раз построив множество, мы сможем любой элемент проверять на принадлежность ему одним действием, без проверки обладания всеми требуемыми признаками.

В Паскале над множествами определено большое число операций, что делает множества еще более удобным инструментом для решения задач.
 

Правила задания множественных констант.
 

12 - целая константа, '#' - символьная, а как задать множественную?
Есть несколько правил, по которым они строятся. Общий вид множественной константы следующий:

[<элемент>,<элемент>,<элемент>,...]
т.е. это список элементов множества, перечисленных через запятую и заключенных в квадратные скобки. Конечно, все <элементы> должны иметь один и тот же тип из разрешенных. Какой именно - зависит от типа множества ( целое, символьное и т.д.). <элементы> могут быть такие:

1. Константы (например 23 или 'd'). В множество включается сама константа.
2. Переменные соответствующего типа (например, i). В множество включается значение переменной.
3. Выражения соответствующего типа (например, ((i+ 2) mod 4 - 1) ). В множество включается результат выражения.

Кроме того, можно задавать в качестве <элемента> диапазонные выражения вида:
<левая граница> .. <правая граница>

например, 23..34. Это сокращенная запись, означающая включение во множество все значений, лежащих между <левой> и <правой> границами включительно (т.е. 23,24,25,26,27,28,29,30,31,32,33,34 для 23..34). Если <правая граница> меньше <левой>, ни один элемент включен не будет.

Элементы могут повторяться. Независимо от числа включений, они войдут в множество только один раз.
Множественная константа [] обозначает пустое множество (множество, в котором нет ни одного элемента).
Примеры задания множественных констант (пусть i = 2, c = 'a', b = 40):

Множественная константа Получившееся множество
[3, 4, 3, 4, 1, 2, 4] [3,4,1,2]
[3..7, i..( i+2), 5] [3,4,5,6,7,2]
[c, 'x', chr(ord(c)+3), 'f'.. 'h'] ['a', 'x', 'd', 'f', 'g', 'h']
[4.. i+6, 21.. i, 4] [4,5,6,7,8]
[ false, true] [ false, true]
 

Операции над множествами.
 

В Паскале над множествами определены следующие операции:
1. Объединение. Обозначается +. Объединением множеств A и B называется множество, состоящее из всех элементов A и B. Например:
[2,4,5,6] + [3,5,6,1,2] = [2,4,5,6,3,1]

2. Пересечение. Обозначается -. Пересечением множеств A и B называется множество, состоящее из тех элементов, которые принадлежат и A, и B.
Например:
[2,4,5,6] * [3,5,6,1,2] = [2,5,6]

3. Вычитание. Обозначается -. Разностью множеств A и B (A - B) называется множество, состоящее из элементов, принадлежащих A, но не принадлежащих B. Обратите внимание, что (A-B) не равно (B-A)! Примеры:
[2,4,5,6] - [3,5,6,1,2] = [4]
[3,5,6,1,2] - [2,4,5,6] = [1,3]

4. Сравнение. А именно: <=, >=, =, <>. Операции < и > запрещены. Результат определяется по следующим правилам:
( =) множества A и B равны, если они совпадают до последнего элемента (любой элемент A принадлежит B, а любой элемент B принадлежит A).
( <>) множества A и B не равны, если предыдущее условие не выполняется (иначе говоря, если множества различаются хотя бы в одном элементе).
( >=) множество A включается в B (A <= B или B >= A), если все эле-
( <=) менты множества A принадлежат и множеству B (обратное необязательно).

Следующие сравнения истинны:

[2,3,4] = [3,2,4,4]
[2,3,4] <> [3,2]
[2,3] <= [2,3,4]
[2,3,4] => [4,2,3]

5. Включение. Обозначается in. Записывается так:
<элемент> in <множество>
Это логическая операция. Она проверяет, входит ли <элемент> в <множество>. Если да, возвращается true, если нет - false. Например, результат (5 in [6,4..8]) будет true
, а (4 in [1,2]) - false).
 

 Ввод и вывод множеств.
 

Как и массивы, множества надо вводить и выводить поэлементно. Однако техника здесь немного иная. Ввод множества заключается в последовательном вводе его элементов и объединении их с уже введенными:

var m: set of byte;
i, n, k: byte;
...
write('Введите количество элементов в множестве: ');
readln(n);
m := [];
for i := 1 to n do
begin
write('Введите ', i, '-ой элемент: ');
readln(k);
m := m + [k];
end;

 k в операторе присваивания заключена в квадратные скобки. Это превращает ее из целой переменной в множество.

И еще: если при вводе элементов попадались одинаковые, размер множества будет меньше n (так как каждый элемент входит в множество только один раз).

Вывод множества заключается в переборе всех возможных элементов множества и выводе тех, которые на самом деле в множество входят. В примере элементы множества имеют тип byte, а значит элементами могут быть числа от 0 до 255.

write('[');
for i := 0 to 255 do
if i in m then write(i, ',');
{ gotoxy(wherex-1,wherey); этот оператор не обязателен, но желателен }
writeln(']');

Аналогично вводятся и множества других типов