Жанр: Учеба
Программирование в теоремах и задачах
...ться истинным. Им соответствуют несколько начал
образца, являющихся концами входного слова. Но конечный автомат
помнит лишь самое длинное из них. Как же остальные?
Философский ответ. Дело в том, что самое длинное из них определяет
все остальные - это его концы, одновременно являющиеся
его началами.
Не составляет труда для любого конкретного образца написать
программу, осуществляющую поиск этого образца описанным способом.
Однако хотелось бы написать программу, которая ищет произвольный
образец в произвольном слове. Это можно делать в два
этапа: сначала по образцу строится таблица переходов конечного
автомата, а затем читается входное слово и состояние преобразуется
в соответствии с этой таблицей. Подобный метод часто используется
для более сложных задач поиска (см. далее), но для
поиска подслова существует более простой и эффективный алгоритм,
называемый алгоритмом Кнута - Морриса - Пратта. Но прежде нам
понадобятся некоторые вспомогательные утверждения.
10.3. Вспомогательные утверждения
Для произвольного слова X рассмотрим все его начала, одновременно
являющиеся его концами, и выберем из них самое длинное.
(Не считая, конечно, самого слова X.) Будем обозначать его n(X).
Примеры: n(aba)=a, n(abab)=ab, n(ababa)=aba, n(abc) = пустое
слово.
10.3.1. Доказать, что все слова n(X), n(n(X)), n(n(n(X)))
и т.д. являются началами слова X.
Решение. Каждое из них (согласно определению) является началом
предыдущего.
По той же причине все они являются концами слова X.
10.3.2. Доказать, что последовательность предыдущей задачи
обрывается (на пустом слове).
Решение. Каждое слово короче предыдущего.
Задача. Доказать, что любое слово, одновременно являющееся
началом и концом слова X (кроме самого X) входит в последовательность
n(X), n(n(X)),...
Решение. Пусть слово Y есть одновременно начало и конец X.
Слово n(X) - самое длинное из таких слов, так что Y не длиннее
n(X). Оба эти слова являются началами X, поэтому более короткое
из них является началом более длинного: Y есть начало n(X). Аналогично,
Y есть конец n(X). Рассуждая по индукции, можно предполагать,
что утверждение задачи верно для всех слов короче X, в
частности, для слова n(X). Так что слово Y, являющееся концом и
началом n(X), либо равно n(X), либо входит в последовательность
n(n(X)), n(n(n(X))), ..., что и требовалось доказать.
10.4. Алгоритм Кнута - Морриса - Пратта
Алгоритм Кнута - Морриса - Пратта (КМП) получает на вход
слово
X = x[1]x[2]...x[n]
и просматривает его слева направо буква за буквой, заполняя при
этом массив натуральных чисел l[1]..l[n], так что
l[i] = длина слова n(x[1]...x[i])
(функция n определена в предыдущем пункте). Словами: l[i] есть
длина наибольшего начала слова x[1]..x[i], одновременно являющегося
его концом.
10.4.1. Какое отношение все это имеет к поиску подслова?
Другими словами, как использовать алгоритм КМП для определения
того, является ли слово A подсловом слова B?
Решение. Применим алгоритм КМП к слову A#B, где # - специальная
буква, не встречающаяся ни в A, ни в B. Слово A является
подсловом слова B тогда и только тогда, когда среди чисел в массиве
l будет число, равное длине слова A.
10.4.2. Описать алгоритм заполнения таблицы l[1]..l[n].
Решение. Предположим, что первые i значений l[1]..l[i] уже
найдены. Мы читаем очередную букву слова (т.е. x[i+1]) и должны
вычислить l[i+1].
1 i i+1
--------------------------------------------------------
| уже прочитанная часть X | |
--------------------------------------------------------
\-----------Z-----------/ \------------Z------------/
Другими словами, нас интересуют начала Z слова x[1]..x[i+1], одновременно
являющиеся его концами - из них нам надо выбрать самое
длинное. Откуда берутся эти начала? Каждое из них получается
из некоторого слова Z' приписыванием буквы x[i+1]. Слово Z' является
началом и концом слова x[1]..x[i]. Однако не любое слово,
являющееся началом и концом слова x[1]..x[i], годится - надо,
чтобы за ним следовала буква x[i+1].
Получаем такой рецепт отыскания слова Z. Рассмотрим все начала
слова x[1]..x[i], являющиеся одновременно его концами. Из
них выберем подходящие - те, за которыми идет буква x[i+1]. Из
подходящих выберем самое длинное. Приписав в его конец x[i+1],
получим искомое слово Z.
Теперь пора воспользоваться сделанными нами приготовлениями
и вспомнить, что все слова, являющиеся одновременно началами и
концами данного слова, можно получить повторными применениями к
нему функции n из предыдущего раздела. Вот что получается:
i:=1; l[1]:= 0;
{таблица l[1]..l[i] заполнена правильно}
while i "" n do begin
| len := l[i]
| {len - длина начала слова x[1]..x[i], которое является
| его концом; все более длинные начала оказались
| неподходящими}
| while (x[len+1] "" x[i+1]) and (len " 0) do begin
| | {начало оказалось неподходящим, применяем к нему n}
| | len := l[len];
| end;
| {нашли подходящее или убедились в отсутствии}
| if x[len+1] = x[i+1] do begin
| | {x[1]..x[len] - самое длинное подходящее начало}
| | l[i+1] := len+1;
| end else begin
| | {подходящих нет}
| | l[i+1] := 0;
| end;
| i := i+1;
end;
10.4.3. Доказать, что число действий в приведенном только
что алгоритме не превосходит Cn для некоторой константы C.
Решение. Это не вполне очевидно: обработка каждой очередной
буквы может потребовать многих итераций во внутреннем цикле. Однако
каждая такая итерация уменьшает len по крайней мере на 1, и
в этом случае l[i+1] окажется заметно меньше l[i]. С другой стороны,
при увеличении i на единицу величина l[i] может возрасти
не более чем на 1, так что часто и сильно убывать она не может -
иначе убывание не будет скомпенсировано возрастанием.
Более точно, можно записать неравенство
l[i+1] "= l[i] - (число итераций на i-м шаге) + 1
или
(число итераций на i-м шаге) "= l[i] - l[i+1] + 1
и остается сложить эти неравества по всем i и получить оценку
сверху для общего числа итераций.
10.4.4. Будем использовать этот алгоритм, чтобы выяснить,
является ли слово X длины n подсловом слова Y длины m. (Как это
делать с помощью специального разделителя #, описано выше.) При
этом число действий будет не более C*(n+m), и используемая память
тоже. Придумать, как обойтись памятью не более Cn (что может
быть существенно меньше, если искомый образец короткий, а
слово, в котором его ищут - длинное).
Решение. Применяем алгоритм КМП к слову A#B. При этом вычисление
значений l[1],...,l[n] проводим для слова X длины m и
запоминаем эти значения. Дальше мы помним только значение l[i]
для текущего i - кроме него и кроме таблицы l[1]..l[n], нам для
вычислений ничего не нужно.
На практике слова X и Y могут не находиться подряд, поэтому
просмотр слова X и затем слова Y удобно оформить в виде разных
циклов. Это избавляет также от хлопот с разделителем.
10.4.5. Написать соответствующий алгоритм (проверяющий, является
ли слово X=x[1]..x[n] подсловом слова Y=y[1]..y[m]).
Решение. Сначала вычисляем таблицу l[1]..l[n] как раньше.
Затем пишем такую программу:
j:=0; len:=0
{len - длина максимального начала слова X, одновременно
являющегося концом слова y[1]..j[j]}
while (len "" n) and (j "" m) do begin
| while (x[len+1] "" y[j+1]) and (len " 0) do begin
| | {начало оказалось неподходящим, применяем к нему n}
| | len := l[len];
| end;
| {нашли подходящее или убедились в отсутствии}
| if x[len+1] = y[j+1] do begin
| | {x[1]..x[len] - самое длинное подходящее начало}
| | len := len+1;
| end else begin
| | {подходящих нет}
| | len := 0;
| end;
| i := i+1;
end;
{если len=n, слово X встретилось; иначе мы дошли до конца
слова Y, так и не встретив X}
10.5. Алгоритм Бойера - Мура
Этот алгоритм делает то, что на первый взгляд кажется невозможным:
в типичной ситуации он читает лишь небольшую часть
всех букв слова, в котором ищется заданный образец. Как так может
быть? Идея проста. Пусть, например, мы ищем образец "abcd".
Посмотрим на четвертую букву слова: если, к примеру, это буква
"e", то нет никакой необходимости читать первые три буквы. (В
самом деле, в образце буквы "e" нет, поэтому он может начаться
не раньше пятой буквы.)
Мы приведем самую простой вариант этого алгоритма, который
не гарантирует быстрой работы во всех случаях. Пусть x[1]..x[n]
- образец, который надо искать. Для каждого символа s найдем самое
правое его вхождение в слово X, то есть наибольшее k, при
котором x[k]=s. Эти сведения будем хранить в массиве pos[s]; если
символ s вовсе не встречается, то нам будет удобно положить
pos[s] = 0 (мы увидим дальше, почему).
10.5.1. Как заполнить массив pos?
Решение.
положить все pos[s] равными 0
for i:=1 to n do begin
pos[x[i]]:=i;
end;
В процессе поиска мы будем хранить в переменной last номер буквы
в слове, против которой последняя буква образца. Вначале last = m
(длине образца), затем постепенно увеличивается.
last:=m;
{все предыдущие положения образца уже проверены}
while last "= m do begin {слово не кончилось}
| if x[m] "" y[last] then begin {последние буквы разные}
| | last := last + (m - pos[y[last]]);
| | {m - pos[y[last]] - это минимальный сдвиг образца,
| | при котором напротив y[last] встанет такая же
| | буква в образце. Если такой буквы нет вообще,
| | то сдвигаем на всю длину образца}
| end else begin
| | если нынешнее положение подходит, т.е. если
| | x[1]..x[m] = y[last-m+1]..y[last],
| | то сообщить о совпадении;
| | last := last+1;
| end;
end;
Знатоки рекомендуют проверку совпадения проводить справа налево,
т.е. начиная с последней буквы образца (в которой совпадение заведомо
есть). Можно также немного сэкономить, произведы вычитание
заранее и храня не pos[s], а m-pos[s], т.е. число букв в образце
справа от последнего вхождения буквы s.
Возможны разные модификации этого алгоритма. Например, можно
строку last:=last+1 заменить на last:=last+(m-u), где u - координата
второго справа вхождения буквы x[m] в образец.
10.5.2. Как проще всего учесть это в программе?
Решение. При построении таблицы pos написать
for i:=1 to n-1 do...
в основной программе вместо last:=last+1 написать
last:= last+m-pos[y[last]];
Приведенная нами упрощенный вариант алгоритма Бойера - Мура
в некоторых случаях требует существенно больше n действий (число
действий порядка mn), проигрывая алгоритму Кнута - Морриса -
Пратта.
10.5.3. Привести пример ситуации, в которой образец не входит
в слово, но авлгоритму требуется порядка mn действий, чтобы
это установить.
Решение. Пусть образец имеет вид baaa..aa, а само слово
состоит только из букв a. Тогда на каждом шаге несоответствие
выясняется лишь в последний момент.
Настоящий (не упрощенный) алгоритм Бойера - Мура гарантирует,
что число действий не првосходит C*(m+n) в худшем случае. Он
использует идеи, близкие к идеям алгоритма Кнута - Морриса -
Пратта. Представим себе, что мы сравнивали образец со входным
словом, идя справа налево. При этом некоторый кусок Z (являющийся
концом образца) совпал, а затем обнаружилось различие: перед
Z в образце стоит не то, что во входном слове. Что можно сказать
в этот момент о входном слове? В нем обнаружен фрагмент, равный
Z, а перед ним стоит не та буква, что в образце. Эта информация
может позволить сдвинуть образец на несколько позиций вправо без
риска пропустить его вхождение. Эти сдаиги следует вычислить заранее
для каждого конца Z нашего образца. Как говорят знатоки,
все это (вычисление таблицы сдвигов и использовани ее) можно
уложэить в C*(m+n) действий.
10.6. Алгоритм Рабина
Этот алгоритм основан на простой идее. Представим себе, что
в слове длины m мы ищем образем длины n. Вырежем окошечко размера
n и будем двигать его по входному слову. Нас интересует, не
совпадает ли слово в окошечке с заданным образцом. Сравнивать по
буквам долго. Вместо этого фиксируем некоторую функцию на словах
длины n. Если значения этой функции на слове в окошечке и на образце
различны, то совпадения нет. Только если значения одинаковы,
нужно проверять совпадение по буквам.
Что мы выигрываем при таком подходе? Казалось бы, ничего -
ведь чтобы вычислить значение функции на слове в окошечке, все
равно нужно прочесть все буквы этого слова. Так уж лучше их сразу
сравнить с образцом. Тем не менее выигрыш возможен, и вот за
счет чего. При сдвиге окошечка слово не меняется полностью, а
лишь добавляется буква в конце и убирается в начале. Хорошо бы,
чтобы по этим данным можно было бы легко рассчитать, как меняется
функция.
10.6.1. Привести пример удобной для вычисления функции.
Решение. Заменим все буквы в слове и образце их номерами,
представляющими собой целые числа. Тогда удобной функцией является
сумма цифр. (При сдвиге окошечка нужно добавить новое число
и вычесть пропавшее.)
Для каждой функции существуют слова, к которым она применима
плохо. Зато другая функция в этом случае может работать хорошо.
Возникает идея: надо запасти много функций и в начале работы
алгоритма выбирать из них случайную. (Тогда враг, желающий подгадить
нашему алгоритму, не будет знать, с какой именно функцией
ему бороться.)
10.6.2. Привести пример семейства удобных функций.
Решение. Выберем некоторое число p (желательно простое,
смотри далее) и некоторый вычет x по модулю p. Каждое слово длины
n будем рассматривать как последовательность целых чисел (заменив
буквы кодами). Эти числа будем рассматривать как коэффициенты
многочлена степени n-1 и вычислим значение этого многочлена
по модулю p в точке x. Это и будет одна из функций семейства
(для каждой пары p и x получается, таким образом, своя функция).
Сдвиг окошка на 1 соответствует вычитанию старшего члена, умножению
на x и добавлению свободного члена.
Следующее соображение говорит в пользу того, что совпадения
не слишком вероятны. Пусть число p фиксировано и к тому же простое,
а X и Y - два различных слова длины n. Тогда им соответствуют
различные многочлены (мы предполагаем, что коды всех
букв различны - это возможно при p, большем числа букв алфавита).
Совпадение значений функции означает, что в точке x эти два
различных многочлена совпадают, то есть их разность обращается в
0. Разность есть многочлен степени n-1 и имеет не более n-1 корней.
Таким образом, если n много меньше p, то случайному x мало
шансов попасть в неудачную точку.
10.7. Более сложные образцы и автоматы
Мы можем искать не конкретно слово, а подслова заданного
вида. Например, можно искать слова вида a?b, где вместо ? может
стоять любая буква (иными словами, нас интересует буква b на
расстоянии 2 после буквы a).
10.7.1 Указать конечный автомат, проверяющий, есть ли во
входном слове фрагмент вида a?b.
Решение. Читая слово, следует помнить, есть ли буква a на
последнем месте и на предпоследнем - пока не встретим искомый
фрагмент. Получаем такой автомат:
Старое состояние Очередная буква Новое состояние
00 a 01
00 не a 01
01 a 11
01 не a 10
10 a 01
10 b найдено
10 не a и не b 00
11 a 11
11 b найдено
11 не a и не b 10
Другой стандартный знак в образце - это звездочка (*), на
место которой может быть подставлено любое слово. Например, образец
ab*cd означает, что мы ищем подслово ab, за которым следует
что угодно, а затем (на любом расстоянии) следует cd.
10.7.2. Указать конечный автомат, проверяющий, есть ли во
входном слове образец ab*cd (в описанном только что смысле).
Решение.
Старое состояние Очередная буква Новое состояние
нач a a
нач не a нач
a b ab
a a a
a не a и не b нач
ab c abc
ab не c ab
abc d найдено
abc c abc
abc не с и не d ab
Еще один вид поиска - это поиск любого из слово некоторого
списка.
10.7.3. Дан список слов X[1],...,X[k] и слово Y. Определить,
входит ли хотя бы одно из слов X[i] в слово Y (как подслово).
Количество действий не должно превосходить константы, умноженной
на суммарную длину всех слов (из списка и того, в котором
происходит поиск).
Решение. Очевидный способ состоит в том, чтобы каждое слово
из списка проверять отдельно (с помощью одного из рассмотренных
алгоритмов). Однако при этом мы не укладываемся в заданное число
действий (из-за умножения k на длину слова Y).
Посмотрим на дело с другой стороны. Каждому образцу из
списка соответствует конечный автомат с некоторым множество состояний.
Их можно объединить в один автомат, множеством состояний
которого будет произведение множеств состояний всех тех автоматов.
Это - очень большое множество. Однако на самом деле
большинство его элементов недоступны (не могут появиться при
чтении входного слова) и за счет этого получается экономия. Примерно
эту идею (но в измененном виде) мы и будем использовать.
Вспомним алгоритм Кнута - Морриса - Пратта. В нем, читая
входное слово, мы хранили наибольшее начало образца, являющееся
концом прочитанной части. Теперь нам следует хранить для каждого
из образцов наибольшее его начало, являющееся концом прочитанной
части. Решающим оказывается такое замечание: достаточно хранить
самое длинное из них - все остальные по нему восстанавливаются
(как наибольшие начала образцов, являющиеся его концами).
Склеим все образцы в дерево, объединив их совпадающие начальные
участки. Например, набору образцов
{aaa, aab, abab}
соответствует дерево
a/ *
a a / b
* --- * --- * --- *
\b a b
\ * --- * --- *
Формально говоря, вершинами дерева являются все начала всех образцов,
а сыновья вершины получаются приписыванием буквы.
Читая входное слово, мы двигаемся по этому дереву: текущая вершина
- это наибольшая (самая правая) из вершин, являющихся концом
прочитанной части (=наибольший конец прочитанной части, являющийся
началом одного из образцов).
Определим функцию n, аргументами и значениями которой являются
вершины дерева. Именно, n(P) = наибольшая вершина дерева, являющаяся
концом P. (Напомним, вершины дерева - это слова.) Нам понадобится
такое утверждение:
10.7.4. Пусть P - вершина дерева. Докажите, что множество
всех вершин, являющихся концами P, равно {n(P), n(n(P)),...}
Решение. См. доказательство аналогичного утверждения для
алгоритма Кнута - Морриса - Пратта.
Теперь ясно, что нужно делать, находясь в вершине P и читая
букву y входного слова. Надо просматривать последовательно вершины
P, n(P), n(n(P)) и т.д., пока не обнаружится такая, из которой
выходит стрелка с буквой y. Та вершина, в которую эта
стрелка ведет, и будет нашим следующим положением.
Остается понять, как для каждой вершины дерева вычислить
указатель на значение функции n в этой вершине. Это делается как
раньше, при этом значения n для более коротких слов используются
при вычислении очередного значения функции n. Это означает, что
вершины дерева следует просматривать в порядке возрастания их
длины. Нетрудно понять, что все это можно уложить в требуемое
число действий (хотя константа зависит от числа букв в алфавите).
Относящиеся к этому подробности см. в главе об алгоритмах
на графах.
Можно поинтересоваться, какие свойства слов можно распознавать
с помощью конечных автоматов. Оказывается, что существует
просто описываемый класс образцов, задающий все такие свойства -
класс регулярных выражений.
Определение. Пусть фикисирован конечный алфавит Г, не содержащий
символов 'l', 'e', '(', ')', '*' и '|' (они будут использоваться
для построения регулярных выражений и не должны перемешиваться
с буквами). Регулярные выражения строятся по таким
правилам:
(а) буква алфавита Г - регулярное выражение;
(б) символы 'l', 'e' - регулярные выражения;
(в) если A,B,C,..,E - регулярные выражения, то (ABC...E) -
регулярное выражение.
(г) если A,B,C,..,E - регулярные выражения, то
(A|B|C|...|E) - регулярное выражение.
(д) если A - регулярное выражение, то A* - регулярное выра-
жение.
Каждое регулярное выражение задает множество слов в алфавите Г
по таким правилам:
(а) букве соответствует одноэлементное множество, состоящее
из однобуквенного слова, состоящего из этой буквы;
(б) символу 'e' соответствует пустое множество, а символу
'l' - одноэлементное множество, единственным элементом
которого является пустое слово;
(в) регулярному выражению (ABC...E) соответствует множество
всех слов, которые можно получить, если к слову из A
приписать слово из B, затем из C,..., затем из E ("кон-
катенация" множеств);
(г) регулярному выражению (A|B|C|...|E) соответствует
объединение множеств, соответствующих выражениям
A,B,C,..,E;
(д) регулярному выражению A* соответствует "итерация" мно-
жества, соответствующего выражению A, то есть множество
всех слов, которые можно так разрезать на куски, что
каждый кусок принадлежит множеству, соответствующему
выражению A. (В частности, пустое слово всегда содер-
жится в A*.)
Примеры
Выражение Множество
(a|b)* все слова из букв a и b
(aa)* все слова из четного числа букв a
(l|a|b|aa|ab|ba|bb) любое слово из не более чем 2 букв a,b
10.7.5. Написать регулярное выражение, которому соответствует
множество всех слов из букв a и b, в которых число
букв a четно.
Решение. Выражение b* задает все слова без a, а выражение
(b* a b* a b*)
- все слова ровно с двумя буквами a. Остается объединить эти
множества, а потом применить итерацию:
((b* a b* a b*) | b*)*
10.7.6. Написать регулярное выражение, которое задает множество
всех слов из букв a,b,c, в которых слово bac является
подсловом.
Решение. ((a|b|c)* bac (a|b|c)*)
Теперь задачу о поиске образца в слове можно переформулировать
так: проверить, принадлежит ли слово множеству, соответствующему
данному регулярному выражению.
10.7.7. Какие выражения соответствуют образцам a?b и ab*cd,
рассмотренным ранее? (В образце '*' используется не в том смысле,
что в регулярных выражениях!) Предполается, что алфавит содержит
буквы a,b,c,d,e.
Решение. ((a|b|c|d|e)* a (a|b|c|d|e) b (a|b|c|d|e)*) и
((a|b|c|d|e)* ab (a|b|c|d|e)* cd (a|b|c|d|e)*).
10.7.8. Доказать, что для всякого регулярного выражения
можно построить конечный автомат, который распознает соответствующее
этому выражению множество слов.
Решение. Нам потребуется новое понятие - понятие источника
(или недетерминированного конечного автомата). Представим себе
ориентированный граф - картинку из нескольких точек (вершин) и
некоторых стрелок, соединяющих эти точки (ребер). Пусть на некоторых
ребрах написаны буквы (не обязательно на всех). Пусть также
среди вершин выбраны две - начальная Н и конечная К. Такая
картинка называется источником.
Будем двигаться различными способами из Н в К, читая буквы
по дороге (на тех стрелках, где они есть). Каждому пути из Н в
К, таким образом, соответствует некоторое слово. А источнику в
целом соответствует множество слов - тех слов, которые можно
прочесть на путях из Н в К.
Замечание. Если нарисовать состояния конечного автомата в
виде точек, а переходы при чтении букв изобразить в виде стрелок,
то станет ясно, что конечный автомат - это частный случай
источника.
Мы будем строить конечный автомат по регулярному выражению
в два приема. Сначала мы построим источник, которому соответствует
то же самое множество слов. Затем для произвольного
источника построим автомат, который проверяет, принадлежит ли
слово соответствующему множеству.
10.7.9. По регулярному выражению построить источник, задающий
то же множество.
Решение. Индукция по построению регулярного выражения. Буквам
соответствуют графы из одной стрелки. Объединение реализуется
так:
|---------|
----"|*Н1 К1*|-"---
/ |---------| \
/ |---------| \
* ---------"|*Н2 К2*|---"-----* К
Н \ |---------| /
\ |---------| /
---"|*Н3 К3*|---"--
|---------|
Нарисована картинка для объединения трех множеств, прямоугольники
- это источники, соответствующие им; указаны начальные
и конечные вершины. На новых стрелках (их 6) букв не написано.
Конкатенации соответствует картинка
|--------| |--------| |--------|
Н*---"|*Н1 К1*|----"----|*Н2 К2*| ----"----|*Н3 К3*|--"--*К
|--------| |--------| |--------|
Наконец, итерации соответствует картинка
Н*---------"----------*-----------"----------*К
/ \
/ \
| |
V ^
| |
-------------
| *Н1 К1* |
-------------
10.7.10. Дан источник. Построить конечный автомат, проверяющий,
принадлежит ли входное слово множеству, соответствующему
источнику (т.е. можно ли прочесть это слово, идя из Н в К).
Решение. Состояниями автомата будут множества вершин источника.
Именно, пр
...Закладка в соц.сетях
