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

Обновлено: 06.07.2024

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

Изначально используйте массив целых чисел 8 * 8 для представления шахматной доски.

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

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

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

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

Большинство шахматных программ сегодня, особенно те, которые работают на 64-битном процессоре, используют растровый подход для представления Шахматная доска и генерировать ходы. х88 это альтернативная модель платы для машин без 64-битных процессоров.

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

Bitboards

Теперь, например, если вы хотите переместить ладью с a2 на g2 в вышеприведенном примере, все, что вам нужно сделать, это XOR, который вы используете для битборта:

Битборды имеют преимущество в производительности, когда дело доходит до генерации ходов. Есть и другие преимущества в производительности, которые естественным образом проистекают из представления битбордов. Например, вы можете использовать хеш-таблицы без блокировки , которые являются огромным преимуществом при распараллеливании поиска алгоритм.

Дальнейшее чтение

Простой подход - использовать массив целых чисел 8x8. Используйте 0 для пустых квадратов и присвойте значения фигурам:

Движения частей могут быть рассчитаны с использованием индексов массива. Например, белые пешки двигаются путем увеличения индекса строки на 1 или на 2, если это первый ход пешки. Таким образом, белая пешка на [2] [1] может переместиться на [3] [1] или [4] [1].

Однако это простое представление массива 8x8 имеет шахматную доску, имеет несколько проблем. В частности, когда вы перемещаете «скользящие» фигуры, такие как грачи, слоны и королевы, вам необходимо постоянно проверять индексы, чтобы увидеть, не сдвинулась ли фигура с доски.

Большинство современных шахматных программ, особенно те, которые работают на 64-битном процессоре, используют растровый подход для представления шахматной доски и генерирования ходов. x88 - альтернативная модель платы для машин без 64-битных процессоров.

При создании своего шахматного движка я изначально использовал подход [8] [8], однако недавно я изменил свой код для представления шахматной доски, используя массив из 64 предметов. Я обнаружил, что эта реализация была примерно на 1/3 более эффективной, по крайней мере, в моем случае.

Одна из вещей, которую вы хотите учитывать при использовании подхода [8] [8], - это описание позиций. Например, если вы хотите описать правильный ход для шахматной фигуры, вам потребуется 2 байта для этого. Хотя с массивом элементов [64] вы можете сделать это одним байтом.

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

Row = (byte) (index /8)

Col = (байт) (индекс% 8)

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

Массив из 120 байтов.

Это шахматная доска размером 8x8, окруженная часовыми квадратами (например, 255 для обозначения того, что фигура не может переместиться в этот квадрат). Часовые имеют глубину два, поэтому рыцарь не может перепрыгнуть.

Для перемещения вправо добавьте 1. Для перемещения влево добавьте -1. Вверх на 10, вниз -10, вверх и вправо по диагонали 11 и т. Д. Квадрат A1 - это индекс 21. H1 - это индекс 29. H8 - это индекс 99.

Все разработано для простоты. Но он никогда не будет таким же быстрым, как битборды.

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

Два основных варианта выбора - скорость и четкость кода.

Если скорость является вашим приоритетом, то вы должны использовать 64-битный тип данных для каждого набора фигур на доске (например, белые пешки, черные королевы, пешки en passant). Затем вы можете использовать преимущества собственных побитовых операций при генерации ходов и тестировании легальности ходов.

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

Ну, не уверен, поможет ли это, но Deep Blue использовал одно 6-битное число для представления определенной позиции на доске. Это помогло ему сэкономить место на кристалле по сравнению с конкурентом, который использовал 64-битный битборд.

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

Альтернативой стандартной доске 8x8 является 10x12 почтовый ящик (так называемый, потому что, я думаю, он выглядит как почтовый ящик). Это одномерный массив, который включает в себя стражи вокруг своих «границ», чтобы помочь в создании движения. Это выглядит так:

Вы можете сгенерировать этот массив следующим образом (в JavaScript):

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

Давайте сначала посмотрим на создание законных ходов для рыцаря (нескользящая фигура):

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

Скользящие части не намного сложнее. Давайте посмотрим на епископа:

Вот несколько примеров:

Обратите внимание, что функция slide является общей реализацией. Вы должны быть в состоянии моделировать законные ходы других скользящих частей довольно легко.

Использование битборда было бы эффективным способом представления состояния шахматной доски. Основная идея заключается в том, что вы используете 64-битные наборы битов для представления каждого из квадратов на доске, где первый бит обычно представляет A1 (нижний левый квадрат), а 64-й бит представляет H8 (диагонально противоположный квадрат). Каждый тип фигуры (пешка, король и т. Д.) Каждого игрока (черный, белый) получает свою собственную битовую доску, и все 12 из этих досок составляют игровое состояние. Для получения дополнительной информации ознакомьтесь с этой Википедии .

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

Тогда доска [A] [1] - это квадрат доски A1.

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

используйте положительные значения для белых и отрицательные значения для черных

Я бы на самом деле не моделировал шахматную доску, я просто моделировал бы расположение фигур. Тогда у вас могут быть границы для шахматной доски.

Я знаю, что это очень старый пост, с которым я сталкивался несколько раз, когда гуглил шахматное программирование, но я чувствую, что должен упомянуть, что вполне возможно смоделировать шахматную доску с одномерным массивом, например. шахматная доска [64];

Я бы сказал, что это самый простой подход к представлению на шахматной доске . но, конечно, это базовый подход.

Является ли структура массива одномерной шахматной доски более эффективной, чем двумерный массив (который нуждается во вложенном цикле for для доступа и управления индексами)?

Также возможно использовать одномерный массив с более чем 64 квадратами для представления квадратов вне стола, например, шахматная доска [120]; (с правильно инициализированными массивом часового и игрового поля).

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

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

Для реализации мы воспользуемся библиотеками JavaScript: chessboard.js позволит визуализировать доску, а chess.js – сгенерировать возможные перемещения.

Но не все так просто. Библиотеки JavaScript создадут только базис, а самое интересное – это алгоритм для определения оптимального хода. Начнем с функции, которая возвращает случайный ход из всех возможных:

Такой алгоритм шахмат не самый лучший, но это лишь отправная точка.

Определяем значимость каждой фигуры:

С помощью приведенного кода создаем алгоритм шахмат, который выбирает ход в соответствии с оценкой важности каждой фигуры:

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

Алгоритм начинает понимать тактику, но эффективность зависит от глубины поиска, что мы улучшим на следующих этапах.

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

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

На выходе получаем ИИ шахматы на JavaScript с алгоритмом, который может продемонстрировать неплохую игру.

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

перемещение;
оценка шахматной доски;
минимакс;
альфа-бета-отсечение.

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

Готовый алгоритм можно найти на GitHub.

Шаг 1. Генерация ходов и визуализация шахматной доски

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

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

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

Хотя этот алгоритм не очень солидный шахматист, но это хорошая отправная точка, поскольку его уровня достаточно, чтобы сыграть с нами:

Черные играют случайными ходами

Посмотреть, что получилось на данном этапе, вы можете на JSFiddle.

Шаг 2. Оценка доски

Теперь попробуем понять, какая из сторон сильнее в определенном положении. Самый простой способ добиться этого — посчитать относительную силу фигур на доске, используя следующую таблицу:

С помощью функции оценки мы можем создать алгоритм, который выбирает ход с наивысшей оценкой:

Единственным ощутимым улучшением является то, что теперь наш алгоритм съест фигуру, если это возможно:

Черные играют с помощью простой функции оценки

Посмотреть, что получилось на данном этапе, вы можете на JSFiddle.

Шаг 3. Дерево поиска и минимакс

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

Прим. перев. В одной из наших статей мы уже имели дело с минимаксом — учились создавать ИИ, который невозможно обыграть в крестики-нолики.

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

25–26 ноября, Москва и онлайн, От 24 000 до 52 000 ₽

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

Визуализация минимакса в искусственном положении. Лучший ход для белых — b2-c3, так мы можем гарантировать, что доберемся до позиции, где оценка равна -50

С минимаксом наш алгоритм начинает понимать основную тактику шахмат:

Минимакс с уровнем глубины 2

Посмотреть, что получилось на данном этапе, вы можете на JSFiddle.

Эффективность минимакса в значительной степени зависит от достижимой глубины поиска. Именно это мы улучшим на следующем шаге.

Шаг 4. Альфа-бета-отсечение

Альфа-бета-отсечение — это метод оптимизации алгоритма «минимакс», который позволяет игнорировать некоторые ветви в дереве поиска. Это позволяет нам намного глубже оценить дерево поиска, используя те же ресурсы.

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

Альфа-бета-отсечение не влияет на результат минимакса, оно только ускоряет его.

Этот алгоритм будет более эффективным, если мы сначала проверим те пути, которые ведут к хорошим ходам:

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

С альфа-бета-отсечением мы получаем значительное улучшение минимакса, как показано в следующем примере:

Количество позиций, которые нужно оценить в случае поиска с глубиной 4 и начальной позицией, изображённой на картинке.

Посмотреть, что получилось на данном этапе, вы можете на JSFiddle.

Шаг 5. Улучшенная функция оценки

Первоначальная функция оценки довольно наивна, поскольку мы просто подсчитываем очки фигур, которые находятся на доске. Чтобы улучшить её, мы начнём учитывать положение фигур. Например, конь в центре доски «дороже», потому что он имеет больше доступных ходов и, следовательно, более активен, чем конь на краю доски.

Мы будем использовать слегка скорректированную версию квадратных таблиц, первоначально описанных в вики Chess Programming.

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

Применив это улучшение, мы получим алгоритм, который неплохо играет в шахматы, по крайней мере, с точки зрения простого игрока:

Улучшенная оценка и альфа-бета-отсечение с глубиной поиска 3

Посмотреть, что получилось на данном этапе, вы можете на JSFiddle.

Заключение

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

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

Вот некоторые дополнительные улучшения, которые мы могли бы внести в алгоритм:

Если вы хотите узнать о шахматных алгоритмах больше, зайдите на Chess Programming Wiki.

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

Обычно он известен как Презентация доски.

Ответы 14

Самый простой подход - использовать целочисленный массив 8x8. Используйте 0 для пустых квадратов и присвойте значения фигурам:

Ход фигур можно рассчитать, используя индексы массива. Например, белые пешки перемещаются путем увеличения индекса строки на 1 или на 2, если это первый ход пешки. Таким образом, белая пешка на [2] [1] может перейти на [3] [1] или [4] [1].

Однако это простое представление массива 8x8 имеет несколько проблем. В частности, когда вы перемещаете «скользящие» фигуры, такие как ладьи, слоны и ферзи, вам необходимо постоянно проверять индексы, чтобы видеть, не сдвинулась ли фигура с доски.

Большинство шахматных программ сегодня, особенно те, которые работают на 64-битном процессоре, используют растровый подход для представления шахматной доски и генерации ходов. x88 - это альтернативная модель платы для машин без 64-битных процессоров.

Как вы отслеживаете с помощью этой модели, сделал ли конкретный король или ладья ход или нет в отношении рокировки? Пешковые движения относительно взятия на проходе?

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

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

используйте положительные вставки для белого и отрицательные для черного

Первоначально используйте 8 * 8 целочисленный массив для представления шахматной доски.

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

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

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

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

Как вы отметили,

Most chessprograms today, especially those that run on a 64 bit CPU, use a bitmapped approach to represent a chessboard and generate moves. x88 is an alternate board model for machines without 64 bit CPUs.

Как отличить слона от коня, если они оба представлены целым числом 3?

Нет, они не представлены числом 3. Это их материальная ценность (слон и кони стоят примерно 3 пешки).

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

Тогда доска [A] [1] - это доска A1.

На самом деле, вы бы использовали числа, а не буквы, чтобы сохранить математическую логику, где фигурам разрешено переходить в простые.

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

У вас есть два основных варианта: скорость и ясность кода.

Если скорость является вашим приоритетом, вы должны использовать 64-битный тип данных для каждого набора фигур на доске (например, белых пешек, черных ферзей, проходных пешек). Затем вы можете воспользоваться преимуществами собственных побитовых операций при генерации ходов и проверке законности перемещения.

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

Не уверен, что это помогает, но Deep Blue использовал одно 6-битное число для обозначения определенной позиции на доске. Это помогло сэкономить место на кристалле по сравнению с его конкурентом, который использовал 64-битную битовую плату.

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

Использование битовой доски было бы эффективным способом представления состояния шахматной доски. Основная идея состоит в том, что вы используете 64-битные биты для представления каждого квадрата на доске, где первый бит обычно представляет A1 (нижний левый квадрат), а 64-й бит представляет H8 (диагонально противоположный квадрат). Каждый тип фигуры (пешка, король и т. д.) Каждого игрока (черный, белый) получает свою битовую доску, и все 12 этих досок составляют состояние игры. Для получения дополнительной информации ознакомьтесь с этой Википедией статья.

На самом деле я бы не моделировал шахматную доску, я просто моделировал положение фигур. Тогда у вас могут быть границы для шахматной доски.

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

При создании своего шахматного движка я изначально использовал подход [8] [8], однако недавно я изменил свой код, чтобы представить шахматную доску с использованием массива из 64 элементов. Я обнаружил, что эта реализация была примерно на 1/3 эффективнее, по крайней мере, в моем случае.

Одна из вещей, которую вы хотите учитывать при использовании подхода [8] [8], - это описание позиций. Например, если вы хотите описать допустимый ход для шахматной фигуры, вам потребуется 2 байта для этого. В то время как с массивом элементов [64] вы можете сделать это с одним байтом.

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

Строка = (байт) (индекс / 8)

Col = (байт) (индекс% 8)

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

Массив 120 байт.

Это шахматная доска 8x8, окруженная контрольными квадратами (например, 255, чтобы указать, что фигура не может перейти на это поле). Стражи имеют глубину два, так что рыцарь не может перепрыгнуть.

Для перемещения вправо добавьте 1. Для перемещения влево добавьте -1. Вверх 10, вниз -10, вверх и вправо по диагонали 11 и т. д. Квадрат A1 - это индекс 21. H1 - это индекс 29. H8 - это индекс 99.

Все сделано для простоты. Но он никогда не будет таким быстрым, как битборды.

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

Битборды

Теперь, например, если вы хотите переместить ладью с a2 на g2 в приведенном выше примере, все, что вам нужно сделать, это выполнить XOR для битовой доски:

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

Дальнейшее чтение

Битовые доски быстрее, чем представление массива, но не по указанным вами причинам. Как вы утверждаете, они имеют меньший вес на нет (массив 8x8 char составляет всего 64 байта), и сделать один ход на самом деле не быстрее. Основное преимущество заключается в том, что вы можете анализировать несколько позиций платы за одну операцию, используя битовые маски и сдвиги. Это позволяет намного быстрее генерировать и оценивать ходы.

Ссылка на хеш-таблицу без блокировки не работает. Еще одна хорошая ссылка была бы отличной!

Альтернативой стандартному Доска 8x8 является почтовый ящик 10x12 (так называемый, потому что, я думаю, он похож на почтовый ящик). Это одномерный массив, который включает часовые вокруг своих «границ», чтобы помочь с генерацией перемещения. Это выглядит так:

Вы можете сгенерировать этот массив следующим образом (в JavaScript):

Конечно, в реальной реализации вы бы поместили фактические объекты на место меток платы. Но вы бы оставили отрицательные (или что-то подобное). Эти места делают создание ходов намного менее болезненным, потому что вы можете легко определить, когда вы сбежали с доски, проверив это специальное значение.

Давайте сначала посмотрим на создание допустимых ходов для коня (не скользящей фигуры):

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

Скользящие детали не намного сложнее. Посмотрим на епископа:

Вот некоторые примеры:

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

Я знаю, что это очень старый пост, на который я наткнулся несколько раз, когда гуглил шахматное программирование, но я чувствую, что должен упомянуть, что вполне возможно смоделировать шахматную доску с 1D-массивом, например. шахматная доска [64];

Я бы сказал, что это самый простой подход к представлению на шахматной доске . но, конечно, это базовый подход.

Является ли структура массива одномерной шахматной доски более эффективной, чем двумерный массив (которому требуется вложенный цикл for для доступа и управления индексами)?

Также можно использовать одномерный массив с более чем 64 квадратами для представления квадратов OffBoard, например, шахматная доска [120]; (с правильной инициализацией контрольного массива и игровых полей на доске).

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

Читайте также: