«Математико» (итальянская игра)

Челябинский Государственный Педагогический Университет

«Математико» (Итальянская игра)

Курсовая работа по информатике

Выполнил: Ларин Д.Д.,

студент 452 группы

физического факультета.

Проверил: Кузнецов А.Б.

Челябинск 2002

ВВЕДЕНИЕ.

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

• Компьютер дает возможность быстро и главное безошибочно провести необходимые расчеты, решить оптимизационную задачу;

• Компьютер дает возможность разработать систему действий по обработке данной ситуации;

• Компьютер дает возможность «предугадать» возможный исход некоторого анализируемого события;

• Компьютер становиться противником, позволяет играть одному человеку.

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

Изучая разного рода литературу по этому вопросу, можно отметить наличие широкого выбора оптимизационных алгоритмов. Например, динамическое программирование. Но для многих оптимизационных задач есть более простые и быстрые алгоритмы, чем динамическое программирование. В данной работе рассматриваются задачи, которые можно решать с помощью «жадных алгоритмов» (greedy algorithms). Такой алгоритм делает на каждом шаге локально оптимальный выбор, - в надежде, что итоговое решение также окажется оптимальным. Это не всегда так – но для многих задач такие алгоритмы действительно дают оптимум.

Таким образом, сформулируем цель работы: разработка программного комплекса логической игры «Математико» на компьютере, с применением «жадного алгоритма».

В связи с этим, объектом изучения будет выступать «жадный алгоритм». Исходя из цели исследования, была выдвинута гипотеза о том, что «жадный алгоритм» необходим для реализации логической игры «Математико» на компьютере.

В ходе выполнения работы решались следующие задачи:

1. Проанализировать состояние исследуемой проблемы по существующей на данный момент литературе.

2. Разработать оптимизационный алгоритм для решения различных игровых ситуаций.

3. Разработать программу, позволяющую моделировать игру «Математико» на компьютере.

Новизна и практическая значимость выполненной работы состоит в том, что:

• Разработан алгоритм для компьютера по решению игровых ситуаций;

 Разработан программный комплекс логической игры «Математико».

Теоретическое обоснование применения «жадного алгоритма» изложено в следующей главе.

Глава 1.

Жадные алгоритмы

Для многих оптимизационных задач есть более простые и быстрые алгоритмы, чем динамическое программирование. В этой главе мы рассматриваем задачи, которые можно решать с помощью жадных алгоритмов (greedy algorithms). Такой алгоритм делает на каждом шаге локально оптимальный выбор, - в надежде, что итоговое решение также окажется оптимальным. Это не всегда так – но для многих задач такие алгоритмы действительно дают оптимум. Наш первый пример – простая, но не вполне тривиальная задача о выборе заявок . Далее мы обсуждаем, для каких задач годятся жадные алгоритмы.

§1. Задача о выборе заявок

Пусть даны n заявок на проведение занятий в одной и той же аудитории. Два разных занятия не могут перекрываться по времени. В каждой заявке указаны начало и коней занятия (s_i и f_i для i-й заявки). Разные заявки могут пересекаться, и тогда можно удовлетворить только одну из них. Мы отождествляем каждую заявку с промежутком [s_{i ,} f_i), так что конец одного занятия может совпадать с началом другого, и это не считается пересечением.

Формально говоря, заявки с номерами i и j совместны (compatible), если интервалы [s_i , f_i) и [s_j,f_j) не пересекаются (иными словами, если

f_{i } s_j или f_{j } s_i). Задача о выборе заявок ( activity-selection problem) состоит в том, чтобы набрать максимальное количество совместных друг с другом заявок.

Жадный алгоритм работает следующим образом. Мы предполагаем, что заявки упорядочены в порядке возрастания времени окончания:

f_{1 } f _{2 } …  f_n (1)

Если это не так, то можно отсортировать их за время O(n log n); заявки с одинаковым временем конца располагаем в произвольном порядке.

Тогда алгоритм выглядит так (f и s – массивы):

Greedy-Activity- Selector (s, f)

1 n  length [s]

2 A  {1}

3 j  1

4 for i  2 to n

1. do if s_i  f_j

2. then A  A {i}

3. j  i

4. return A

Работа этого алгоритма показана на рис.1. Множество F состоит из номеров выбранных заявок, j – номер последней из них; при этом

F_j = max {f_k : k  A}, (17.2)

поскольку заявки отсортированы по возрастанию времени окончания. Вначале А содержит заявку номер 1, и j=1 (строки 2-3). Далее ( цикл в строках 4-7) ищется заявка, начинающаяся не раньше окончания заявки номер j. Если таковая найдена, она включается в множество Ф и переменной j присваивается ее номер (строки 6-7).

Алгоритм Greedy-Activity- Selector требует всего лишь  (n) шагов ( не считая предварительной сортировки). Как и подобает жадному алгоритму, на каждом шаге он делает выбор так, чтобы остающееся свободным время было максимально.

§2. Правильность алгоритма

Не для всех задач жадный алгоритм дает оптимальное решение, но для нашей дает. Убедимся в этом.

Теорема 1. Алгоритм Greedy-Activity- Selector дает набор из наибольшего возможного количества совместных заявок.

Доказательство. Напомним, что заявки отсортированы по возрастанию времени окончания. Прежде всего докажем, что существует оптимальное решение задачи о выборе заявок, содержащее заявку номер1 (с самым ранним временем окончания). В самом деле, если в каком-то оптимальном множестве заявок заявка номер 1 не содержится, то можно заменить в нем заявку с самым ранним временем окончания не заявку номер 1, что не повредит совместности заявок ( ибо заявка номер 1 кончается еще раньше, чем прежняя, и не с чем пересечься не может) и не изменит их общего количества. Стало быть, можно искать оптимальное решение, начинающееся с жадного выбора.

После того, как мы договорились рассматривать только наборы, содержащие заявку номер 1, все несовместные с ней заявки можно выкинуть, и задача сводится к выбору оптимального набора заявок из множества оставшихся заявок (совместных с заявкой номер 1). Другими словами, мы свели задачу к аналогичной задаче с меньшим числом заявок. Рассуждая по индукции, получаем, что, делая на каждом шаге жадный выбор, мы придем к оптимальному решению.

i s_i f _i

1 1 4

2 3 5					2
		1
3 0 6		3
		1
4 5 7							4
		1
5 3 8					5
		1		4
6 5 9							6
		1		4
7 6 10								7
		1		4
8 8 11										8
		1		4
9 8 12										9
		1		4		8
10 2 13				10
		1		4		8
11 12 14														11
		1		4		8
		1		4		8		11

время

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14

Рис. 1. Работа алгоритма Greedy-Activity-Selector для 11 заявок.

Каждая строка на рисунке соответствует одному проходу цикла

в строках 4-7. Серые заявки уже включены в А, белая сейчас рассматривается. Если левый конец белого прямоугольника левее правого конца правого серого ( стрелка идет влево), то заявка отвергается. В противном случае она добавляется к А.

§3. Когда применим жадный алгоритм?

Как узнать, даст ли жадный алгоритм оптимум применительно к данной задаче? Общих рецептов тут нет, но существует две особенности, характерные для задач, решаемых жадными алгоритмами. Это принцип жадного выбора и свойство оптимальности для подзадач.

§4. Принцип жадного выбора

Говорят, что к оптимизационной задаче применим принцип жадного выбора (greedy-choice property), если последовательность локально оптимальных (жадных) выборов дает глобально оптимальное решение. Различие между жадными алгоритмами и динамическим программированием можно пояснить так: на каждом шаге жадный алгоритм берет "самый жирный кусок", а потом уже пытается сделать наилучший выбор среди оставшихся, каковы бы они ни были; алгоритм динамического программирования принимает решение, просчитав заранее последствия для всех вариантов.

Как доказать, что жадный алгоритм дает оптимальное решение? Это не всегда тривиально, но в типичном случае такое доказательство следует схеме, использованной в доказательстве теоремы 1. Сначала мы доказываем, что жадный выбор на первом шаге не закрывает пути к оптимальному решению: для всякого решения есть другое, согласованное с жадным выбором и не худшее первого. Затем показывается, что подзадача, возникающая после жадного выбора на первом шаге, аналогична исходной, и рассуждение завершается по индукции.

§5. Оптимальность для подзадач

Говоря иными словами, решаемые с помощью жадных алгоритмов задачи обладают свойством оптимальности для подзадач (have optimal substructure): оптимальное решение всей задачи содержит в себе оптимальные решения подзадач. (С этим свойством мы уже встречались, говоря о динамическом программировании). Например, при доказательстве теоремы 1 мы видели, что если А – оптимальный набор заявок, содержащий заявку номер 1, то А’=A \{1} – оптимальный набор заявок для меньшего множества заявок S’, состоящего из тех заявок, для которых s_{i } f₁.

§6. Жадный алгоритм или динамическое программирование?

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

Дискретная задача о рюкзаке (0-1 knapsack problem) состоит в следующем. Пусть вор пробрался на склад, на котором хранится n вещей. Вещь номер i стоит v_i долларов и весит w_i килограммов (v_i и w_i - целые числа). Вор хочет украсть товара на максимальную сумму, причем максимальный вес, который он может унести в рюкзаке, равен W ( число W тоже целое). Что он должен положить в рюкзак?

Непрерывная задача о рюкзаке ( fractional knapsack problem)) отличается от дискретной тем, что вор может дробить краденые товары на части и укладывать в рюкзак эти части, а не обязательно вещи целиком (если в дискретной задаче вор имеет дело с золотыми слитками, то в непрерывной – с золотым песком).

Обе задачи о рюкзаке обладают свойством оптимальности для подзадач. В самом деле, рассмотрим дискретную задачу. Вынув вещь номер j из оптимально загруженного рюкзака, получим решение задачи о рюкзаке с максимальным весом W – w_j и набором из n-1 вещи ( все вещи, кроме j-й). Аналогичное рассуждение подходит и для непрерывной задачи: вынув из оптимально загруженного рюкзака, в котором лежит w килограммов товара номер j , весь этот товар, получим оптимальное решение непрерывной задачи, в которой максимальный вес равен W- w (вместо W), а количество j-го товара равно w_j-w ( вместо w_j).

Хотя две задачи о рюкзаке и похожи, жадный алгоритм дает оптимум в непрерывной задаче о рюкзаке и не дает в дискретной. В самом деле, решение непрерывной задачи о рюкзаке с помощью жадного алгоритма выглядит так. Вычислим цены (в расчете на килограмм) всех товаров (цена товара номер i равна v_i/w_i ). Сначала вор берет по максимуму самого дорогого товара; если весь этот товар кончился, а рюкзак не заполнен, вор берет следующий по цене товар, затес следующий, и так далее, пока не наберет вес W. Поскольку товары надо предварительно отсортировать по ценам, на что уйдет время О(n logn), время работы описанного алгоритма будет О(n logn).

Чтобы убедиться в том, что аналогичный жадный алгоритм не обязан давать оптимум в дискретной задаче о рюкзаке, взгляните на рис. 2(а). Грузоподъемность рюкзака 50кг, на складе имеются три вещи, весящие 10, 20 и 30кг и стоящие 60, 100 и 120 долларов соответственно. Цена их в расчете на единицу веса равна 6,5 и 4. Жадный алгоритм для начала положит в рюкзак вещь номер 1; однако оптимальное решение включает предметы номер 2 и 3.

Для непрерывной задачи с теми же исходными данными жадный алгоритм, предписывающий начать с товара номер 1, дает оптимальное решение (рис. 2(в)). В дискретной задаче такая стратегия не срабатывает: положив в рюкзак предмет номер 1, вор лишается возможности заполнить рюкзак «под завязку», а пустое место в рюкзаке снижает цену наворованного в расчете на единицу веса. Здесь, чтобы решить, класть ли данную вещь в рюкзак, надо сравнить решения двух подзадач: когда данная вещь заведомо лежит в рюкзаке и когда этой вещи в рюкзаке заведомо нет. Тем самым дискретная задача о рюкзаке порождает множество перекрывающихся подзадач – типичный признак того, что может пригодиться динамическое программирование. И действительно, к дискретной задаче о рюкзаке оно применимо .

Рис. 2. В дискретной задаче о рюкзаке жадная стратегия может не сработать. (а) Вор должен выбрать две вещи из трех с тем, чтобы их суммарный вес не превысил 50кг. (б) Оптимальный выбор – вторая и третья вещи; если положить в рюкзак первую, то выбор оптимальным не будет, хотя именно она дороже всех в расчете на единицу веса. (в) Для непрерывной задачи о рюкзаке с теми же исходными данными выбор товаров в порядке убывания цены на единицу веса будет оптимален.

	Вещь3		50				30	$120 $100			$100 + $60			$120 + $60	20	$80 + $100 + $60
	30	30
	Вещь2	30	20	20
Вещь1	20		20
10			10	10	10
$60	$100	$120	рюкзак	=$220	=$160	=$180	=$240
(а)	(б)	(в)

Глава 2

§1. Применение «жадного алгоритма».

В логической игре «Математико» применение «жадного алгоритма» необходимо для того, чтобы компьютер принимал наиболее выгодное решение в зависимости от поступаемого из колоды числа. Компьютер должен принимать решение о том, куда ставить выпавшее число по нескольким параметрам:

1. Какая наиболее выгодная комбинация может получиться в данной строке (столбце или по диагонали);

1. Какова вероятность выпадения необходимого числа для данной комбинации из колоды;

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

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

procedure Tform1.MC(x:integer); / x-число которое выпало из колоды

var

s1,s2:real;

p1,o1,p,o,x1,y1:integer;

qw:pat;

begin

MV[x]:=MV[x]-1; / массив, который отвечает за числа оставшиеся в колоде

s2:=1000;

x1:=0;

y1:=0;

if n=1 then / число выпавшее первым ставиться в клетку с координатой 1,1.

begin

x1:=1;

y1:=1;

p:=1;

o:=1;

end

else

for p:=1 to 5 do

for o:=1 to 5 do

if (a[p,o]=0)and(ver[p,o,x]=1) then / если в данной клетке нет числа, то в нее заносится число

begin

s1:=0;

a[p,o]:=x;

for p1:=1 to 5 do

qw[p1]:=a[p,p1]; / составляется комбинация по строке

s1:=reit(qw); / и считается её возможный рейтинг

for p1:=1 to 5 do

qw[p1]:=a[p1,p]; / составляется комбинация по столбцу

s1:=s1+reit(qw); / и считается её возможный рейтинг(в сумме с предыдущим)

if p=o then

begin

for p1:=1 to 5 do

qw[p1]:=a[p1,p1]; / составляется комбинация по диагонали

s1:=s1+reit(qw); / и считается её возможный рейтинг(в сумме с предыдущим)

end;

if p=6-o then

begin

for p1:=1 to 5 do

qw[p1]:=a[p1,6-p1]; / чем меньше рейтинг, тем больше шансов выпасть

s1:=s1+reit(qw); / у комбинации (см. функцию REIT)

end;

if s1

begin

s2:=s1;

x1:=p; / X1 и Y1 необходимые координаты клетки

y1:=o;

end;

a[p,o]:=0;

end;

stringgrid2.Cells[x1,y1]:=inttostr(x); / Устанавливаем число

a[x1,y1]:=x;

mcv(a,ver);

if n=25 then

for p:=1 to 5 do

for o:=1 to 5 do

begin

case p of

1:cm1[o]:=a[p,o];

2:cm2[o]:=a[p,o];

3:cm3[o]:=a[p,o];

4:cm4[o]:=a[p,o];

5:cm5[o]:=a[p,o];

end;

case o of 1:cm6[p]:=a[p,o];

2:cm7[p]:=a[p,o];

3:cm8[p]:=a[p,o];

4:cm9[p]:=a[p,o];

5:cm10[p]:=a[p,o];

end;

if p=6-o then cm12[p]:=a[p,o];

if p=o then cm11[p]:=a[p,o];

end;

end;

Компьютер при принятии решения каждый раз обращается к данной процедуре, в которой выпавшее число устанавливается в каждую пустую клетку. Процедура сама выберет оптимальное на данный момент местоположение числа. Следующее число опять попадет в данную процедуру, и для него опять будет принято оптимальное решение, которое необязательно будет оптимальным в итоге. Это и есть «жадный алгоритм».

§2. Правила игры.

Имеется набор из 52 карточек, на которых записаны числа от 1 до 13, причем карточки с каждым из этих чисел встречаются четырежды. Имеется квадратное поле с 25 клетками. Программа случайным образом извлекает какую-либо из этих карточек и выдает записанное на ней число. Каждый игрок (вы и компьютер) заносит это число в одну из клеток квадрата. Так продолжается до тех пор, пока все клетки квадрата не будут заполнены.

По окончании игры заполнение соответствующего квадрата оценивается определенным количеством очков. Цель игры – разместить числа в клетках так, чтобы набрать наибольшее количество очков в соответствии с данной таблицей:

Комбинация чисел	В ряду или столбце	По диагонали
За 2 одинаковых числа	10 очков	20 очков
За 2 пары одинаковых чисел	20 очков	30 очков
За 3 одинаковых числа	40 очков	50 очков
За 3 одинаковых числа и два других одинаковых числа	80 очков	90 очков
За 4 одинаковых числа	160 очков	170 очков
За 5 последовательных чисел, но необязательно по порядку расположенных	50 очков	60 очков
За три раза по 1 и два раза по 13	100 очков	110 очков
За числа 1,10,11,12 и 13, но необязательно по порядку расположенных	150 очков	160 очков
За 4 единицы	200 очков	210 очков

§3. Руководство пользователя.

Перед вами игровое поле:

«Ваше поле» - поле, которое заполняете вы сами.

«Поле компьютера» - поле, которое заполняет компьютер.

«Число» - число, которое выпало, его и надо ставить.

Если вы случайно выбрали клетку, которая уже занята другим числом,

то вы увидите:

Если вы хотите поменять цвет формы, полей, то вам необходимо выбрать:

«Файл» - «Настроить цвет…»

Если вы хотите поменять шрифт, то вам необходимо выбрать:

«Файл» - «Настроить шрифт…»

Также вы имеете возможность начать игру заново:

«Файл» - «Новая игра»

Для того чтобы выйти из игры необходимо:

«Файл» - «Выход»

Если вам необходимо уточнить правила игры, то выберите « О программе».

После того, как все клетки будут заполнены, вы узнаете результат игры:

§4. Заключение.

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

1. Сократить время принятия решения

2. Проверять все возможные варианты решения на данный момент времени.

В ходе работы нами был разработан и реализован «жадный алгоритм» для логической игры «Математико» на Delphi 5.

Данный программный комплекс представляет собой реализацию логической игры «Математико» на компьютере с использованием «жадного алгоритма». «Жадный алгоритм» позволяет компьютеру принимать оптимальное решение для данного числа в данной ситуации, что делает его очень «хорошим» соперником.

У данного программного комплекса есть свои недостатки. Например, если подряд выпадают несколько «хороших» чисел (которые являются какой-нибудь комбинацией), то совсем необязательно, что компьютер поставит их в один ряд. Поэтому в данном случае человек получает некоторое преимущество. Но когда приходят числа, которые, казалось бы, никак не связаны, то и «жадный алгоритм» примет оптимальное решение, что скажется на итоге. И в последующих работах недостатки будут устранены.

Приложение.

Листинг программы

unit Unit1;

interface

uses

Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,

StdCtrls, Grids, Menus,shellapi;

type

pat=array [1..5] of integer;

ver1=array[1..5,1..5,1..13] of integer;

ver2=array[1..5,1..5] of integer;

TForm1 = class(TForm)

StringGrid1: TStringGrid;

StringGrid2: TStringGrid;

Label1: TLabel;

Label2: TLabel;

Edit1: TEdit;

Label3: TLabel;

Edit2: TEdit;

Label4: TLabel;

Edit3: TEdit;

Label5: TLabel;

MainMenu1: TMainMenu;

N1: TMenuItem;

N2: TMenuItem;

N3: TMenuItem;

N4: TMenuItem;

N5: TMenuItem;

N6: TMenuItem;

N7: TMenuItem;

N8: TMenuItem;

N9: TMenuItem;

ColorDialog1: TColorDialog;

N10: TMenuItem;

N11: TMenuItem;

N12: TMenuItem;

N13: TMenuItem;

FontDialog1: TFontDialog;

N14: TMenuItem;

N15: TMenuItem;

N16: TMenuItem;

N17: TMenuItem;

procedure FormCreate(Sender: TObject);

procedure Massiv;

procedure MC(x:integer);

procedure zanos_ig(w,x,y:integer);

procedure podschet( a: pat; var s:integer);

procedure mcv(ww:ver2; var qq:ver1);

procedure StringGrid1MouseDown(Sender: TObject; Button: TMouseButton;

Shift: TShiftState; X, Y: Integer);

function reit(z:pat):real;

procedure reit_t(z:pat;x,y:integer; var we:ver1);

procedure N8Click(Sender: TObject);

procedure N10Click(Sender: TObject);

procedure N11Click(Sender: TObject);

procedure N12Click(Sender: TObject);

procedure N13Click(Sender: TObject);

procedure N15Click(Sender: TObject);

procedure N16Click(Sender: TObject);

procedure N2Click(Sender: TObject);

procedure N3Click(Sender: TObject);

procedure N4Click(Sender: TObject);

private

{ Private declarations }

public

{ Public declarations }

end;

var

Form1: TForm1;

ver:ver1;

q:array[1..52] of integer;

a:ver2;

ig1,ig2,ig3,ig4,ig5,ig6,ig7,ig8,ig9,ig10,ig11,ig12:pat;

cm1,cm2,cm3,cm4,cm5,cm6,cm7,cm8,cm9,cm10,cm11,cm12:pat;

e,r,n,summa:integer;

MV:array[1..13]of integer;

implementation

//-----------------------------------------------------------

procedure Tform1.Massiv;

var

i,j,b:integer;

begin

randomize;

for i:=1 to 13 do

for j:=1 to 4 do

q[(i-1)*4+j]:=i;

for i:=1 to 52 do

begin

j:=random(52);

b:=q[i];

q[i]:=q[j];

q[j]:=b;

end;

end;

//-----------------------------------------------------------

procedure tform1.zanos_ig(w,x,y:integer);

begin

case x of

1:ig1[y]:=w;

2:ig2[y]:=w;

3:ig3[y]:=w;

4:ig4[y]:=w;

5:ig5[y]:=w;

end;

case y of

1:ig6[x]:=w;

2:ig7[x]:=w;

3:ig8[x]:=w;

4:ig9[x]:=w;

5:ig10[x]:=w;

end;

if x=6-y then ig12[x]:=w;

if x=y then ig11[x]:=w;

end;

//-----------------------------------------------------------

procedure tform1.podschet( a: pat; var s:integer);

var

z:array[1..13] of integer;

p,l,sum:integer;

begin

sum:=0;

for p:=1 to 13 do z[p]:=0;

for p:=1 to 13 do

for l:=1 to 5 do

if a[l]=p then z[p]:=z[p]+1;

if (z[1]=1)and(z[10]=1)and(z[11]=1)and(z[12]=1)and(z[13]=1) then sum:=150;

if z[1]=4 then sum:=200;

if (z[1]=3)and(z[13]=2) then sum:=100;

for p:=2 to 13 do

if z[p]=4 then sum:=160;

for p:=1 to 13 do

if z[p]=3 then

for l:=1 to 13 do

if z[l]=2 then sum:=80;

if sum=0 then

for p:=1 to 13 do

if z[p]=3 then sum:=40;

if sum=0 then

for p:=1 to 13 do

if z[p]=2 then

for l:=p+1 to 13 do

if z[l]=2 then sum:=20;

if sum=0 then

for p:=1 to 13 do

if z[p]=2 then sum:=10;

if sum=0 then

for p:=1 to 9 do

if (z[p]=1)and(z[p+1]=1)and(z[p+2]=1)and(z[p+3]=1)and(z[p+4]=1) then sum:=50;

s:=sum;

end;

//-----------------------------------------------------------

{$R *.DFM}

procedure TForm1.FormCreate(Sender: TObject);

var

p,o,l:integer;

begin

form1.left:=140;

form1.top:=100;

for p:=1 to 5 do

for o:=1 to 5 do

for l:=1 to 13 do ver[p,o,l]:=1;

Massiv;

for p:=1 to 25 do

if q[p]>13 then

q[p]:=q[26];

for p:=1 to 5 do

for o:=1 to 5 do

a[p,o]:=0;

for p:=1 to 13 do

MV[p]:=4;

n:=1;

summa:=0;

edit1.text:=inttostr(q[1]);

end;

//------------------------------------------------------------

procedure tform1.reit_t(z:pat; x,y:integer;var we:ver1);

var

a1,p,l,l1,nul:integer;

q1:array[1..13]of integer;

fl:boolean;

begin

nul:=0;

for p:=1 to 5 do

if z[p]=0 then nul:=nul+1;

for p:=1 to 13 do q1[p]:=0;

for p:=1 to 13 do

for l:=1 to 5 do

if z[l]=p then q1[p]:=q1[p]+1;

//------1-10-11-12-13-----------------------

if (q1[1]<2>

and(q1[2]=0)and(q1[3]=0)and(q1[4]=0)and(q1[5]=0)and(q1[6]=0)and(q1[7]=0)and(q1[8]=0)and(q1[9]=0)then

begin

we[x,y,1]:=1;

we[x,y,10]:=1;

we[x,y,11]:=1;

we[x,y,12]:=1;

we[x,y,13]:=1;

end;

//-------1-2-3-4-5--------------------------

if (q1[1]<2>

and(q1[10]=0)and(q1[11]=0)and(q1[12]=0)and(q1[13]=0)and(q1[6]=0)and(q1[7]=0)and(q1[8]=0)and(q1[9]=0)then

begin

we[x,y,1]:=1;

we[x,y,4]:=1;

we[x,y,5]:=1;

we[x,y,2]:=1;

we[x,y,3]:=1;

end;

//-------2-3-4-5-6--------------------------

if (q1[6]<2>

and(q1[10]=0)and(q1[11]=0)and(q1[12]=0)and(q1[13]=0)and(q1[1]=0)and(q1[7]=0)and(q1[8]=0)and(q1[9]=0)then

begin

we[x,y,6]:=1;

we[x,y,4]:=1;

we[x,y,5]:=1;

we[x,y,2]:=1;

we[x,y,3]:=1;

end;

//-------3-4-5-6-7--------------------------

if (q1[6]<2>

and(q1[10]=0)and(q1[11]=0)and(q1[12]=0)and(q1[13]=0)and(q1[1]=0)and(q1[2]=0)and(q1[8]=0)and(q1[9]=0)then

begin

we[x,y,6]:=1;

we[x,y,4]:=1;

we[x,y,5]:=1;

we[x,y,7]:=1;

we[x,y,3]:=1;

end;

//-------4-5-6-7-8--------------------------

if (q1[6]<2>

and(q1[10]=0)and(q1[11]=0)and(q1[12]=0)and(q1[13]=0)and(q1[1]=0)and(q1[2]=0)and(q1[3]=0)and(q1[9]=0)then

begin

we[x,y,6]:=1;

we[x,y,4]:=1;

we[x,y,5]:=1;

we[x,y,7]:=1;

we[x,y,8]:=1;

end;

//-------5-6-7-8-9--------------------------

if (q1[6]<2>

and(q1[10]=0)and(q1[11]=0)and(q1[12]=0)and(q1[13]=0)and(q1[1]=0)and(q1[2]=0)and(q1[3]=0)and(q1[4]=0)then

begin

we[x,y,6]:=1;

we[x,y,9]:=1;

we[x,y,5]:=1;

we[x,y,7]:=1;

we[x,y,8]:=1;

end;

//-------6-7-8-9-10-------------------------

if (q1[6]<2>

and(q1[5]=0)and(q1[11]=0)and(q1[12]=0)and(q1[13]=0)and(q1[1]=0)and(q1[2]=0)and(q1[3]=0)and(q1[4]=0)then

begin

we[x,y,6]:=1;

we[x,y,9]:=1;

we[x,y,10]:=1;

we[x,y,7]:=1;

we[x,y,8]:=1;

end;

//-------7-8-9-10-11------------------------

if (q1[11]<2>

and(q1[5]=0)and(q1[6]=0)and(q1[12]=0)and(q1[13]=0)and(q1[1]=0)and(q1[2]=0)and(q1[3]=0)and(q1[4]=0)then

begin

we[x,y,11]:=1;

we[x,y,9]:=1;

we[x,y,10]:=1;

we[x,y,7]:=1;

we[x,y,8]:=1;

end;

//--------8-9-10-11-12----------------------

if (q1[11]<2>

and(q1[5]=0)and(q1[6]=0)and(q1[7]=0)and(q1[13]=0)and(q1[1]=0)and(q1[2]=0)and(q1[3]=0)and(q1[4]=0)then

begin

we[x,y,11]:=1;

we[x,y,9]:=1;

we[x,y,10]:=1;

we[x,y,12]:=1;

we[x,y,8]:=1;

end;

//---------9-10-11-12-13--------------------

if (q1[11]<2>

and(q1[5]=0)and(q1[6]=0)and(q1[7]=0)and(q1[8]=0)and(q1[1]=0)and(q1[2]=0)and(q1[3]=0)and(q1[4]=0)then

begin

we[x,y,11]:=1;

we[x,y,9]:=1;

we[x,y,10]:=1;

we[x,y,12]:=1;

we[x,y,13]:=1;

end;

//--------четверка--------------------------

for p:=1 to 13 do

if (q1[p]=3) and (nul>0) then

begin

we[x,y,p]:=1;

end;

//---------три+2----------------------------

for p:=1 to 13 do

if q1[p]=3 then

for l:=1 to 13 do

if (q1[l]>0) and (nul>0) then

begin

we[x,y,l]:=1;

end;

//--------тройка----------------------------

for p:=1 to 13 do

if (q1[p]=2) and (nul>0) then

begin

we[x,y,p]:=1;

end;

//---------2+2------------------------------

for p:=1 to 13 do

if (q1[p]=2) and (nul>0) then

for l:=1 to 13 do

if (q1[l]>0) and (l<>p)then

begin

we[x,y,l]:=1;

end;

end;

//------------------------------------------------------------

procedure tform1.mcv(ww:ver2;var qq:ver1);

var

p,o,i,l,k:integer;

z:pat;

begin

for p:=1 to 5 do

for o:=1 to 5 do

for i:=1 to 13 do

qq[p,o,i]:=0;

for p:=1 to 5 do

for o:=1 to 5 do

begin

if ww[p,o]=0 then

begin

for i:=1 to 5 do

z[i]:=ww[p,i];

reit_t(z,p,o,qq);

for i:=1 to 5 do

z[i]:=ww[i,o];

reit_t(z,p,o,qq);

if p=o then

for i:=1 to 5 do

z[i]:=ww[i,i];

reit_t(z,p,o,qq);

if p=6-o then

for i:=1 to 5 do

z[i]:=ww[i,6-i];

reit_t(z,p,o,qq);

end;

end;

end;

//------------------------------------------------------------

function Tform1.reit(z:pat):real;

var

a1,p,l,l1,nul:integer;

q1:array[1..13]of integer;

r,rm:real;

fl:boolean;

begin

r:=100;

rm:=100;

nul:=0;

for p:=1 to 5 do

if z[p]=0 then nul:=nul+1;

for p:=1 to 13 do q1[p]:=0;

for p:=1 to 13 do

for l:=1 to 5 do

if z[l]=p then q1[p]:=q1[p]+1;

//------1-10-11-12-13-----------------------

if (q1[1]<2>

and(q1[2]=0)and(q1[3]=0)and(q1[4]=0)and(q1[5]=0)and(q1[6]=0)and(q1[7]=0)and(q1[8]=0)and(q1[9]=0)then

begin

r:=(1-q1[1])*mv[1]/4*(25-n)/(52-n)+(1-q1[10])*mv[10]/4*(21-n)/(48-n)+(1-q1[11])*mv[11]/4*(22-n)/(49-n)+(1-q1[12])*mv[12]/4*(23-n)/(50-n)+(1-q1[13])*mv[13]/4*(24-n)/(51-n);

if r

end;

//-------1-2-3-4-5--------------------------

if (q1[1]<2>

and(q1[10]=0)and(q1[11]=0)and(q1[12]=0)and(q1[13]=0)and(q1[6]=0)and(q1[7]=0)and(q1[8]=0)and(q1[9]=0)then

begin

r:=(1-q1[1])*mv[1]/4*(25-n)/(52-n)+(1-q1[2])*mv[2]/4*(21-n)/(48-n)+(1-q1[3])*mv[3]/4*(22-n)/(49-n)+(1-q1[4])*mv[4]/4*(23-n)/(50-n)+(1-q1[5])*mv[5]/4*(24-n)/(51-n);

if r

end;

//-------2-3-4-5-6--------------------------

if (q1[6]<2>

and(q1[10]=0)and(q1[11]=0)and(q1[12]=0)and(q1[13]=0)and(q1[1]=0)and(q1[7]=0)and(q1[8]=0)and(q1[9]=0)then

begin

r:=(1-q1[6])*mv[6]/4*(25-n)/(52-n)+(1-q1[2])*mv[2]/4*(21-n)/(48-n)+(1-q1[3])*mv[3]/4*(22-n)/(49-n)+(1-q1[4])*mv[4]/4*(23-n)/(50-n)+(1-q1[5])*mv[5]/4*(24-n)/(51-n);

if r

end;

//-------3-4-5-6-7--------------------------

if (q1[6]<2>

and(q1[10]=0)and(q1[11]=0)and(q1[12]=0)and(q1[13]=0)and(q1[1]=0)and(q1[2]=0)and(q1[8]=0)and(q1[9]=0)then

begin

r:=(1-q1[6])*mv[6]/4*(25-n)/(52-n)+(1-q1[7])*mv[7]/4*(21-n)/(48-n)+(1-q1[3])*mv[3]/4*(22-n)/(49-n)+(1-q1[4])*mv[4]/4*(23-n)/(50-n)+(1-q1[5])*mv[5]/4*(24-n)/(51-n);

if r

end;

//-------4-5-6-7-8--------------------------

if (q1[6]<2>

and(q1[10]=0)and(q1[11]=0)and(q1[12]=0)and(q1[13]=0)and(q1[1]=0)and(q1[2]=0)and(q1[3]=0)and(q1[9]=0)then

begin

r:=(1-q1[6])*mv[6]/4*(25-n)/(52-n)+(1-q1[7])*mv[7]/4*(21-n)/(48-n)+(1-q1[8])*mv[8]/4*(22-n)/(49-n)+(1-q1[4])*mv[4]/4*(23-n)/(50-n)+(1-q1[5])*mv[5]/4*(24-n)/(51-n);

if r

end;

//-------5-6-7-8-9--------------------------

if (q1[6]<2>

and(q1[10]=0)and(q1[11]=0)and(q1[12]=0)and(q1[13]=0)and(q1[1]=0)and(q1[2]=0)and(q1[3]=0)and(q1[4]=0)then

begin

r:=(1-q1[6])*mv[6]/4*(25-n)/(52-n)+(1-q1[7])*mv[7]/4*(21-n)/(48-n)+(1-q1[8])*mv[8]/4*(22-n)/(49-n)+(1-q1[9])*mv[9]/4*(23-n)/(50-n)+(1-q1[5])*mv[5]/4*(24-n)/(51-n);

if r

end;

//--------6-7-8-9-10-------------------------

if (q1[6]<2>

and(q1[5]=0)and(q1[11]=0)and(q1[12]=0)and(q1[13]=0)and(q1[1]=0)and(q1[2]=0)and(q1[3]=0)and(q1[4]=0)then

begin

r:=(1-q1[6])*mv[6]/4*(25-n)/(52-n)+(1-q1[7])*mv[7]/4*(21-n)/(48-n)+(1-q1[8])*mv[8]/4*(22-n)/(49-n)+(1-q1[9])*mv[9]/4*(23-n)/(50-n)+(1-q1[10])*mv[10]/4*(24-n)/(51-n);

if r

end;

//--------7-8-9-10-11-------------------------

if (q1[11]<2>

and(q1[5]=0)and(q1[6]=0)and(q1[12]=0)and(q1[13]=0)and(q1[1]=0)and(q1[2]=0)and(q1[3]=0)and(q1[4]=0)then

begin

r:=(1-q1[11])*mv[11]/4*(25-n)/(52-n)+(1-q1[7])*mv[7]/4*(21-n)/(48-n)+(1-q1[8])*mv[8]/4*(22-n)/(49-n)+(1-q1[9])*mv[9]/4*(23-n)/(50-n)+(1-q1[10])*mv[10]/4*(24-n)/(51-n);

if r

end;

//-------8-9-10-11-12-------------------------

if (q1[11]<2>

and(q1[5]=0)and(q1[6]=0)and(q1[7]=0)and(q1[13]=0)and(q1[1]=0)and(q1[2]=0)and(q1[3]=0)and(q1[4]=0)then

begin

r:=(1-q1[11])*mv[11]/4*(25-n)/(52-n)+(1-q1[12])*mv[12]/4*(21-n)/(48-n)+(1-q1[8])*mv[8]/4*(22-n)/(49-n)+(1-q1[9])*mv[9]/4*(23-n)/(50-n)+(1-q1[10])*mv[10]/4*(24-n)/(51-n);

if r

end;

//-------9-10-11-12-13-------------------------

if (q1[11]<2>

and(q1[5]=0)and(q1[6]=0)and(q1[7]=0)and(q1[8]=0)and(q1[1]=0)and(q1[2]=0)and(q1[3]=0)and(q1[4]=0)then

begin

r:=(1-q1[11])*mv[11]/4*(25-n)/(52-n)+(1-q1[12])*mv[12]/4*(21-n)/(48-n)+(1-q1[13])*mv[13]/4*(22-n)/(49-n)+(1-q1[9])*mv[9]/4*(23-n)/(50-n)+(1-q1[10])*mv[10]/4*(24-n)/(51-n);

if r

end;

//-------четверка--------------------------

for p:=1 to 13 do

if (q1[p]=3) and (nul>0) then

begin

r:=(4-q1[p])*mv[p]/4*(25-n)/(52-n);

if r

end;

//--------3+2-------------------------

for p:=1 to 13 do

if q1[p]=3 then

for l:=1 to 13 do

if (q1[l]>0) and (nul>0) then

begin

r:=(2-q1[l])*mv[l]/4*(25-n)/(52-n);

if r

end;

//-------тройка--------------------------

for p:=1 to 13 do

if (q1[p]=2) and (nul>0) then

begin

r:=(3-q1[p])*mv[p]/4*(25-n)/(52-n);

if r

end;

//-------2+2--------------------------

for p:=1 to 13 do

if (q1[p]=2) and (nul>0) then

for l:=1 to 13 do

if (q1[l]>0) and (l<>p)then

begin

r:=(2-q1[l])*mv[l]/4*(25-n)/(52-n);

if r

end;

//---------------------------------

{

for p:=1 to 13 do

if (q1[p]=2) and (rm=100) then

begin

r:=0;

if r

end;

}

//---------------------------------

if (rm=100) and (nul<=3) then rm:=2*rm;

reit:=rm;

end;

//------------------------------------------------------------

//------------------------------------------------------------

procedure Tform1.MC(x:integer);

var

s1,s2:real;

p1,o1,p,o,x1,y1:integer;

qw:pat;

begin

MV[x]:=MV[x]-1;

s2:=1000;

x1:=0;

y1:=0;

if n=1 then

begin

x1:=1;

y1:=1;

p:=1;

o:=1;

end

else

for p:=1 to 5 do

for o:=1 to 5 do

if (a[p,o]=0)and(ver[p,o,x]=1) then

begin

s1:=0;

a[p,o]:=x;

for p1:=1 to 5 do

qw[p1]:=a[p,p1];

s1:=reit(qw);

for p1:=1 to 5 do

qw[p1]:=a[p1,p];

s1:=s1+reit(qw);

if p=o then

begin

for p1:=1 to 5 do

qw[p1]:=a[p1,p1];

s1:=s1+reit(qw);

end;

if p=6-o then

begin

for p1:=1 to 5 do

qw[p1]:=a[p1,6-p1];

s1:=s1+reit(qw);

end;

if s1

begin

s2:=s1;

x1:=p;

y1:=o;

end;

a[p,o]:=0;

end;

if (x1=0) and (y1=0) then

for p:=1 to 5 do

for o:=1 to 5 do

if (a[p,o]=0) then

begin

s1:=0;

a[p,o]:=x;

for p1:=1 to 5 do

qw[p1]:=a[p,p1];

s1:=reit(qw);

for p1:=1 to 5 do

qw[p1]:=a[p1,p];

s1:=s1+reit(qw);

if p=o then

begin

for p1:=1 to 5 do

qw[p1]:=a[p1,p1];

s1:=s1+reit(qw);

end;

if p=6-o then

begin

for p1:=1 to 5 do

qw[p1]:=a[p1,6-p1];

s1:=s1+reit(qw);

end;

if s1

begin

s2:=s1;

x1:=p;

y1:=o;

end;

a[p,o]:=0;

end;

stringgrid2.Cells[x1,y1]:=inttostr(x);

a[x1,y1]:=x;

mcv(a,ver);

if n=25 then

for p:=1 to 5 do

for o:=1 to 5 do

begin

case p of

1:cm1[o]:=a[p,o];

2:cm2[o]:=a[p,o];

3:cm3[o]:=a[p,o];

4:cm4[o]:=a[p,o];

5:cm5[o]:=a[p,o];

end;

case o of

1:cm6[p]:=a[p,o];

2:cm7[p]:=a[p,o];

3:cm8[p]:=a[p,o];

4:cm9[p]:=a[p,o];

5:cm10[p]:=a[p,o];

end;

if p=6-o then cm12[p]:=a[p,o];

if p=o then cm11[p]:=a[p,o];

end;

end;

//------------------------------------------------------------

procedure TForm1.StringGrid1MouseDown(Sender: TObject;

Button: TMouseButton; Shift: TShiftState; X, Y: Integer);

var

sum:integer;

begin

sum:=0;

if (n<=25)and (stringgrid1.Cells[stringgrid1.col,stringgrid1.row]='') then

begin

zanos_ig(q[n],stringgrid1.col,stringgrid1.row);

mc(q[n]);

n:=n+1;

stringgrid1.Cells[stringgrid1.col,stringgrid1.row]:=inttostr(q[n-1]);

end

else

if (n<=25) then showmessage ('Занято');

edit1.text:=inttostr(q[n]);

if n=26 then

begin

showmessage ('Сейчас подсчитаем');

podschet(ig1,sum);

stringgrid1.Cells[1,0]:=inttostr(sum);

summa:=summa+sum;

podschet(ig2,sum);

stringgrid1.Cells[2,0]:=inttostr(sum);

summa:=summa+sum;

podschet(ig3,sum);

stringgrid1.Cells[3,0]:=inttostr(sum);

summa:=summa+sum;

podschet(ig4,sum);

stringgrid1.Cells[4,0]:=inttostr(sum);

summa:=summa+sum;

podschet(ig5,sum);

stringgrid1.Cells[5,0]:=inttostr(sum);

summa:=summa+sum;

podschet(ig6,sum);

stringgrid1.Cells[0,1]:=inttostr(sum);

summa:=summa+sum;

podschet(ig7,sum);

stringgrid1.Cells[0,2]:=inttostr(sum);

summa:=summa+sum;

podschet(ig8,sum);

stringgrid1.Cells[0,3]:=inttostr(sum);

summa:=summa+sum;

podschet(ig9,sum);

stringgrid1.Cells[0,4]:=inttostr(sum);

summa:=summa+sum;

podschet(ig10,sum);

stringgrid1.Cells[0,5]:=inttostr(sum);

summa:=summa+sum;

podschet(ig11,sum);

if sum<>0 then

begin

stringgrid1.Cells[0,0]:=inttostr(sum+10);

summa:=summa+sum+10;

end

else stringgrid1.Cells[0,0]:=inttostr(0);

podschet(ig12,sum);

if sum<>0 then

begin

stringgrid1.Cells[0,0]:=stringgrid1.Cells[0,0]+'+'+inttostr(sum+10);

summa:=summa+sum+10;

end

else stringgrid1.Cells[0,0]:=stringgrid1.Cells[0,0]+'+'+inttostr(0);

edit2.text:=inttostr(summa);

edit2.visible:=true;

label4.visible:=true;

//--------------------------------------

showmessage('Сейчас подсчитаем у компа');

summa:=0;

podschet(cm1,sum);

stringgrid2.Cells[1,0]:=inttostr(sum);

summa:=summa+sum;

podschet(cm2,sum);

stringgrid2.Cells[2,0]:=inttostr(sum);

summa:=summa+sum;

podschet(cm3,sum);

stringgrid2.Cells[3,0]:=inttostr(sum);

summa:=summa+sum;

podschet(cm4,sum);

stringgrid2.Cells[4,0]:=inttostr(sum);

summa:=summa+sum;

podschet(cm5,sum);

stringgrid2.Cells[5,0]:=inttostr(sum);

summa:=summa+sum;

podschet(cm6,sum);

stringgrid2.Cells[0,1]:=inttostr(sum);

summa:=summa+sum;

podschet(cm7,sum);

stringgrid2.Cells[0,2]:=inttostr(sum);

summa:=summa+sum;

podschet(cm8,sum);

stringgrid2.Cells[0,3]:=inttostr(sum);

summa:=summa+sum;

podschet(cm9,sum);

stringgrid2.Cells[0,4]:=inttostr(sum);

summa:=summa+sum;

podschet(cm10,sum);

stringgrid2.Cells[0,5]:=inttostr(sum);

summa:=summa+sum;

podschet(cm11,sum);

if sum<>0 then

begin

stringgrid2.Cells[0,0]:=inttostr(sum+10);

summa:=summa+sum+10;

end

else stringgrid2.Cells[0,0]:=inttostr(0);

podschet(cm12,sum);

if sum<>0 then

begin

stringgrid2.Cells[0,0]:=stringgrid2.Cells[0,0]+'+'+inttostr(sum+10);

summa:=summa+sum+10;

end

else stringgrid2.Cells[0,0]:=stringgrid2.Cells[0,0]+'+'+inttostr(0);

edit3.text:=inttostr(summa);

edit3.visible:=true;

label5.visible:=true;

if strtoint(edit2.text)>strtoint(edit3.text) then showmessage('Вы выиграли!!!!!')

else showmessage('ВЫ ПРОИГРАЛИ! ХА-ХА-ХА');

end;

end;

procedure TForm1.N8Click(Sender: TObject);

begin

if colordialog1.Execute then form1.Color:=colordialog1.color;

end;

procedure TForm1.N10Click(Sender: TObject);

begin

if colordialog1.Execute then stringgrid1.Color:=colordialog1.color;

end;

procedure TForm1.N11Click(Sender: TObject);

begin

if colordialog1.Execute then stringgrid1.FixedColor:=colordialog1.color;

end;

procedure TForm1.N12Click(Sender: TObject);

begin

if colordialog1.Execute then stringgrid2.Color:=colordialog1.color;

end;

procedure TForm1.N13Click(Sender: TObject);

begin

if colordialog1.Execute then stringgrid2.FixedColor:=colordialog1.color;

end;

procedure TForm1.N15Click(Sender: TObject);

begin

if fontdialog1.Execute then stringgrid1.Font.Assign(fontdialog1.Font)

end;

procedure TForm1.N16Click(Sender: TObject);

begin

if fontdialog1.Execute then stringgrid2.Font.Assign(fontdialog1.Font)

end;

procedure TForm1.N2Click(Sender: TObject);

begin

ShellExecute(Handle,nil,'file.txt',nil,nil,sw_restore);

end;

procedure TForm1.N3Click(Sender: TObject);

var

x,y,p,o,l:integer;

begin

label4.Visible:=false;

label5.Visible:=false;

edit3.text:='';

edit2.Text:='';

edit3.Visible:=false;

edit2.Visible:=false;

form1.left:=140;

form1.top:=100;

for x:=0 to 5 do

for y:=0 to 5 do

begin

stringgrid1.cells[x,y]:='';

stringgrid2.cells[x,y]:='';

end;

for x:=1 to 5 do

for y:=1 to 5 do

begin

stringgrid1.cells[x,y]:='';

stringgrid2.cells[x,y]:='';

case x of

1:ig1[y]:=0;

2:ig2[y]:=0;

3:ig3[y]:=0;

4:ig4[y]:=0;

5:ig5[y]:=0;

end;

case y of

1:ig6[x]:=0;

2:ig7[x]:=0;

3:ig8[x]:=0;

4:ig9[x]:=0;

5:ig10[x]:=0;

end;

if x=6-y then ig12[x]:=0;

if x=y then ig11[x]:=0;

end;

for p:=1 to 5 do

for o:=1 to 5 do

for l:=1 to 13 do ver[p,o,l]:=1;

Massiv;

for p:=1 to 25 do

if q[p]>13 then

q[p]:=q[26];

for p:=1 to 5 do

for o:=1 to 5 do

a[p,o]:=0;

for p:=1 to 13 do

MV[p]:=4;

n:=1;

summa:=0;

edit1.text:=inttostr(q[1]);

end;

procedure TForm1.N4Click(Sender: TObject);

begin

form1.Close;

end;

end.

Список используемой литературы

1. Архангельский А.Я. Программирование в Delphi 4. – М.: Бином, 1999

2. Архангельский А.Я. Программирование в Delphi 5. – М.: Бином, 2000

3. Кордемский Б.А. Математическая смекалка. – М.: Гос. изд. физ.-матем. лит., 1958

4. Кормен Т и др. Алгоритмы: построение и анализ. – М.: МЦНМО, 2000

5. Ивин А.А. Логика: учеб. для вузов. – М.: Гардарика, 1999

6. Липский В. Комбинаторика для программистов. – М.: Мир, 1998

7. Алфёрова З.В. Теория алгоритмов. – М.: Статистика, 1973