Как организовать вывод элементов множества

Множества

Множество представляет собой набор элементов одного типа. Элементы множества считаются неупорядоченными; каждый элемент может входить во множество не более одного раза. Тип множества описывается следующим образом:

В качестве базового может быть любой тип, в том числе строковый и классовый. Исключение составляют типы указателей.

type
ByteSet = set of byte;
StringSet = set of string;
Digits = set of ‘0’..’9′;
SeasonSet = set of (Winter,Spring,Summer,Autumn);
PersonSet = set of Person;

Элементы базового типа сравниваются на равенство следующим образом: у простых типов, строк и указателей сравниваются значения, у структурированных и у классов — значения всех элементов или полей. Однако, если поля относятся к ссылочному типу, то сравниваются только их адреса (неглубокое сравнение).

Чтобы сконструировать значение типа множество, используется так называемый конструктор множества, имеющий вид:

где в списке могут перечисляться через запятую либо выражения базового типа, либо (для порядковых типов) их диапазоны в виде a..b , где a и b — выражения базового типа. Например:

var
bs: ByteSet := [1,3,5,20..25];
fios: StringSet := [‘Иванов’,’Петров’,’Сидорова’];

Значения в списке могут отсутствовать, тогда множество является пустым:

Пустое множество-константа [] совместимо по присваиванию с множеством любого типа. Однако тип пустого множества-константы не выводится автоматически:

Множество, задаваемое конструктором множества, может иметь элементы различных типов, например:

В этом случае вычисляется наиболее общий тип, и он объявляется базовым типом множества. Например:

[1..4,5.5] // set of real
[‘1′,’abc’] // set of string
[1,’1′] // set of object

Для множеств имеет место структурная эквивалентность типов.

Множества целых и множества на базе типа и его диапазонного подтипа или на базе двух диапазонных типов одного базового типа неявно преобразуются друг к другу. Если при присваивании s := s1 во множестве s1 содержатся элементы, которые не входят в диапазон значений базового типа для множества s, то они отсекаются.

var st: set of 3..9;
.
st := [1..5,8,10,12]; // в st попадут значения [3..5,8]

Операция in проверяет принадлежность элемента множеству:

if Wed in bestdays then .

Для множеств определены операции + (объединение), — (разность), * (пересечение), = (равенство), <> (неравенство), = (нестрого содержит) и > (строго содержит).

Процедура Write при выводе множества выводит все его элементы. Например,

выведет [‘Иванов’,’Петров’,’Сидорова’] , при этом данные, если это возможно, будут отсортированы по возрастанию.

Для перебора всех элементов множества можно использовать цикл foreach , данные перебираются в некотором внутреннем порядке:

foreach var s in fios do
Write(s,’ ‘);

Для добавления элемента x к множеству s используется конструкция s += [x] или стандартная процедура Include : Include(s,x) . Для удаления элемента x из множества s используется конструкция s -= [x] или стандартная процедура Exclude : Exclude(s,x) .

Множества в языке Pascal

Множество — это структурированный тип данных, представляющий собой набор взаимосвязанных по какому-либо признаку или группе признаков объектов, которые можно рассматривать как единое целое. Каждый объект в множестве называется элементом множества.

Все элементы множества должны принадлежать одному из порядковых типов, содержащему не более 256 значений. Этот тип называется базовым типом множества. Базовый тип задается диапазоном или перечислением.

Область значений типа множество — набор всевозможных подмножеств, составленных из элементов базового типа. В выражениях на языке Паскаль значения элементов множества указываются в квадратных скобках: [1,2,3,4], [‘а’,‘b’,’с’], [‘a’..’z’].

Если множество не имеет элементов, оно называется пустым и обозначается как []. Количество элементов множества называется его мощностью.

Множество может принимать все значения базового типа. Базовый тип не должен превышать 256 возможных значений. Поэтому базовым типом множества могут быть byte, char, boolean и производные от них типы.

Множество в памяти хранится как массив битов, в котором каждый бит указывает является ли элемент принадлежащим объявленному множеству или нет. Максимальное число элементов множества 256, а данные типа множество могут занимать не более 32 байт.

Число байтов, выделяемых для данных типа множество, вычисляется по формуле: ByteSize = (max div 8) — (min div 8) + 1, где max и min — верхняя и нижняя границы базового типа данного множества.

Номер байта для конкретного элемента Е вычисляется по формуле: ByteNumber = (E div 8) — (min div 8), номер бита внутри этого байта по формуле: BitNumber = E mod 8

Не имеет значения порядок записи элементов множества внутри конструктора. Например, [1, 2, 3] и [3, 2, 1] — это эквивалентные множества.

Каждый элемент в множестве учитывается только один раз. Поэтому множество [1, 2, 3, 4, 2, 3, 4, 5] эквивалентно [1..5].

Переменные множественного типа описываются так:
Var : set of ;

Var A, D : Set Of Byte; B : Set Of 'a'..'z'; C : Set Of Boolean;

Нельзя вводить значения во множественную переменную процедурой ввода и выводить процедурой вывода.

Множественная переменная может получить конкретное значение только в результате выполнения оператора присваивания:
:= ;

A : = [50, 100, 150, 200]; B : = ['m', 'n', 'k']; C : = [True, False]; D : = A;

Кроме того, выражения могут включать в себя операции над множествами.

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

Объединением двух множеств A и B называется множество, состоящее из элементов, входящих хотя бы в одно из множеств A или B. Знак операции объединения в Паскале «+».

1) [1, 2, 3, 4] + [3, 4, 5, 6] => [1, 2, 3, 4, 5, 6] 2) []+[‘a’..’z’]+[‘A’..’E’, ‘k’] => [‘A’..’E’, ‘a’..’z’] 3) [5 [false, true]

Пересечением двух множеств A и B называется множество, состоящее из элементов, одновременно входящих во множество A и во множество B.

Знак операции пересечения в Паскале «*»

1) [1, 2, 3, 4] * [3, 4, 5, 6] => [3, 4] 2) [‘a’..’z’]*[‘A’..’E’, ‘k’] => [‘k’] 3) [5 []

Разностью двух множеств A и B называется множество, состоящее из элементов множества A, не входящих во множество B.

1a) [1, 2, 3, 4] - [3, 4, 5, 6] => [1, 2] 1b) [3, 4, 5, 6] - [1, 2, 3, 4] => [5, 6] 2a) [‘a’..’z’]-[‘A’..’E’, ‘k’] => [‘a’..’j’, ‘i’..’z’] 2b) [‘A’..’E’, ‘k’] - [‘a’..’z’] => [‘A’..’E’] 3a) [5 [false] 3b) [true] - [5 [true]

Операция вхождения. Это операция, устанавливающая связь между множеством и скалярной величиной, тип которой совпадает с базовым типом множества. Если x — такая скалярная величина, а M — множество, то операция вхождения записывается так: x in M.

Результат — логическая величина true, если значение x входит в множество M, и false — в противном случае.

Например, 4 in [3, 4, 7, 9] –– true, 5 in [3, 4, 7, 9] –– false.

Используя данную операцию, можно не только работать с элементами множества, но и, даже если в решении задачи явно не используются множества, некоторые логические выражения можно записать более лаконично.

1) Натуральное число n является двухзначным. Вместо выражения (n >= 10) and (n можно записать n in [10..99] .

2) Символ c является русской буквой. Вместо выражения (c >= ‘А’) and (c =‘а’) and (c =‘р’) and (c пишем c in [‘А’.. ‘Я’, ‘а’.. ‘п’, ‘р’.. ‘я’] и т.д.

Добавить новый элемент в множество можно с использованием операции объединения. Например, a:= a+[5] Для этих же целей в Turbo Pascal 7.0 предназначена процедура Include: include (M, A) M – множество, A – переменная того же типа, что и элементы множества M. Тот же пример можно записать так: Include (a, 5)

Исключить элемент из множества можно с помощью операции «разность множеств». Например, a:= a-[5] Для этих же целей в Turbo Pascal 7.0 предназначена процедура Exclude: exclude (M, A) M – множество, A – переменная того же типа, что и элементы множества M. Тот же пример можно записать так: Exclude (a, 5)

Рассмотрим несколько примеров использования множеств при решении задач.

Задача 1. В городе имеется n высших учебных заведений, которые производят закупку компьютерной техники. Есть шесть компьютерных фирм: «Диалог», «Avicom», «Нэта», «Сервер», «Декада», «Dega.ru». Ответить на следующие вопросы:
1) в каких фирмах закупка производилась каждым из вузов?
2) в каких фирмах закупка производилась хотя бы одним из вузов?
3) в каких фирмах ни один из вузов не закупал компьютеры?

Решим задачу с использованием множеств. Для удобства дальнейших манипуляций в порядке следования занумеруем компьютерные фирмы, начиная с единицы. Занесём информации о месте закупок компьютеров каждым из вузов в отдельное множество.

Ответ на первый вопрос можно получить, выполнив пересечение всех таких множеств.

Ответ на второй вопрос – результат объединения множеств.

И, наконец, на последний – разность множества всех фирм и множества фирм, где хотя бы один вуз делал покупки.

program ex_set_1; type firma = set of 1..6; v = array[0..20] of firma; const f: array [1..6] of string[10] = ('Диалог', 'Avicom', 'Нэта', 'Сервер', 'Декада', 'Dega.ru'); procedure vvod(var a: firma); var i: byte; ans: 0..1; begin a:= []; for i := 1 to 6 do begin Write('Вуз покупал компьютеры в фирме ', f[i], ' (1 - да, 0 - нет)? '); ReadLn(ans); if ans = 1 then a:=a+[i] end; end; procedure Print(a : firma); var i: byte; begin for i := 1 to 6 do if i in a then write(f[i]:10); writeln end; procedure Rez1(a: v; n : byte; var b : firma); var i : byte; begin b := [1..6]; for i := 0 to n-1 do b := b * a[i]; end; procedure Rez2(a: v; n : byte; var b : firma); var i : byte; begin b := []; for i := 0 to n-1 do b := b + a[i]; end; var a: v; n, i : byte; c : firma; begin write('Сколько вузов делали закупку? '); readln(n); for i := 0 to n-1 do vvod(a[i]); Rez1(a, n, c); writeln('Каждый из вузов закупил компьютеры в фирмах: '); Print(c); Rez2(a, n, c); writeln('Хотя бы один из вузов закупил компьютеры в фирмах: '); Print(c); writeln('Ни один из вузов не закупил компьютеры в фирмах: '); Print([1..6]-c); end.

Задача 2. Сгенерировать n множеств (нумерацию начать с 1). Вывести элементы, которые входят во все множества с номерами, кратными трём, но не входят в первое множество.

program ex_set_2; type mn = set of byte; v = array[1..30] of mn; procedure vvod(var a: mn); var i, n, vsp: byte; begin a:= []; n := 1 +random(200); for i := 1 to n do begin vsp:= random(256); a:=a+[vsp] end; end; procedure Print(a : mn); var i: byte; begin for i := 0 to 255 do if i in a then write(i:4); writeln end; procedure Rez(a: v; n : byte; var b : mn); var i : byte; begin b := [0..255]; i:= 3; while i 
Задача 3. Дана строка. Сохранить в ней только первые вхождения символов, удалив все остальные.
program ex_set_3; var m : set of char; s : string; i : byte; begin write('Введите строку: '); readln(s); m :=[]; i := 1; while i 

  
Что такое множество?
  
Почему множество является структурированным типом данных?
  
Как хранится множество в памяти ЭВМ? Какой максимальный объем оперативной памяти может быть отведен под хранение одного множества?
  
Какие операции можно выполнять над множествами?
  
Как добавить элемент в множество?
  
Как исключить элемент из множества?
  
Как вывести элементы множества? Как подсчистать количество элементов в множестве?
  
Как может быть использована операция вхождения?


Как организовать вывод элементов множества
  
Загрузка. Пожалуйста, подождите.
Правила раздела!
1. Заголовок или название темы должно быть информативным ! 
2. Все тексты фрагментов программ должны помещаться в теги [code] . [/code] или [code=pas] . [/code]. 
3. Прежде чем задавать вопрос, см. "FAQ" и используйте 4. НЕ используйте форум для личного общения! 
5. Самое главное - это раздел теоретический, т.е. никаких задач и программ (за исключением небольших фрагментов) - для этого есть отдельный раздел! 

Вывод множеств, Как вывести на экран множества
21.01.2006 16:35
 
Группа: Пользователи 
Сообщений: 17 
Пол: Женский
Репутация: 0 
for i:=1 to N do
if (i in m1) then write(i)

или есть другой способ?

21.01.2006 16:41
Нет. Только этот. Вывод множества - только полным перебором элементов и проверкой на наличие.
Кстати, и математически понятие "извлечение элемента из множества" не определено .
21.01.2006 16:49
Группа: Пользователи 
Сообщений: 17 
Пол: Женский
Репутация: 0 
В продолжение темы. 
Я так понимаю, что операция сравнения m1[1]>m1[2] со множеством m1 тоже не проходит? Как тогда можно подмнжество, состоящее только из гласных букв отсортировать по алфавиту? Я извиняюсь за настойчивость, но я раньше со множествами работала очень мало, а в faq тоже материла не много.
Теоретический материал (Паскаль)
Множественный тип данных. Множество. Элемент множества. Способы задания множества. Объединение множеств. Разность множеств. Пересечение множеств
Множественный тип данных напоминает перечислимый тип данных. Вместе с тем, множество - набор элементов, не организованных в порядке следования. В математике множество - любая совокупность элементов произвольной природы. Понятие множества в программировании значительно уже математического понятия. Определение. Под множеством в Паскале понимается конечная совокупность элементов, принадлежащих некоторому базовому типу. В качестве базовых типов могут использоваться: перечислимые типы данных, символьный и байтовый типы или диапазонные типы на их основе. Такие ограничения связаны с формой представления множества в языке и объясняются тем, что функция Ord для элементов используемого базового типа должна быть в пределах от 0 до 255. Множество имеет зарезервированное слово set of и вводится следующим описанием


Type 
 < имя типа >= set of < имя базового типа >;
Var 
< идентификатор. >:< имя типа >;


Рассмотрите примеры описаний множеств:


Type 
SetByte = set of byte;  
SetChisla = set of 10 .. 20;  
Symbol = set of char;  
Month = (January, February, March, April, May, June, July, August, September, October, November, December); 
Season = set of Month; 
Var 
Letter, Digits, Sign : Symbol;  
Winter, Spring, Summer, Autumn, Vacation, WarmSeason : Season; 
Index : SetChisla=[12, 15, 17]; 
Operation : set of (Plus, Minus, Mult, Divid); 
Param : set of 0..9=[0, 2, 4, 6, 8];


Для переменных типа множества в памяти отводится по 1 биту под каждое возможное значение базового типа. Так, под переменные Letter, Digits, Sign будет отведено по 256/8=32 байта. Для переменной Winter, базовый тип которой (Month) имеет 12 элементов, необходимо 2 байта, причем второй используется только наполовину. Если множество содержит какой-то элемент, то связанный с ним бит имеет значение 1, если нет - 0. Для того, чтобы дать переменной множества какое-то значение, используют либо конструктор множества - перечисление элементов множества через запятую в квадратных скобках:


Sign:=['+', '-'];
Spring:=[March, April, May];
b:=[ 'k', 'l', 'd' ]


либо определение через диапазон. В этом случае в множество включены все элементы диапазона.


Digits:=['0'..'9'];
WarmSeason := [May .. September];


Обратите внимание, что в определении множества Digits использованы символы в таблице ASCII-кодов, а не целые числа. Обе формы конструирования могут сочетаться:


Vacation:=[January, February, June .. August];


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


Const 
YesOrNo = ['Y', 'y', 'N', 'n']; 

Const 
Digits : set of char=['0'..'9']; 
DigitsAndLetter : set of char=['0'..'9', 'a'..'z', 'A'..'Z']; 
Const 
Yes = ['Y', 'y']; 
No = ['N', 'n']; 
YesOrNo = Yes+No;


Объединение множеств (+)
Определение. Объединением двух множеств называется третье множество, включающее все элементы, которые принадлежат хотя бы одному из множеств-операндов, при этом каждый элемент входит в объединение множеств только один раз. Объединение множеств записывается как операция сложения.


Type 
Symbol = set of char; 
Var 
SmallLatinLetter, CapitalLatinLetter, LatinLetter : Symbol;
Begin 
. . . . . . 
SmallLatinLetter :=['a'..'z']; 
CapitalLatinLetter := ['A'..'Z']; 
LatinLetter := SmallLatinLetter+CapitalLatinLetter; 
. . . . . . 
End.


В операции объединения множеств могут участвовать и отдельные элементы множества. Например, допустима следующая запись, где два элемента и множество объединяются в новое множество:


WarmSeason := May+Summer+September;


или другая запись
которую можно применить для организации множества в цикле, если заменить множество ['c'] переменной Sym того же типа, что и множество B, и считывать с клавиатуры данные в переменную Sym, объединяя ее затем с множеством В.
Разность множеств (-)
Определение. Разностью двух множеств является третье множество, которое содержит все элементы 1-го множества, не входящие во 2-е множество.
Если в вычитаемом множестве есть элементы, отсутствующие в уменьшаемом, они не влияют на результат.


Summer := WarmSeason-Spring-Autumn;
Summer := WarmSeason-May-September;


Модуль System содержит процедуры для включения элемента в множество


Include(Var S : set of T; Element : T);


и исключения из множества


Exclude(Var S : set of T; Element : T);


где S - множество элементов типа Т, а Element - включаемый (или исключаемый) элемент. Эти функции отличаются от операций объединения и вычитания множеств только тем, что генерируют более эффективный код.
Пересечение множеств
Определение. Пересечением множеств называется множество, содержащее все элементы, одновременно входящие в оба множества-операнда. Операция обозначается знаком умножения.


Summer := WarmSeason*Vacation;


Логические операции над множествами: проверка принадлежности элемента множеству, проверка включения элемента в множество, сравнение множеств
Определение. Множества считаются равными, если все элементы, содержащиеся в одном множестве, присутствуют в другом, и наоборот. В соответствии с этим правилом определяется результат операций сравнения "=" и "<>". Например,


If WarmSeason*Vacation=Summer 
Then 
Writeln ('Правильно');


Задание. Сравните множества М1 и М2, пользуясь рисунками.
Проверка включения
Определение. Одно множество считается входящим в другое, если все элементы первого множества содержатся во втором, при этом обратное в общем случае может быть несправедливо. Операции проверки вхождения одного множества в другое записываются как " ="


if S1 then 
writeln ('S1 входит в S2');
if S1>=S2 
then 
writeln ('S2 входит в S1');


Задание. Подумайте, что напечатает оператор Write в каждом из случаев: 1.


if Vacation>=Summer 
then 
writeln ('Правильно') 
else 
writeln ('Неправильно');




if Vacation then 
writeln ('Правильно') 
else 
writeln ('Неправильно');


Проверка принадлежности
Операция проверки принадлежности элемента множеству записывается с использованием оператора in. Например, выражение


May in WarmSeason


имеет значение True. Использование множеств и операции in позволяет, в частности, сделать эффективнее проверку правильности вводимых символов. Например, для проверки допустимости введенного символа можно использовать следующее условие:


(Reply='y') or (Reply='Y') or (Reply='n') or (Reply='N')


Но если ввести множество


Const 
AllowSymbol : set of char = ['Y', 'y', 'N', 'n'];


проверяемое условие можно записать в более компактной форме:


Reply in AllowSymbol


Задание. Наберите рассмотренную программу, откомпилируйте ее. Проверьте работу программы, исполняя ее по шагам и наблюдая текущие значения переменных i, X, M в окне просмотра. Попробуйте задать значения числа большие 50, повторно задавать одинаковые значения Х и анализируйте значения множества М. Дополните программу выводом на экран содержимого полученного множества. Откомпилируйте программу.
Примеры решения задач на применение множеств
Пример 1. Описать множества гласных и согласных букв русского языка, определить количество гласных и согласных букв в предложении, введенном с клавиатуры. Зададим тип Letters - множество букв русского языка, затем опишем переменные этого типа: Glasn - множество гласных букв, Sogl - множество согласных букв. Вводимое с клавиатуры предложение опишем переменной Text типа String. Для указания номера символа в строке Text применим переменную i типа byte. Для подсчета количества гласных и согласных букв опишем переменные G и S. Проверку принадлежности символов, составляющих предложение, множеству гласных или согласных букв русского языка организуем с использованием оператора цикла For. Параметр цикла i, изменяясь от 1 до значения длины предложения, будет указывать порядковый номер символа в предложении. Принадлежность очередного символа предложения множеству гласных или согласных букв проверим с помощью операции in. Если выполняется условие Text[i] in Sogl, тогда увеличивается на 1 счетчик S. Если выполняется условие Text[i] in Glasn, тогда увеличивается на 1 счетчик G. Если не выполняется ни первое, ни второе условие, значит, очередной символ в предложении не является гласной или согласной буквой русского языка. Теперь рассмотрите текст программы:


Program GlasnSogl;
Type 
Letters = set of 'A'..'я';
Var 
Glasn, Sogl : Letters; 
Text : String; 
i, G, S : byte;
Begin 
Glasn := ['A', 'а', 'Е', 'е', 'И', 'и', 'О', 'о', 'У', 'у', 'ы','Э', 'э', 'Ю', 'ю', 'Я', 'я', 'Ё', 'ё']; 
Sogl := ['Б'..'Д', 'б'..'д', 'Ж', 'ж', 'З', 'з', 'К'..'Н', 'к'..'н', 'П'..'Т', 'п'..'т', 'Ф'..'Щ', 'ф'..'щ', 'ь', 'ъ']; 
Write('Введите предложение '); 
Readln(Text); 
G := 0; 
S := 0; 
For i := 1 to Length(Text) do 
Begin 
If Text[i] in Glasn 
Then 
G := G+1; 
If Text[i] in Sogl 
Then 
S := S+1; 
End; 
Write('В предложении " ', Text, ' " ', G, ' гласных и ', S, ' согласных букв');
End.


Задание. Усовершенствуйте программу, дополните комментарием. Если у Вас возникла идея решения этой задачи с помощью другого алгоритма, - дерзайте. Пример 2. Поиск простых чисел с помощью решета Эратосфена в числовом промежутке [1 .. N]. В теме "Целочисленная арифметика" Вы решали задачи на поиск простых чисел в заданном диапазоне различными способами. Здесь мы рассмотрим ту же задачу, но применим для ее решения знания, полученные при изучении темы "Множества".  Примечание. Вспомним, что простым числом называется число, не имеющее делителей, кроме единицы и самого себя. Идея метода "решета Эратосфена" заключается в следующем: сформируем множество М, в которое поместим все числа заданного промежутка. Затем последовательно будем удалять из него элементы, кратные 2, 3, 4, и так далее до целой части числа [N/2], кроме самих этих чисел. После такого "просеивания" в множестве М останутся только простые числа. Рассмотрите вариант решения этой задачи.


Program Resheto;
Var 
M : set of byte; 
i, k, N : Integer;
Begin 
Writeln('Введите размер промежутка (до 255) '); 
Readln(N); 
M := [2..N]; 
For k := 2 to N div 2 do 
For i := 2 to N do 
If (i mod k=0) and (i<>k) 
Then 
M := M-[i]; 
For i := 1 to N do 
If i in M 
Then 
Write(i:3); 
Readln;
End.



Как сформировано множество М?
Как организован просмотр элементов этого множества?
Как организован просмотр делителей?
Как удаляется элемент множества?
Как организован вывод "просеянного" множества?

Если Вы внимательно рассмотрели решение этой задачи и правильно ответили на вопросы, Вы должны были заметить, что алгоритм решения задачи можно улучшить.
Задание. Улучшите алгоритм решения предложенной задачи. Протестируйте программу и дополните ее комментариями.
Примечание. Если Вы затрудняетесь при выполнении задания, то вот Вам подсказки:

   Например, вы знаете, что если из множества М удалены все элементы, делящиеся на 2, то нет смысла проверять, делятся ли оставшиеся числа на 4, 6, 8, 10, и т.д. 


Пример 3. Разгадывание ребусов.
Каждая буква - это цифра, разным буквам соответствуют разные цифры. Необходимо заменить буквы цифрами так, чтобы получилось верное равенство. Найти все решения. Для решения этой задачи используется метод перебора с возвратом. Используем множество S1 для хранения цифр слова МУХА, причем будем вносить в него цифры последовательно, учитывая уже внесенные цифры. Начальное значение S1 - пустое множество. После выбора всех цифр первого слова создаем его числовой эквивалент и числовой образ слова СЛОН. Выделяем цифры СЛОНа (множество S2), и если слова состоят из разных цифр (то есть пересечение S1 и S2 пустое), и все цифры СЛОНа разные, то выводим решение на экран. Если же нет, то идет возврат - удаляем из множества S1 последнюю внесенную цифру и пытаемся выбрать еще одно значение. Таким образом, мы перебираем все возможные варианты и выводим на экран только те, которые удовлетворяют равенству.
Заметим, что значение буквы М в слове МУХА может иметь значения от 1 до 4, а буква А в этом же слове не может быть равна 0.
Рассмотрите решение задачи.


Program Rebus;
Type 
MN = set of 0..9;
Var 
digit, m, u, h, a : 0..9; 
i, n1, n2 : Integer; 
S1, S2 : MN; 
f : boolean;
Procedure Print(x, y : Integer);
Begin 
write(x); 
write(' + '); 
write(x); 
write(' = '); 
writeln(y); 
writeln;
End;
Begin 
S1 := [ ]; 
for m := 1 to 4 do 
begin 
S1 := S1+[m]; 
for u := 0 to 9 do 
if Not(u in S1) 
then 
begin 
S1 := S1+[u]; 
for h := 0 to 9 do 
if Not (h in S1) 
then 
begin 
S1 := S1+[h]; 
for a := 1 to 9 do 
if Not (a in S1) 
then 
begin 
S1 := S1+[a]; 
n1 := 1000*m+100*u+10*h+a;  
n2 := 2*n1;  
f := true;  
S2 := [ ]; 
for i := 1 to 4 do 
begin 
digit := n2 mod 10;  
n2 := n2 div 10; 
f := f and not (digit in s2);  
S2 := [digit] + S2; 
end; 
if (S1*S2=[ ]) and f  
then 
Print (n1, 2 * n1); 
S1 := S1-[a]; 
end; 
S1 := S1-[h]; 
end; 
S1 := S1-[u]; 
end; 
S1 := S1-[m]; 
end; 
Readln;
End.


Задание. Решите один из ребусов:

П Ч Ё Л К А x 7 = ЖЖЖЖЖЖ
ТОРГ x Г = ГРОТ
ЛАДЬЯ+ЛАДЬЯ = ФЕРЗЬ
М3 = КУБ
СМ3 = КУБИК
МАТЕ * М = АТИКА
ПРОП * О = РЦИЯ
ПРОП : О = РЦИЯ
(М + О + С +К + В + А)4 = МОСКВА
ВЕТКА + ВЕТКА = ДЕРЕВО
САР = АТОВ
ПЛОМБА * 5 = АПЛОМБ
НИКЕЛЬ * 6 = ЕЛЬНИК
КВАНТ * 30 = ЖУРНАЛ
КАПЛЯ + КАПЛЯ + КАПЛЯ + = ОЗЕРКО
СОРОК * 5 = ДВЕСТИ
SIX * TWO = TWELVE
ДВЕСТИ * 5 = ТЫСЯЧА
НАТАША + ТОНЯ = СЁСТРЫ
БРА2 = БОМДОР

Пример 4. Рассмотрите специальную процедуру ввода положительных целых чисел, которая запрещает набор иных символов, кроме цифр, и ограничивает число используемых символов.


Procedure ReadWord(Var Result : Word; x, y, MaxLength : byte);
Const 
ValidSymbol : set of char=['0'..'9',#8,#13];
Var 
Str : string; 
Code : integer; 
Key : char;
Begin 
GoToXY(x, y); 
Str := '';  
repeat  

repeat 
Key := ReadKey 
until Key in ValidSymbol; 
case Key of  
'0'..'9' :  
if Length(Str)>=MaxLength  
then 
begin 
Sound(100);  
Delay(200); 
NoSound; 
end 
else  
begin 
write(Key); 
Str:=Str+Key;  
end; 
#8 :  
if Length(Str)>0  
then 
begin 
Delete(Str, Length(Str),1);  
GoToXY(WhereX-1, WhereY);  
write(' ');  
GoToXY(WhereX-1, WhereY);  
end 
else  
begin 
Sound(100);  
Delay(200); 
NoSound; 
end; 
#13 :  
begin 
Val(Str, Result, Code);  
Exit  
end; 
end;  
until False; 
End;


В заголовке процедуры Result - возвращаемое число; MaxLength - максимальное число цифр в записи числа; х, у - координаты начальной позиции вывода. Процедура формирует текстовую строку Str, состоящую из цифр. При нажатии клавиши Enter строка преобразуется в целочисленную переменную.
В начале программы курсор направляется в заданную точку, и текстовой строке присваивается пустое значение. Далее начинается бесконечный цикл, заданный оператором Repeat . Until False. Выход из цикла происходит вместе с выходом из процедуры по команде Exit. "Бесконечность" цикла обеспечивает произвольное число повторов и исправлений при вводе числа.
Процедура реагирует только на нажатие цифровых клавиш, клавиш Enter и BackSpace. Назначение клавиш - традиционное: Enter используется для завершения процедуры, BackSpace - для стирания последнего введенного символа.


repeat 
Key := ReadKey 
until Key in ValidSymbol;


проверяет вводимые символы на допустимость. Множество допустимых символов ValidSymbol определено в процедуре как константа, оно включает цифровые символы и символы, соответствующие клавишам Enter и BackSpace. Первая имеет символьный код #13, вторая - #8.
Далее оператор Case производит выбор одного из трех направлений - обработка нажатой цифры, обработка клавиши BackSpace или обработка клавиши Enter. При нажатой цифре сначала проверяют, не достигло ли число цифр максимального значения. Число цифр определяется функцией Length, аргумент которой - редактируемая строка. Если длина уже достигла максимального значения, выдается звуковой сигнал. Если длина вводимой строки меньше максимальной, то в строку дописывается символ, и он же выводится на экран процедурой Write.
При нажатии клавиши BackSpace должен быть стерт последний введенный символ. Вначале производится проверка, есть ли в строке символы. Если строка пуста, подается звуковой сигнал, если нет - начинается удаление символа. Для этого строка уменьшается на один элемент процедурой Delete, курсор возвращается назад на одну позицию, на место стираемой цифры записывается символ пробела, затем курсор снова возвращается на позицию назад. Возврат курсора обеспечивается оператором GoToXY(WhereX-1, WhereY), который использует функции WhereX и WhereY для определения текущего положения курсора и уменьшает координату х на 1.
После нажатия Enter строка преобразуется в целочисленную переменную процедурой Val, и происходит выход из процедуры ReadWord по команде Exit.
В этой процедуре показано, что ввод данных и другие процедуры, связанные с работой оператора, должны, как правило, иметь защиту от ошибочных действий. В данном примере это обеспечивается тем, что процедура блокирует неправильные нажатия клавиш и ограничивает длину строки.
Поскольку все проверки усложняют программу, требование защиты от возможных ошибок программиста не является обязательным. Вопрос в том - надеется ли программист на свою аккуратность при использовании собственных процедур.
Задание*. Составьте программу для проверки входных данных другого типа.
Как организовать вывод элементов множества
Загрузка. Пожалуйста, подождите.
Правила раздела!
1. Заголовок или название темы должно быть информативным ! 
2. Все тексты фрагментов программ должны помещаться в теги [code] . [/code] или [code=pas] . [/code]. 
3. Прежде чем задавать вопрос, см. "FAQ" и используйте 4. НЕ используйте форум для личного общения! 
5. Самое главное - это раздел теоретический, т.е. никаких задач и программ (за исключением небольших фрагментов) - для этого есть отдельный раздел! 

Вывод множеств, Как вывести на экран множества

21.01.2006 16:35
Группа: Пользователи 
Сообщений: 17 
Пол: Женский
Репутация: 0 
for i:=1 to N do
if (i in m1) then write(i)

или есть другой способ?

21.01.2006 16:41
Нет. Только этот. Вывод множества - только полным перебором элементов и проверкой на наличие.
Кстати, и математически понятие "извлечение элемента из множества" не определено .
21.01.2006 16:49
Группа: Пользователи 
Сообщений: 17 
Пол: Женский
Репутация: 0 
В продолжение темы. 
Я так понимаю, что операция сравнения m1[1]>m1[2] со множеством m1 тоже не проходит? Как тогда можно подмнжество, состоящее только из гласных букв отсортировать по алфавиту? Я извиняюсь за настойчивость, но я раньше со множествами работала очень мало, а в faq тоже материла не много.
Множества в Pascal
В Pascal множества обладают рядом особенностей. Все элементы одного множества должны принадлежать одному и тому же базовому типу. В качестве базового типа должен выступать порядковый тип, но не каждый.
Размер множества в Паскале ограничен предельно допустимым количеством элементов. Во множествах допускаются только такие элементы, порядковые значения которых в их базовых типах не выходят за границы 0..255. Для целочисленных множеств это означает, что в них могут присутствовать только числа от 0 до 255. Отрицательные элементы во множествах не допускаются.
Поэтому базовым типом не может выступать, например, integer . Если необходимо множество целочисленных объектов, то базовый тип должен объявлен как диапазон типа byte . Для символьных множеств базовым типом является char (в нем 256 значений с порядковыми номерами от 0 до 255).
Объявление множеств
В математике для обозначения множества используют фигурные скобки, например , в Паскале — квадратные, например [1, 3, 5]. Порядок элементов во множестве не имеет значения. Так множества [3, 6, 9] и [9, 3, 6] одинаковы.
По форме записи объявление переменной типа множество сходно с объявлением одномерного массива:
var имя: set of тип;
Например, объявление переменной ch как множества с базовым типом char , имеет вид:
var ch: set of char;
Можно сначала объявить тип множества, а потом использовать его для объявления переменных:
type t_ch = set of char; var ch1, ch2: t_ch;
Часто в качестве базового типа используются перечисления и диапазоны:
type week_days = (Mon, Tue, Wed, Thu, Fri); var work_days: set of week_days; lett: set of 'A'..'Z';
type nums = 5..25; var a: set of nums;
Объявление переменной-множества не присваивает ей набора значений.
Построение множества
Чтобы во множестве появились элементы, необходимо выполнить оператор присваивания, в левой части которого стоит имя переменной-множества, а в правой — конструктор множества или некоторое выражение над множествами.
Конструктор множества — это заключенный в квадратные скобки перечень элементов, разделенных запятыми. В качестве элементов могут использоваться диапазоны значений:
type week_days = (Mon, Tue, Wed, Thu, Fri); var work_days: set of week_days; lett: set of 'A'..'Z'; begin work_days := [Mon, Wed, Thu]; lett := ['C', 'E'..'M', 'Z'] end.
Следует помнить, что при задании множества порядок его элементов безразличен, но при задании диапазона такой порядок важен.
Множество, в котором нет элементов, называется пустым (или нуль-множеством). В языке программирования Паскаль обозначается квадратными скобками, между которыми нет элементов:
work_days := [ ];
Множество может быть объявлено типизированной константой, для чего в описании после знака равенства следует указать конструктор множества. Например:
const lett: set of ['а'..'я'] = ['а', 'е', 'и', 'о', 'у', 'ы', 'э', 'ю', 'я'];
Конструируя множества, можно использовать и переменные при условии, что их текущие значения попадают в диапазон базового типа множества. Так, если ch1 и ch2 имеют тип char , то допустима следующая последовательность операторов:
ch1 := 'A'; ch2 := 'K'; chs := [ch1, ch2, 'M'];
В результате получится множество ['A', 'K', 'M'].
Вывод элементов множества
В Pascal элементы множества нельзя вводить и выводить. Для организации их ввода-вывода следует использовать вспомогательные переменные. В то же время можно использовать множества как элементы типизированных файлов.
type nums = 0..10; var a: set of nums; i: byte; begin a := [3, 0, 2]; for i := 0 to 10 do if i in a then writeln(i); end.
0 2 3
Операции над множествами

присвоение
объединение
пересечение
дополнение
тождественность
нетождественность
содержится во множестве
содержит множество
принадлежность элемента множеству


Объединение, пересечение и разность множеств
Над множествами выполнимы объединение (+), пересечение (*) и разность (-).
Объединение двух множеств A и B (A + B) – это новое множество, состоящее из элементов, принадлежащих множеству A или B, либо тому и другому одновременно.
var chs1, chs2, chs3: set of char; begin chs1 := ['a', 'b', 'd']; chs2 := ['m', 'd', 'e']; chs3 := chs1 + chs2 + ['k', 'n']; end.
Результат: chs3 = ['a', 'b', 'd', 'm', 'e', 'k', 'n'].
Пересечение двух множеств A и B (A * B) – это множество, состоящее из элементов, одновременно принадлежащих множествам A и B.
chs3 := chs1 * chs2;
Результат: chs3 = ['d'] .
Разность (дополнение) множеств A и B (A - B) – это новое множество, состоящее из элементов множества A, не вошедших в множество B.
chs1 := ['a', 'e', 't']; chs2 := chs1 – ['e'] < ['a', 't'] >chs3 := ['m', 'n', 't'] – chs2
Используя операции объединения, пересечения и разности, можно добавлять элементы к множествам или удалять их.
Для вставки и удаления элементов при работе с множествами в Pascal введены две процедуры:
include(имя_множества, элемент) exclude(имя_множества, элемент)
Первая из них позволяет выполнить добавление одного элемента в указанное множество, а вторая удалить. Например:
include (chs1, 'g'); < аналогично chs1 + ['g'] >exclude (chs2, 'a');
Операции сравнения множеств
Над множествами можно выполнять четыре операции сравнения: =, <>, >=, 
Два множества A и B равны (A = B), если каждый элемент множества A является элементом множества B и наоборот.
Два множества A и B не равны (A <> B), если они отличаются хотя бы одним элементом.
Другими словами, операции = и <> используются для проверки эквивалентности: два значения переменной типа set считаются равными, если они состоят из одних и тех же элементов.
[1, 3] = [3, 1] возвращает true, 
[1..3] = [1, 2, 3] возвращает true, 
[1] <> [2] возвращает true, 
[1, 2, 3] = [1, 4, 3] возвращает false, 
[red, blue] = [red, yellow] возвращает false. 
Множество A является подмножеством множества B (A = A), если каждый элемент из A присутствует в B.
Пустое множество [ ] содержится во всех множествах, т.е. всегда [ ] 
in - операция проверки принадлежности элемента множеству
Имеется возможность выяснить, принадлежит ли данный элемент некоторому множеству. Для этого служит операция in . Пусть A – множество элементов некоторого базового типа, а x – переменная этого типа. Тогда выражение x in A истинно, если значение x является элементом множества A .
red in [red, yellow] возвращает true ; 
red in [blue, green] возвращает false .
Замечание 1. Чтобы проверить, является ли значение n цифрой, удобно использовать операцию in следующим образом:
if n in [0..9] then …
Замечание 2. Результат операции in может быть неопределенным в некоторых случаях. Пусть:
a: set of 1..50; x: integer.
Если присвоить x число, большее максимального значения 50 (например, x := 55 ), то в этом случае результат операции x in a не всегда false .
Все операции сравнения множеств, а также операция in возвращают логическое значение true или false .
Приоритеты операций над множествами
В сложных выражениях над множествами операции имеют следующие приоритеты:
Множества
Множество представляет собой набор элементов одного типа. Элементы множества считаются неупорядоченными; каждый элемент может входить во множество не более одного раза. Тип множества описывается следующим образом:
В качестве базового может быть любой  тип, в том числе строковый и классовый. Исключение составляют типы указателей.

type 
ByteSet = set of byte; 
StringSet = set of string; 
Digits = set of '0'..'9'; 
SeasonSet = set of (Winter,Spring,Summer,Autumn); 
PersonSet = set of Person;

Элементы базового типа сравниваются на равенство следующим образом: у простых типов, строк и указателей сравниваются значения, у структурированных и у классов - значения всех элементов или полей. Однако, если поля относятся к ссылочному типу, то сравниваются только их адреса (неглубокое сравнение).
Чтобы сконструировать значение типа множество, используется так называемый конструктор множества, имеющий вид:
где в списке могут перечисляться через запятую либо выражения базового типа, либо (для порядковых типов) их диапазоны в виде a..b , где a и b - выражения базового типа. Например:

var 
bs: ByteSet := [1,3,5,20..25]; 
fios: StringSet := ['Иванов','Петров','Сидорова'];

Значения в списке могут отсутствовать, тогда множество является пустым:
Пустое множество-константа [] совместимо по присваиванию с множеством любого типа. Однако тип пустого множества-константы не выводится автоматически:
Множество, задаваемое конструктором множества, может иметь элементы различных типов, например:
В этом случае вычисляется наиболее общий тип, и он объявляется базовым типом множества. Например:

[1..4,5.5] // set of real
['1','abc'] // set of string
[1,'1'] // set of object

Для множеств имеет место структурная эквивалентность типов.
Множества целых и множества на базе типа и его диапазонного подтипа или на базе двух диапазонных типов одного базового типа неявно преобразуются друг к другу. Если при присваивании s := s1 во множестве s1 содержатся элементы, которые не входят в диапазон значений базового типа для множества s, то они отсекаются.

var st: set of 3..9; 
. 
st := [1..5,8,10,12]; // в st попадут значения [3..5,8]

Операция in проверяет принадлежность элемента множеству:

if Wed in bestdays then .

Для множеств определены операции + (объединение), - (разность), * (пересечение), = (равенство), <> (неравенство), = (нестрого содержит) и > (строго содержит).
Процедура Write при выводе множества выводит все его элементы. Например,
выведет ['Иванов','Петров','Сидорова'] , при этом данные, если это возможно, будут отсортированы по возрастанию.
Для перебора всех элементов множества можно использовать цикл foreach , данные перебираются в некотором внутреннем порядке:

foreach var s in fios do 
Write(s,' ');

Для добавления элемента x к множеству s используется конструкция s += [x] или стандартная процедура Include : Include(s,x) . Для удаления элемента x из множества s используется конструкция s -= [x] или стандартная процедура Exclude : Exclude(s,x) .
Множества в Python

Множество — неупорядоченный набор элементов. Каждый элемент в множестве уникален (т. е. повторяющихся элементов нет) и неизменяем.

Само по себе множество можно изменять, то есть удалять или добавлять элементы.
Множества удобно использовать для выполнения математических операций: объединение, пересечение, симметрическая разность и т. д.
Как создать множество
Множество объявляется так: элементы помещаются в фигурные скобки <> и разделяются запятыми. Сделать это можно и с помощью встроенной функции set() .
Внутри множества может быть любое количество элементов любого типа (целые числа, числа с плавающей точкой, кортежи, строки и т. д.). Внутрь множества нельзя помещать элементы изменяемых типов: списки, другие множества или словари.
# Разные виды множеств # Множество с целыми числами my_set = print(my_set) # Множество с разными типами данных my_set = print(my_set)
Вывод:
# Внутри множества не может быть одинаковых элементов # Вывод: my_set = print(my_set) # Аргументом функции set() может быть список # Вывод: my_set = set([1, 2, 3, 2]) print(my_set) # Внутри множества не может быть изменяемых объектов # В этом множестве [3, 4] — изменяемый список # Поэтому следующая строка вызовет ошибку my_set =
Вывод:


Traceback (most recent call last): 
File "", line 15, in  
my_set = 
TypeError: unhashable type: 'list'
Создание пустого множество — дело хитрое.
Пустые фигурные скобки <> — это словарь. Чтобы объявить пустое множество, нужно использовать функцию set() без аргументов.
# Обратим внимание на объявление пустого множества # Объявление с помощью <> a = <> # Проверка типа a print(type(a)) # Объявление с помощью set() a = set() # Проверка типа a print(type(a))
Вывод:
Как изменять множество
Множества изменяемы и не упорядочены. Поэтому в индексации нет никакого смысла.
Так что получить доступ к элементам с помощью индексов или срезов не получится. Множества просто не поддерживают эти операции.
Чтобы добавить один элемент, нужно использовать метод add() . Если нужно добавить несколько элементов — метод update() . Метод update() принимает в качестве аргументов кортежи, списки или другие множества. Во всех случаях следует избегать одинаковых элементов.
# создаем my_set my_set = print(my_set) # вызов my_set[0] приведет к ошибке # TypeError: 'set' object does not support indexing # добавляем элемент # Вывод: my_set.add(2) print(my_set) # добавляем несколько элементов # Вывод: my_set.update([2, 3, 4]) print(my_set) # добавляем список и множество # Вывод: my_set.update([4, 5], ) print(my_set)
Вывод:
Как удалять элементы из множества
Определенный элемент множества можно удалить с помощью методов discard() и remove() .
Разница между ними вот в чем. Если элемент, который вы хотите удалить с помощью discard() , отсутствует в множестве — оно не изменится. А вот remove() вызовет ошибку, если элемента нет в множестве.
# разница между discard() и remove() # создаем my_set my_set = print(my_set) # удаление элемента # с помощью discard # Вывод: my_set.discard(4) print(my_set) # удаление элемента # с помощью remove # Вывод: my_set.remove(6) print(my_set) # удаление элемента, # отсутствующего в my_set, # с помощью discard # Вывод: my_set.discard(2) print(my_set) # При удалении элемента, # отсутствующего в my_set, # с помощью remove # вы получите ошибку. # Вывод: KeyError my_set.remove(2)
Вывод:




Traceback (most recent call last): 
File "", line 28, in 
KeyError: 2
Удалить и вернуть элемент мы можем с помощью метода pop() .
Так как множество — неупорядоченный тип данных, невозможно определить, какой из элементов будет удален. Это произойдет случайным образом.
Удалить все элементы из множества можно с помощью метода clear() .
# cоздаем my_set # Вывод: множество уникальных элементов my_set = set("Приветмир") print(my_set) # pop элемента # Вывод: случайный элемент print(my_set.pop()) # pop еще одного элемента my_set.pop() print(my_set) # очищаем my_set # Вывод: set() my_set.clear() print(my_set)
Вывод:

П

set()
Операции со множествами
Множества можно использовать для выполнения математических операций вроде объединения, пересечения, симметрической разности и т. д. Сделать это можно с помощью операторов и методов.
Рассмотрим два множества и проведем с ними разные операции.
A = 
B =
Объединение

Результат бъединения A и B — множество, содержащее в себе все элементы множеств A и B.

Операцию объединения можно произвести двумя способами: с помощью оператора | и метода union() .
# Операция объединения двух множеств # Создаем множества A и B A = B = # Используем оператор | # Вывод: print(A | B)
Вывод: 
Попробуйте ввести следующие примеры в консоль:
# используем функцию union >>> A.union(B) # используем функцию union с B >>> B.union(A)
Пересечение

Результат пересечения A и B — множество, которому принадлежат те и только те элементы, которые одновременно принадлежат всем данным множествам

Операцию объединения можно произвести двумя способами: с помощью оператора & и метода intersection() .
# Пересечение множеств # Создаем множества A и B A = B = # Используем оператор & # Вывод: print(A & B)
Вывод:
Попробуйте ввести следующие примеры в консоль:
# использование метода intersection с A >>> A.intersection(B) # использование метода intersection с B >>> B.intersection(A)
Разность

Результат разности множеств B и A — множество элементов, содержащихся только в A. Следовательно, B-A = множество элементов, содержащихся только в B.

Операцию объединения можно произвести двумя способами: с помощью оператора - и метода difference() .
# Разность двух множеств # Создаем множества A и B A = B = # Используем оператор - с A # Вывод: print(A - B)
Вывод:
Попробуйте ввести следующие примеры в консоль:
# Использование функции difference с A >>> A.difference(B) # Использование оператора - с B >>> B - A # Использование функции difference с B >>> B.difference(A)
Симметрическая разность

Результат симметрической разности множеств A и B — множество элементов, содержащихся и в A, и в B, но не в обоих сразу. Иначе говоря, исключается только пересечение множеств.

Операцию объединения можно произвести двумя способами: с помощью оператора ^ и метода symmetric_difference() .
# Симметрическая разность множеств A и B # Создаем множества A и B A = B = # Используем оператор ^ # Вывод: print(A ^ B)
Вывод:
Попробуйте ввести следующие примеры в консоль:
# Использование функции symmetric_difference с A >>> A.symmetric_difference(B) # Использование функции symmetric_difference с B >>> B.symmetric_difference(A)
Методы множеств
У множеств много методов, некоторые мы уже обсудили выше. Вот полный список методов объекта set :
Метод
Описание
Добавляет элемент в множество
Удаляет все элементы из множества
Возвращает копию множества
Возвращает новое множество — разность двух или более множеств
Удаляет все элементы одного набора из другого
Удаляет элемент, если он содержится в множестве (если элемента в множестве нет, то ничего не происходит)
Возвращает новое множество — пересечение двух множеств
Добавляет в множество пересечение с другим множеством или с самим собой
Возвращает True , если два множества не имеют пересечения
Возвращает True , если определенное множество содержится в другом множестве
Возвращает True , если в множестве есть другое множество
Удаляет и возвращает случайный элемент множества. Если множество пусто, то возвращает ошибку KeyError
Удаляет определенный элемент множества. Если элемент отсутствует в множестве, то возвращает ошибку KeyError
Возвращает новое множество — симметрическую разность двух множеств
Добавляет в множество симметрическую разницу с другим множеством или с самим собой
Возвращает новое множество — объединение множеств
Добавляет в множество объединение с другим множеством или с самим собой
Несколько операций со множествами
Проверка на вхождение
Мы можем проверить, есть ли элемент в множестве. Сделать это можно с помощью ключевого слова in .
# Использование ключевого слова in # Создаем множество my_set my_set = set("яблоко") # Проверяем, есть ли 'о' в множестве # Вывод: True print('о' in my_set) # Проверяем, отсутствует ли 'к' в множестве # Output: False print('к' not in my_set)
Вывод:
True
False
Итерирование по множеству
Множество можно перебрать с помощью цикла for .
for letter in set("яблоко"): print(letter) 
Вывод:
я
о
л
к
б
Встроенные функции множеств
Функция
Описание
Возвращает True , если все элементы множества истинны или множество пустое
Возвращает True , если хоть один элемент множества истинен. Если множество пустое, возвращает False
Возвращает перечисляемый объект. В нем в виде пар содержатся значения и индексы всех элементов множества
Возвращает длину (количество элементов) множества
Возвращает наибольший элемент множества
Возвращает наименьший элемент множества
Возвращает отсортированный список, в котором находятся элементы множества (само множество не сортируется)
Возвращает сумму всех элементов множества
Frozenset
Frozenset — класс, имеющий характеристики множества. Отличие состоит в том, что frozenset после объявления неизменяем.

Кортеж — неизменяемый список, frozenset — неизменяемое множество.

Множества изменяемы, поэтому не могут использоваться в качестве ключей словаря. Frozenset же неизменяемы — их можно использовать в качестве ключей словаря.
Этот тип данных поддерживает следующие методы: copy() , difference() , intersection() , isdisjoint() , issubset() , issuperset() , symmetric_difference() и union() . Так как он неизменяем, методы add() и remove() с ним не работают.
# Frozenset # Создаем множества A и B A = frozenset([1, 2, 3, 4]) B = frozenset([3, 4, 5, 6])
Попробуйте ввести следующие примеры в консоль:
>>> A.isdisjoint(B) False >>> A.difference(B) frozenset() >>> A | B frozenset() >>> A.add(3) . AttributeError: 'frozenset' object has no attribute 'add' ```


Похожие публикации:

Вернуться к конфигурации бд что это в 1с
Как запустить антивирус в безопасном режиме
Как проверить наушники самсунг на оригинальность
Как сделать перенос картинки на следующую строку