КуМир (Комплект Учебных МИРов) — это учебная среда программирования, разработанная специально для обучения базовым концепциям алгоритмизации. Её главная фишка — использование русскоязычного синтаксиса, что серьёзно снижает порог входа для начинающих программистов. Вместо пугающих if, while и for тут привычные "если", "пока" и "нц". Согласитесь, куда понятнее для школьника, который только начинает осваивать программирование.
В центре нашего внимания сегодня — исполнитель Робот. Это виртуальный персонаж, который "живёт" на прямоугольном клетчатом поле и выполняет простые команды: двигаться в четырёх направлениях и закрашивать клетки. Казалось бы, примитивно, но именно в этой простоте и кроется гениальность для обучения. Поле Робота напоминает шахматную доску — прямоугольник из клеток, но с одним важным отличием: некоторые клетки могут быть заблокированы стенами, которые Робот не может пересекать. Эти ограничения добавляют интересный элемент головоломки даже в простейшие задачи.
Робот понимает небольшой набор команд:вверх, вниз, влево, вправо — для передвижения.закрасить — для окрашивания текущей клетки.- несколько команд-вопросов, как
сверху свободно или снизу стена, которые помогают Роботу ориентироваться в пространстве.
Что действительно круто в этом исполнителе — мы можем сами создавать поля любой конфигурации и программировать Робота для решения разнообразных задач: от простейшего перемещения до сложных алгоритмов поиска маршрута в лабиринте.
Среда КуМир позволяет запускать программы в пошаговом режиме, что делает её отличным инструментом для отладки. Можно буквально наблюдать, как Робот выполняет каждую команду, и сразу видеть результат. Это то, чего часто не хватает в "взрослых" языках программирования — наглядности исполнения кода. Я часто замечаю, как студенты, начинавшие с КуМира, гораздо быстрее схватывают концепции циклов и условий в "серьёзных" языках программирования. Почему? Да потому что они уже на визуальном уровне понимают, как работают эти конструкции. Они видели, как Робот повторяет одни и те же действия в цикле или принимает разные решения в зависимости от условий.
Ещё одна сильная сторона Робота — он идеально подходит для освоения основ алгоритмического мышления. Когда пишешь программу для Робота, волей-неволей приходится разбивать задачу на маленькие логические шаги, думать наперёд и предвидеть возможные проблемы. Это именно те навыки, которые лежат в основе хорошего программирования, незовисимо от языка.
В этой статье мы разберём задачи с Роботом — от элементарных до весьма нетривиальных. Я постараюсь не просто дать готовые решения, а показать ход мыслей, которые приводят к этим решениям. Ведь главное в программировании — не знать синтаксис языка, а уметь мыслить алгоритмически. Так что, если вы новичок в программировании или учитель, который хочет сделать уроки информатики увлекательнее — продолжайте чтение. А если вы опытный программист, которому интересно вспомнить, с чего всё начиналось — вам тоже будет полезно заглянуть под капот этого простого, но мощного учебного инструмента.
Особенности исполнителя Робот и его сравнение с другими исполнителями
Робот в КуМире выделяется среди других исполнителей своей интуитивной понятностью и наглядностью. Представьте его как маленького виртуального персонажа, который бродит по клетчатому полю и выполняет ваши команды. Эта простота обманчива — за ней скрывается мощный образовательный инструмент. Одна из ключевых особенностей Робота — ограниченный набор команд. В отличие от реального программирования, где библиотеки содержат тысячи функций, наш виртуальный друг работает всего с десятком инструкций. И знаете что? Этого достаточно для решения удивительно широкого спектра задач! Такое ограничение заставляет мыслить креативно и разбивать сложные алгоритмы на простые шаги.
Ещё одна фишка Робота — его двумерный мир с препятствиями. В этом он похож на персонажа компьютерной игры, что делает процесс обучения невероятно увлекательным. Ты буквально видишь, как твой код оживает, как Робот шагает по полю, обходит стены и закрашивает клетки.
А теперь давайте сравним Робота с другими исполнителями среды КуМир:
Робот vs Чертёжник
Чертёжник работает в системе координат и рисует линии, передвигаясь от точки к точке. Если Робот ограничен дискретными перемещениями по клеткам, то Чертёжник оперирует в непрерывном пространстве. Это существенная разница!
| Code | 1
2
3
4
5
6
7
8
9
10
| // Пример программы для Чертёжника
использовать Чертёжник
алг
нач
опустить перо
сместиться на вектор(10, 10)
сместиться на вектор(0, -20)
сместиться на вектор(-10, 10)
поднять перо
кон |
|
| Code | 1
2
3
4
5
6
7
8
9
10
11
12
| // Пример программы для Робота
использовать Робот
алг
нач
вправо
вправо
вниз
закрасить
вниз
влево
закрасить
кон |
|
Робот vs Водолей
Водолей — ещё один исполнитель в КуМире, работающий с переливаниями жидкости между сосудами разного объёма. Здесь мы имеем дело с абсолютно другим типом задач — комбинаторными головоломками.
| Code | 1
2
3
4
5
6
7
8
9
| // Пример программы для Водолея
использовать Водолей
алг
нач
наполнить(1)
перелить(1, 2)
вылить(2)
перелить(1, 2)
кон |
|
Робот vs Кузнечик
Кузнечик перемещается по одномерной числовой прямой прыжками фиксированной длины. Это упрощенная версия Робота, если можно так выразиться.
| Code | 1
2
3
4
5
6
7
8
| // Пример программы для Кузнечика
использовать Кузнечик
алг
нач
вперед(3)
вперед(2)
назад(1)
кон |
|
Что делает Робота особенным?
Робот, пожалуй, наиболее универсальный из всех исполнителей КуМира. Он позволяет изучать:
1. Линейные алгоритмы — через простые перемещения и закрашивания.
2. Ветвления — через проверки наличия стен и принятия решений.
3. Циклы — через повторения действий для закрашивания областей.
4. Подпрограммы — через создание вспомогательных алгоритмов для типовых задач.
Ещё один аспект, который часто недооценивают — Робот отлично подходит для визуализации алгоритмов поиска пути, включая такие классические, как поиск в глубину, поиск в ширину или алгоритм A*. Да-да, на этом простом исполнителе можно демонстрировать достаточно продвинутые концепции!
Я вспоминаю, как однажды мои ученики, освоив базовые принципы работы с Роботом, самостоятельно "изобрели" алгоритм заливки, не зная, что это классический алгоритм в компьютерной графике. Они просто решали задачу закрашивания замкнутой области. Вот в чём сила этого исполнителя — он позволяет "открывать" фундаментальные алгоритмические принципы через игру.
При всей своей простоте, этот виртуальный персонаж становится мощным инструментом для развития алгоритмического мышления. И главное — он делает процесс обучения программированию увлекательным, что особенно важно на начальных этапах, когда каждый успех укрепляет уверенность и мотивацию двигаться дальше в этом увлекательном мире алгоритмов и программ.
Исполнитель Робот
дали вот несколько задач (попросили решить, будучи студентом уже не ничего помню из курса информатики), можете проверить 1-3 и объяснить как делать... Задача для исполнителя Робот
Народ, нужны советы по поводу решения этой задачи.Буду признателен любым советам.
Условие:Задачу необходимо решить, используя условный оператор... [КуМир] Робот: закрасить все клетки соединенных ответвлений
Не могу написать программу в кумире связанную с роботом.
Задача такая:
Робот находится в левом конце горизонтального коридора ширины 1. Коридор... [КуМир] Робот находится внутри замкнутой области, найти периметр области
Робот находится внутри замкнутой области, не обязательно прямоугольной, неизвестных размеров. Используя алгоритм с результатами, вычислить и вывести...
Базовые команды и принципы работы с Роботом
Прежде чем мы начнём решать задачи с Роботом, нужно разобраться с его командным языком. Знаю по опыту — понимание базовых инструментов экономит массу времени при разработке сложных алгоритмов. Всю систему команд Робота в КуМире можно разделить на три основные группы: команды перемещения, команды действия и команды проверки условий. Давайте разберём каждую группу подробно.
Команды перемещения
Это самые простые и интуитивно понятные команды, которые заставляют Робота двигаться по полю:
| Code | 1
2
3
4
| вверх // Робот перемещается на одну клетку вверх
вниз // Робот перемещается на одну клетку вниз
влево // Робот перемещается на одну клетку влево
вправо // Робот перемещается на одну клетку вправо |
|
Команды действия
Пока что у нашего Робота только одно действие, кроме перемещения:
| Code | 1
| закрасить // Закрашивает текущую клетку, на которой стоит Робот |
|
Команды проверки условий
Вот где скрыта настоящая мощь Робота! Эти команды позволяют ему "смотреть по сторонам" и принимать решения:
| Code | 1
2
3
4
5
6
7
8
9
10
11
| сверху свободно // Возвращает истина, если сверху нет стены
снизу свободно // Возвращает истина, если снизу нет стены
слева свободно // Возвращает истина, если слева нет стены
справа свободно // Возвращает истина, если справа нет стены
сверху стена // Возвращает истина, если сверху стена
снизу стена // Возвращает истина, если снизу стена
слева стена // Возвращает истина, если слева стена
справа стена // Возвращает истина, если справа стена
клетка закрашена // Возвращает истина, если текущая клетка закрашена |
|
| Code | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
| использовать Робот
алг
нач
// Рисуем букву "Г"
закрасить
вправо
закрасить
вправо
закрасить
вниз
закрасить
вниз
закрасить
кон |
|
| Code | 1
2
3
4
5
6
7
8
9
| использовать Робот
алг
нач
// Рисуем горизонтальную линию длиной 5 клеток
нц 5 раз
закрасить
вправо
кц
кон |
|
нц ... кц — это цикл в КуМире. В данном случае мы повторяем два действия (закрасить и двигаться вправо) пять раз. А теперь давайте добавим немного интеллекта нашему Роботу с помощью условных операторов:
| Code | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| использовать Робот
алг
нач
// Идём вправо, пока не встретим стену
нц пока справа свободно
вправо
кц
// Если снизу свободно, идём вниз
если снизу свободно то
вниз
иначе
закрасить // Отмечаем тупик
все
кон |
|
1. нц пока <условие> ... кц — цикл с предусловием.
2. если ... то ... иначе ... все — условный оператор.
Комбинирование этих базовых конструкций позволяет создавать сложные алгоритмы поведения Робота.
Разработка алгоритмов для Робота обычно следует определённым принципам:
1. Принцип локальных действий — Робот "видит" только соседние клетки и должен принимать решения на основе этой ограниченной информации.
2. Принцип последовательного выполнения — каждая команда выполняется только после завершения предыдущей.
3. Принцип избегания ошибок — хорошая программа для Робота всегда проверяет возможность выполнения действия перед его выполнением.
Когда я только начинал работать с Роботом, часто допускал одну типичную ошибку — забывал проверять наличие стены перед движением. Это приводило к аварийному завершению программы. Со временем выработалась привычка всегда писать код по шаблону:
| Code | 1
2
3
| если <направление> свободно то
<движение в направлении>
все |
|
| Code | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
| использовать Робот
// Вспомогательный алгоритм для закрашивания квадрата 2x2
алг закрасить_квадрат()
нач
закрасить
вправо
закрасить
вниз
закрасить
влево
закрасить
кон
// Основная программа
алг
нач
закрасить_квадрат() // Вызов вспомогательного алгоритма
// Перемещаемся к следующей позиции
вправо
вправо
закрасить_квадрат() // Снова вызываем вспомогательный алгоритм
кон |
|
Практика показывает, что многим начинающим сложно перейти от линейных алгоритмов к использованию циклов. Для облегчения этого перехода я рекомендую сначала выполнить несколько итераций "вручную", записывая последовательность действий, а потом искать в ней повторяющиеся паттерны. Как только вы заметите повторение — это сигнал к применению цикла. Мастерство программирования Робота приходит с практикой. Начните с простых линейных алгоритмов, затем добавляйте условия, циклы, и постепенно вы научитесь создавать сложные интеллектуальные программы, способные решать нетривиальные задачи навигации и манипуляции.
В следующих разделах мы перейдём к системе координат и детальным примерам — от простых перемещений до сложных алгоритмов сканирования поля и принятия решений.
Система координат и перемещения Робота
Работа с Роботом в КуМире неразрывно связана с пониманием его системы координат. В отличие от математической системы, к которой многие привыкли, координаты Робота имеют свои особенности, и осознание этих нюансов существенно упрощает программирование сложных алгоритмов. Поле Робота представляет собой прямоугольную таблицу из клеток. Каждая клетка идентифицируется парой координат (x, y), где:- x — номер столбца (отсчитывается слева направо).
- y — номер строки (отсчитывается сверху вниз).
Важный момент: начало координат (0, 0) находится в левом верхнем углу поля. Это отличается от традиционной декартовой системы, где начало обычно в левом нижнем углу. Такая "экранная" система координат часто используется в компьютерной графике и игровых движках.
| Code | 1
2
3
4
5
6
7
| (0,0) → (1,0) → (2,0) → ...
↓ ↓ ↓
(0,1) → (1,1) → (2,1) → ...
↓ ↓ ↓
(0,2) → (1,2) → (2,2) → ...
↓ ↓ ↓
... ... ... |
|
Перемещения Робота осуществляются посредством четырех базовых команд: "вверх", "вниз", "влево" и "вправо". Каждая такая команда меняет одну из координат на единицу:
| Code | 1
2
3
4
| вверх → y уменьшается на 1
вниз → y увеличивается на 1
влево → x уменьшается на 1
вправо → x увеличивается на 1 |
|
| Code | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| использовать Робот
алг
нач
нц для i от 1 до 10
нц i раз
закрасить
вправо
кц
нц i раз
закрасить
вниз
кц
нц i+1 раз
закрасить
влево
кц
нц i+1 раз
закрасить
вверх
кц
кц
кон |
|
| Code | 1
2
3
4
| если справа свободно и не клетка закрашена то
вправо
закрасить
все |
|
При работе с большими полями удобно использовать относительные координаты, отсчитываемые от начального положения Робота. Например, чтобы переместить Робота на 3 клетки вправо и 2 вниз от его текущей позиции, можно написать:
| Code | 1
2
3
4
5
6
| нц 3 раз
вправо
кц
нц 2 раз
вниз
кц |
|
| Code | 1
2
3
4
5
6
| // Движение по диагонали вправо-вниз
нц 5 раз
вправо
вниз
закрасить
кц |
|
Особый случай – когда Робот должен обойти препятствие. Здесь уже потребуется применить элементы искусственного интеллекта – алгоритм обхода препятствий. Один из простейших вариантов – метод "правой руки":
| Code | 1
2
3
4
5
6
7
8
9
10
11
12
| // Алгоритм "правой руки" для обхода препятствий
нц пока не клетка закрашена
если справа свободно то
вправо
иначе если сверху свободно то
вверх
иначе если слева свободно то
влево
иначе
вниз
все
кц |
|
Понимание системы координат и принципов перемещения Робота – это фундамент, на котором строятся все остальные алгоритмы работы с этим исполнителем. Освоив базовые принципы перемещения, вы сможете решать гораздо более сложные задачи – от заполнения областей до нахождения выхода из лабиринта.
Отладка программ и обработка ошибок исполнителя
Казалось бы, что может пойти не так при программировании такого примитивного исполнителя как Робот? На практике ошибок получается немало, и без навыков отладки можно застрять даже на простых задачах. Как человек, который сломал немало виртуальных роботов, делюсь накопленным опытом. В КуМире встроены мощные инструменты отладки, которые многие начинающие просто игнорируют. А зря! Пожалуй, самый полезный из них — пошаговое выполнение программы. Запустив программу в пошаговом режиме (клавиша F8), вы можете наблюдать за каждым действием Робота и состоянием переменных. Это как рентген для вашего алгоритма — сразу видно, где начинаются проблемы.
| Code | 1
2
3
4
5
6
7
8
9
10
| использовать Робот
алг
нач
нц пока справа свободно
вправо
если клетка закрашена то
вниз // Потенциально опасное место!
все
кц
кон |
|
Типичные ошибки при работе с Роботом можно разделить на несколько категорий:
1. Выход за границы поля или столкновение со стеной
Это самая частая ошибка. Программа аварийно завершается с сообщением вроде "Робот врезался в стену". Решение простое — всегда проверять доступность направления перед движением:
| Code | 1
2
3
| если справа свободно то
вправо
все |
|
Робот бесконечно ходит по кругу или топчется на месте. Нужно добавить условие выхода из цикла:
| Code | 1
2
3
| нц пока не клетка закрашена и справа свободно
вправо
кц |
|
Часто встречается путаница между "сверху свободно" и "сверху стена". Помните: они возвращают противоположные значения!
| Code | 1
2
3
4
| // Ошибочно, оба условия могут быть истинны одновременно
если сверху свободно или сверху стена то
закрасить
все |
|
Например, алгоритм прекрасно работает на пустом поле, но ломается при наличии стен. Всегда тестируйте на разных конфигурациях поля.
Для эффективной отладки я применяю некоторые техники, которые могу порекомендовать:
Техника "маркировки пути"
Закрашивайте клетки разными цветами, чтобы отмечать, где уже побывал Робот. Это помогает визуально отслеживать маршрут и находить логические ошибки.
| Code | 1
2
3
4
5
6
7
8
| использовать Робот
алг
нач
нц 10 раз
закрасить // Отмечаем путь
вправо
кц
кон |
|
КуМир позволяет выводить значения переменных и результаты проверок. Используйте это для отладки:
| Code | 1
2
3
4
5
6
7
8
9
| использовать Робот
алг
нач
нц для i от 1 до 5
вывод "Шаг ", i
вывод "Спереди стена?", справа стена
вправо
кц
кон |
|
Начните с простой рабочей версии, а затем добавляйте новую функциональность малыми порциями, тестируя после каждого изменения. Это снижает вероятность появления сложных ошибок. Что касается обработки ошибок, то в КуМире нет таких конструкций, как try-catch в "взрослых" языках. Вместо этого мы используем проактивный подход — предотвращаем ошибки с помощью проверок:
| Code | 1
2
3
4
5
6
7
8
9
10
| // Безопасное движение вправо
алг безопасно_вправо()
нач
если справа свободно то
вправо
рез := истина
иначе
рез := ложь
все
кон |
|
При разработке сложных алгоритмов полезно разбивать программу на функциональные блоки — подпрограммы. Это не только делает код чище, но и упрощает отладку, позволяя тестировать каждый блок отдельно:
| Code | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| использовать Робот
// Подпрограмма для закрашивания периметра квадрата
алг периметр_квадрата(длина: цел)
нач
нц 4 раз
нц длина - 1 раз
закрасить
вправо
кц
закрасить
вниз
кц
кон
алг
нач
периметр_квадрата(5)
кон |
|
Когда я обучаю программированию, часто советую вести "журнал ошибок" — записывать возникающие проблемы и способы их решения. Это помогает избежать повторения одних и тех же ошибок. Иногда для отладки сложных алгоритмов я использую "метод ручного моделирования" — прохожу алгоритм на бумаге, отмечая положение Робота и состояние переменных на каждом шаге. Это особено полезно для понимания рекурсивных алгоритмов или сложных условий.
| Code | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| // Алгоритм заливки области
алг заливка()
нач
если не клетка закрашена то
закрасить
если справа свободно то
вправо
заливка()
влево
все
если снизу свободно то
вниз
заливка()
вверх
все
// и так далее для всех направлений
все
кон |
|
Помните, что отладка — это искусство, требующее терпения. Даже опытные программисты тратят уйму времени на поиск и исправление ошибок. Если вы зашли в тупик, иногда лучший выход — отвлечься ненадолго и вернуться к задаче со свежим взглядом. Моя практика показывает, что решение нередко приходит именно таким образом. При работе с Роботом особенно важно тестировать программу на разичных конфигурациях поля — с разным расположением стен, с разным начальным положением Робота. Это поможет выявить слабые места в вашем алгоритме и сделать его по-настоящему надежным.
Визуальный редактор обстановки и его возможности
Одна из самых мощных, но недооценённых фишек работы с Роботом в КуМире — это визуальный редактор обстановки. По сути, это конструктор лабиринтов и полей для нашего виртуального героя. Когда я впервые открыл для себя все его возможности, моё представление о том, какие задачи можно решать с Роботом, расширилось в разы. Для доступа к редактору достаточно нажать кнопку "Обстановка" в верхней панели КуМира. И вот тут начинается волшебство! Перед вами открывается лаборатория, где вы буквально становитесь творцом мира для Робота. Первое, на что стоит обратить внимание — настройки размера поля. По умолчанию вам доступно поле 15×15 клеток, но вы можете его увеличить или уменьшить по своему усмотрению. Для учебных задач обычно хватает стандартного размера, но для более продвинутых алгоритмов (например, поиск пути в сложном лабиринте) я рекомендую увеличивать поле до 30×30 и даже больше.
Основные элементы, которыми мы можем манипулировать:- Стены (непроходимые препятствия).
- Закрашенные клетки.
- Начальное положение Робота.
Добавление стен происходит предельно интуитивно — выбираете инструмент "Стена" и кликаете между клетками, где хотите разместить преграду. Можно создавать как одиночные стены, так и замкнутые области, формируя настоящие лабиринты. Любители головоломок могут воссоздать классические лабиринты вроде лабиринта Минотавра или более современные вариации. Интересная фишка — возможность создавать закрашенные клетки. Это особенно полезно, когда вы хотите подготовить определённую конфигурацию поля для тестирования алгоритмов распознавания образов или заливки областей. Просто выбираете соответствующий инструмент и кликаете по нужным клеткам.
Самое важное — установка начальной позиции Робота. Ведь в реальных задачах Робот может стартовать из разных точек поля. Эта настройка критически важна для тестирования устойчивости ваших алгоритмов. Хорошая программа должна работать корректно независимо от начальной позиции Робота (конечно, в рамках логики задачи).
| Code | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| // Пример алгоритма, устойчивого к разным начальным положениям
использовать Робот
алг
нач
// Сначала движемся в левый верхний угол
нц пока слева свободно
влево
кц
нц пока сверху свободно
вверх
кц
// Теперь положение стандартизировано
// и можно выполнять основной алгоритм
...
кон |
|
Использование редактора обстановки открывает потрясающие возможности для творчества. Помню, как мы с учениками создали "Чемпионат роботов" — соревнование, где каждый разрабатывал своё поле-головоломку, а затем все пытались написать программы для прохождения лабиринтов друг друга. Вот где разгуляться фантазии и одновременно отточить навыки программирования!
Есть в редакторе и некоторые хитрости. Например, мало кто знает, что можно создавать "острова" — области, полностью окружённые стенами, куда Робот не может попасть. Такие конструкции полезны для тестирования алгоритмов поиска связных областей. Еще один полезный приём — создание "коридоров" определённой ширины. Это позволяет моделировать реальные задачи робототехники, где роботу нужно перемещаться по заданному маршруту, например, по линии.
| Code | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| // Алгоритм движения по коридору
использовать Робот
алг
нач
нц пока не клетка закрашена
если справа стена и слева стена то
вниз // Коридор идет вертикально
иначе если сверху стена и снизу стена то
вправо // Коридор идет горизонтально
иначе
// Обработка перекрестка
...
все
кц
кон |
|
Одно из моих любимых применений редактора обстановки — это моделирование реальных жизненных ситуаций. Например, план эвакуации из здания школы или оптимальная расстановка станков в цеху. Такой подход помогает ученикам увидеть практическую пользу от программирования и алгоритмизации.
Важный момент для учителей: визуальный редактор — отличный инструмент для создания разноуровневых заданий. На одном и том же поле можно давать задачи разной сложности в зависимоти от подготовки учеников. Кому-то достаточно прейти из точки А в точку Б, а продвинутые могут искать оптимальный маршрут или решать задачу с дополнительными условиями.
Освоив работу с редактором обстановки, вы откроете для себя новые горизонты возможностей исполнителя Робот, трансформируя его из простого учебного примера в мощную платформу для моделирования и решения алгоритмических задач различной сложности.
Простые задачи для начинающих
Теперь, когда мы разобрались с основами, давайте перейдём к практике. Ничто не помогает освоить программирование лучше, чем решение конкретных задач. Начнём с простых примеров, которые помогут новичкам освоиться с Роботом и почувствовать уверенность в своих силах.
Задача 1: Обход периметра
Пожалуй, классика жанра – заставить Робота обойти периметр прямоугольника и закрасить все клетки по контуру.
| Code | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
| использовать Робот
алг
нач
// Идём вправо до стены, закрашивая каждую клетку
нц пока справа свободно
закрасить
вправо
кц
закрасить // Не забываем про последнюю клетку!
// Теперь идём вниз до стены
нц пока снизу свободно
вниз
закрасить
кц
// Идём влево до стены
нц пока слева свободно
влево
закрасить
кц
// И наконец, поднимаемся вверх до начальной точки
нц пока сверху свободно
вверх
закрасить
кц
кон |
|
Задача 2: Закрашивание "шахматной доски"
Теперь задача посложнее – нужно закрасить клетки поля в шахматном порядке. Здесь понадобится отслеживать чередование клеток:
| Code | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
| использовать Робот
алг
нач
цел i, j
лог закрашивать
// Устанавливаем начальное значение флага
закрашивать := истина
нц пока не снизу стена
// Идём по строке вправо, пока не упрёмся в стену
нц пока не справа стена
если закрашивать то
закрасить
все
закрашивать := не закрашивать
вправо
кц
// Обрабатываем последнюю клетку в строке
если закрашивать то
закрасить
все
// Переходим на следующую строку
вниз
// Возвращаемся в начало строки
нц пока не слева стена
влево
кц
// Переключаем флаг для новой строки, чтобы сохранить шахматный порядок
если справа свободно то
закрашивать := не закрашивать
все
кц
// Обрабатываем последнюю строку
закрашивать := не закрашивать
нц пока не справа стена
если закрашивать то
закрасить
все
закрашивать := не закрашивать
вправо
кц
если закрашивать то
закрасить
все
кон |
|
закрашивать, которая меняет своё значение при каждом шаге.
Задача 3: Спираль
А теперь заставим Робота двигаться по спирали, закрашивая клетки:
| Code | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
| использовать Робот
алг
нач
цел шагов_вправо, шагов_вниз, шагов_влево, шагов_вверх
шагов_вправо := 1
шагов_вниз := 1
шагов_влево := 2
шагов_вверх := 2
нц пока справа свободно и снизу свободно и слева свободно и сверху свободно
// Идём вправо
нц шагов_вправо раз
если не справа стена то
закрасить
вправо
все
кц
шагов_вправо := шагов_вправо + 2
// Идём вниз
нц шагов_вниз раз
если не снизу стена то
закрасить
вниз
все
кц
шагов_вниз := шагов_вниз + 2
// Идём влево
нц шагов_влево раз
если не слева стена то
закрасить
влево
все
кц
шагов_влево := шагов_влево + 2
// Идём вверх
нц шагов_вверх раз
если не сверху стена то
закрасить
вверх
все
кц
шагов_вверх := шагов_вверх + 2
кц
кон |
|
Задача 4: Поиск выхода из простого лабиринта
В этой задаче Робот должен найти выход из лабиринта, двигаясь по правилу "правой руки" (всегда держаться правой стены):
| Code | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| использовать Робот
алг
нач
// Продолжаем, пока не найдём закрашенную клетку (выход)
нц пока не клетка закрашена
// Приоритет: вправо, вниз, влево, вверх (правило правой руки)
если справа свободно то
вправо
иначе если снизу свободно то
вниз
иначе если слева свободно то
влево
иначе если сверху свободно то
вверх
все
кц
кон |
|
Задача 5: Закрашивание замкнутой области
А вот и первая задачка на заливку – Робот должен закрасить все клетки внутри замкнутой области:
| Code | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
| использовать Робот
алг Заливка
нач
закрасить
// Проверяем соседние клетки и рекурсивно вызываем алгоритм
если справа свободно и не справа стена то
вправо
если не клетка закрашена то
Заливка
все
влево
все
если снизу свободно и не снизу стена то
вниз
если не клетка закрашена то
Заливка
все
вверх
все
если слева свободно и не слева стена то
влево
если не клетка закрашена то
Заливка
все
вправо
все
если сверху свободно и не сверху стена то
вверх
если не клетка закрашена то
Заливка
все
вниз
все
кон |
|
Задача 6: Подсчёт клеток определённого типа
Иногда нам нужно не просто закрасить клетки, но и подсчитать их количество:
| Code | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
| использовать Робот
алг
нач
цел количество_закрашенных := 0
// Проходим всё поле
нц пока не снизу стена
// Идём по строке
нц пока не справа стена
если клетка закрашена то
количество_закрашенных := количество_закрашенных + 1
все
вправо
кц
// Проверяем последнюю клетку в строке
если клетка закрашена то
количество_закрашенных := количество_закрашенных + 1
все
// Переходим на следующую строку
вниз
// Возвращаемся в начало строки
нц пока не слева стена
влево
кц
кц
// Проверяем последнюю строку
нц пока не справа стена
если клетка закрашена то
количество_закрашенных := количество_закрашенных + 1
все
вправо
кц
если клетка закрашена то
количество_закрашенных := количество_закрашенных + 1
все
вывод "Количество закрашенных клеток: ", количество_закрашенных
кон |
|
Задача 7: Движение до первой закрашенной клетки
Финальная задача в нашем наборе простых примеров – Робот должен двигаться по заданному алгоритму, пока не найдёт закрашенную клетку:
| Code | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
| использовать Робот
алг
нач
// Двигаемся зигзагом, пока не найдём закрашенную клетку
нц пока не клетка закрашена
// Идём вправо, пока можем
нц пока справа свободно и не клетка закрашена
вправо
кц
если клетка закрашена то
выход // Выходим из внешнего цикла
все
// Если можем, спускаемся на строку вниз
если снизу свободно то
вниз
иначе
выход // Некуда двигаться, выходим
все
// Идём влево, пока можем
нц пока слева свободно и не клетка закрашена
влево
кц
если клетка закрашена то
выход // Выходим из внешнего цикла
все
// Если можем, спускаемся на строку вниз
если снизу свободно то
вниз
иначе
выход // Некуда двигаться, выходим
все
кц
вывод "Робот нашел закрашенную клетку!"
кон |
|
На этих примерах вы можете увидеть, как даже с ограниченным набором команд можно решать разнообразные алгоритмические задачи. Важно понимать, что при решении задач с Роботом нужно тщательно продумывать алгоритм перед написанием кода. Решение "методом проб и ошибок" обычно оказывается неэффективным.
Помните, что хороший алгоритм должен работать корректно на любом допустимом поле, а не только на конкретном примере. Поэтому всегда тестируйте свои программы на разных конфигурациях поля, с разными начальными положениями Робота.
Линейные алгоритмы и задачи на закрашивание клеток
Линейные алгоритмы — самый понятный тип программ для начинающих программистов. Когда команды выполняются последовательно, одна за другой, без разветвлений и повторений, новички могут легко представить всю цепочку действий Робота. Именно с таких алгоритмов стоит начинать знакомство с программированием в КуМире.
Рассмотрим несколько задач на линейные алгоритмы, которые помогут освоить базовые принципы работы с Роботом.
Задача 8: Нарисовать букву "Т"
Казалось бы, простая задача, но она отлично демонстрирует необходимость продумывать последовательность действий:
| Code | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| использовать Робот
алг
нач
// Рисуем горизонтальную часть буквы "Т"
закрасить
вправо
закрасить
вправо
закрасить
// Возвращаемся к середине
влево
// Рисуем вертикальную часть
вниз
закрасить
вниз
закрасить
кон |
|
Задача 9: Нарисовать квадрат 3×3
Ещё одна классическая задача для новичков:
| Code | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
| использовать Робот
алг
нач
// Верхняя сторона
закрасить
вправо
закрасить
вправо
закрасить
// Правая сторона
вниз
закрасить
вниз
закрасить
// Нижняя сторона
влево
закрасить
влево
закрасить
// Левая сторона
вверх
закрасить
вверх
кон |
|
Задача 10: Закрасить диагональ
Рисование диагонали требует чередования горизонтальных и вертикальных перемещений:
| Code | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
| использовать Робот
алг
нач
закрасить
вправо
вниз
закрасить
вправо
вниз
закрасить
вправо
вниз
закрасить
кон |
|
Задача 11: Создание флага
Немного усложним задачу — теперь Робот должен нарисовать двухцветный флаг. В КуМире нет возможности использовать разные цвета, но для обучения можно условно считать закрашенные клетки одним цветом, а незакрашенные — другим:
| Code | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
| использовать Робот
алг
нач
// Первая строка
закрасить
вправо
закрасить
вправо
закрасить
// Переходим на вторую строку
вниз
влево
влево
// Вторая строка
// Оставляем клетки незакрашенными
вправо
вправо
вправо
// Переходим на третью строку
вниз
влево
влево
влево
// Третья строка
закрасить
вправо
закрасить
вправо
закрасить
кон |
|
Задача 12: Рисуем шахматную доску 3×3
Теперь усложним задачу ещё больше — нарисуем маленькую шахматную доску без использования циклов:
| Code | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
| использовать Робот
алг
нач
// Первая строка
закрасить
вправо
вправо
закрасить
// Переходим на вторую строку
вниз
влево
влево
влево
// Вторая строка
вправо
закрасить
вправо
вправо
// Переходим на третью строку
вниз
влево
влево
влево
// Третья строка
закрасить
вправо
вправо
закрасить
кон |
|
Задача 13: Рисуем крестик
Эта задача интересна тем, что нам придётся несколько раз возвращаться в исходную точку:
| Code | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
| использовать Робот
алг
нач
// Запоминаем, что начинаем из центра
// Рисуем первый луч вправо
вправо
закрасить
// Возвращаемся в центр
влево
// Рисуем второй луч влево
влево
закрасить
// Возвращаемся в центр
вправо
// Рисуем третий луч вверх
вверх
закрасить
// Возвращаемся в центр
вниз
// Рисуем четвертый луч вниз
вниз
закрасить
// Закрашиваем центр
вверх
закрасить
кон |
|
Задача 14: Рисуем в углу поля
А вот задача, которая учит ориентироваться на поле и находить его края:
| Code | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| использовать Робот
алг
нач
// Идём в правый верхний угол
нц пока справа свободно
вправо
кц
нц пока сверху свободно
вверх
кц
// Рисуем узор в углу
закрасить
влево
закрасить
вниз
закрасить
кон |
|
Линейные алгоритмы имеют очевидные ограничения — они становятся неудобными при необходимости многократного повторения одних и тех же действий. И всё же они служат отличной основой для понимания более сложных конструкций. Когда вы освоите линейные алгоритмы, вы заметите, что многие из них содержат повторяющиеся последовательности команд. Это первый признак того, что пора переходить к циклам. Например, в задаче с шахматной доской мы могли бы использовать цикл для обработки строк, и ещё один — для обработки столбцов.
Что касается закрашивания клеток, этот механизм позволяет Роботу "оставлять след" и визуализировать выполнение программы. В образовательном плане это бесценный инструмент: ученик сразу видит результат работы своего алгоритма и может анализировать ошибки.
Начиная с линейных алгоритмов закрашивания, вы постепенно сможете перейти к более сложным задачам, таким как заливка области, распознавание фигур и даже реализация клеточных автоматов. Это отличная база для развития алгоритмического мышления в целом.
Методика составления пошаговых алгоритмов и типичные ошибки новичков
Когда я начинал работать с КуМиром, то часто впадал в ступор перед сложными задачами. Казалось, что невозможно написать алгоритм, который заставит Робота выполнить все необходимые действия. Со временем выработался определённый подход к разработке алгоритмов, которым хочу поделиться.
Первое правило успешного программирования для Робота — разбивайте задачу на максимально маленькие подзадачи. Чем меньше шаг, тем проще его реализовать. Например, если нужно закрасить периметр квадрата, разбейте задачу на четыре части: закрасить верхнюю сторону, правую, нижнюю, левую. Я рекомендую начинать с физического моделирования. Просто возьмите лист бумаги в клеточку и "проиграйте" действия Робота ручкой или карандашом. Это поможет визуализировать алгоритм и выявить возможные проблемы ещё до написания кода.
Важный этап — определение начальных условий. Где находится Робот в начале программы? Какие клетки уже закрашены? Что произойдёт, если начальное положение изменится? Ответив на эти вопросы, вы составите более универсальный алгоритм.
Теперь о методике пошагового составления алгоритма:
1. Формализуйте задачу. Запишите чётко, что должен делать Робот. Например: "Закрасить все клетки внутри замкнутой области".
2. Проанализируйте исходную обстановку. Какие клетки уже закрашены? Где расположены стены? С чего нужно начать?
3. Определите граничные условия. Когда алгоритм должен остановиться? Например: "Прекратить движение, когда справа стена".
4. Составьте псевдокод. Это промежуточный шаг между естественным языком и языком программирования. Например:
| Code | 1
2
3
| Пока не дошли до стены:
Закрасить текущую клетку
Сделать шаг вправо |
|
6. Протестируйте на простых примерах. Начните с проверки алгоритма на самом простом возможном поле.
7. Усложняйте тестовые примеры. Постепенно добавляйте сложности: стены, закрашенные клетки, другие начальные положения Робота.
При составлении алгоритмов новички часто сталкиваются с типовыми ошибками. Рассмотрим самые распространённые из них.
Ошибка №1: Игнорирование граничных условий
| Code | 1
2
3
4
5
6
7
8
| использовать Робот
алг
нач
нц 10 раз
закрасить
вправо // А что, если справа стена?
кц
кон |
|
Ошибка №2: Отсутствие проверки начальных условий
Многие новички сразу приступают к выполнению основного алгоритма, не проверив, выполнены ли необходимые предусловия. Например, если Робот должен закрасить периметр прямоугольника, начиная с левого верхнего угла, необходимо сначала убедиться, что он действительно находится в этом углу.
Ошибка №3: Бесконечные циклы
| Code | 1
2
3
4
5
6
7
8
9
10
11
| использовать Робот
алг
нач
нц пока не справа стена
вправо
если сверху свободно то
вверх
влево // Здесь мы возвращаемся назад!
все
кц
кон |
|
Ошибка №4: Неправильная обработка последней операции
| Code | 1
2
3
4
5
6
7
8
| использовать Робот
алг
нач
нц пока справа свободно
вправо
закрасить
кц
кон |
|
Ошибка №5: Путаница с условиями
Новички часто путаются между условиями "сверху свободно" и "сверху стена". Эти условия противоположны, и использование неправильного условия приведёт к противоположному результату.
Ошибка №6: Отсутствие декомпозиции
Когда алгоритм становится сложным, его нужно разбивать на подзадачи. Новички часто пытаются написать всё в одном большом куске кода, что приводит к путанице и ошибкам.
Ошибка №7: Неэффективное решение
| Code | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
| использовать Робот
алг
нач
// Закрашиваем строку длиной 5
закрасить
вправо
закрасить
вправо
закрасить
вправо
закрасить
вправо
закрасить
кон |
|
| Code | 1
2
3
4
5
6
7
8
9
10
| использовать Робот
алг
нач
нц 5 раз
закрасить
если справа свободно то
вправо
все
кц
кон |
|
В сложных алгоритмах с рекурсией или подпрограммами новички часто забывают вернуть Робота в исходное положение после выполнения определённой подзадачи.
Для успешного программирования Робота важно не только избегать ошибок, но и научиться думать алгоритмически. Вот несколько советов, которые помогут в этом:- Используйте отладку по шагам. КуМир позволяет выполнять программу пошагово, что помогает увидеть, где именно происходит ошибка.
- Тестируйте на разных примерах. Одно и то же решение может работать на одном поле и давать сбой на другом.
- Не бойтесь экспериментировать. Если решение не работает, попробуйте другой подход.
- Учитесь у других. Изучайте готовые решения и понимайте, как они работают.
Важно помнить, что составление алгоритмов — это навык, который приходит с практикой. Не стоит расстраиваться, если с первого раза не получается написать идеальный код. Главное — анализировать свои ошибки и учиться на них.
Задачи средней сложности с циклами и условиями
Теперь, когда мы разобрались с базовыми алгоритмами, самое время поднять планку и перейти к задачам посложнее. Здесь нам понадобится комбинировать циклы с условиями, что позволит создавать более интеллектуальные программы для нашего Робота.
Задача 15: Поиск ближайшей закрашенной клетки
В этой задаче Робот должен найти ближайшую закрашенную клетку, перемещаясь по спирали от начального положения:
| Code | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
| использовать Робот
алг
нач
цел шаг, направление
// Начальные настройки
шаг := 1
направление := 0 // 0 - вправо, 1 - вниз, 2 - влево, 3 - вверх
нц пока не клетка закрашена
// Двигаемся в текущем направлении на текущий шаг
нц для i от 1 до шаг
если клетка закрашена то
выход // Нашли закрашенную клетку
все
// Перемещаемся в выбранном направлении
выбор направление
при 0: если справа свободно то вправо иначе выход все
при 1: если снизу свободно то вниз иначе выход все
при 2: если слева свободно то влево иначе выход все
при 3: если сверху свободно то вверх иначе выход все
все
кц
// Меняем направление
направление := (направление + 1) mod 4
// Увеличиваем шаг после каждого второго изменения направления
если направление = 0 или направление = 2 то
шаг := шаг + 1
все
кц
вывод "Закрашенная клетка найдена!"
кон |
|
Задача 16: Подсчёт и закрашивание всех доступных клеток
Здесь мы будем подсчитывать количество клеток, до которых может добраться Робот, закрашивая все найденные клетки:
| Code | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
| использовать Робот
алг
нач
цел счетчик := 0
// Закрашиваем и считаем текущую клетку
если не клетка закрашена то
закрасить
счетчик := счетчик + 1
все
// Проверяем доступность клеток во всех четырёх направлениях
если справа свободно то
вправо
счетчик := счетчик + ОбходДоступныхКлеток()
влево
все
если снизу свободно то
вниз
счетчик := счетчик + ОбходДоступныхКлеток()
вверх
все
если слева свободно то
влево
счетчик := счетчик + ОбходДоступныхКлеток()
вправо
все
если сверху свободно то
вверх
счетчик := счетчик + ОбходДоступныхКлеток()
вниз
все
вывод "Количество доступных клеток: ", счетчик
кон
// Вспомогательная рекурсивная функция
алг цел ОбходДоступныхКлеток()
нач
цел локальный_счетчик := 0
// Закрашиваем и считаем текущую клетку, если ещё не закрашена
если не клетка закрашена то
закрасить
локальный_счетчик := локальный_счетчик + 1
иначе
// Если клетка уже закрашена, просто возвращаем 0
рез := 0
выход
все
// Рекурсивно проверяем клетки во всех направлениях
если справа свободно то
вправо
локальный_счетчик := локальный_счетчик + ОбходДоступныхКлеток()
влево
все
если снизу свободно то
вниз
локальный_счетчик := локальный_счетчик + ОбходДоступныхКлеток()
вверх
все
если слева свободно то
влево
локальный_счетчик := локальный_счетчик + ОбходДоступныхКлеток()
вправо
все
если сверху свободно то
вверх
локальный_счетчик := локальный_счетчик + ОбходДоступныхКлеток()
вниз
все
рез := локальный_счетчик
кон |
|
Задача 17: Лабиринт с обратным отслеживанием пути
В этой задаче Робот должен найти путь в лабиринте, помечая его закрашенными клетками и откатываясь назад, если зашёл в тупик:
| Code | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
| использовать Робот
алг
нач
ПоискПути()
кон
алг лог ПоискПути()
нач
// Если нашли выход (по условию - клетку, отмеченную другим цветом)
если клетка закрашена то
рез := истина
выход
все
// Отмечаем посещённую клетку
закрасить
// Пробуем двигаться в разных направлениях
если справа свободно то
вправо
если ПоискПути() то
рез := истина
выход
все
влево // Возвращаемся, если путь не найден
все
если снизу свободно то
вниз
если ПоискПути() то
рез := истина
выход
все
вверх // Возвращаемся, если путь не найден
все
если слева свободно то
влево
если ПоискПути() то
рез := истина
выход
все
вправо // Возвращаемся, если путь не найден
все
если сверху свободно то
вверх
если ПоискПути() то
рез := истина
выход
все
вниз // Возвращаемся, если путь не найден
все
// Если все направления проверены и выход не найден,
// эта клетка не ведёт к выходу, "разрисуем" её
// В реальности нам нужен был бы другой цвет, но в КуМире это сложно
// поэтому просто считаем, что "разрисованные" клетки не ведут к выходу
рез := ложь
кон |
|
Задача 18: Чётно-нечётные строки
Интересная задача на понимание цикличности - нужно закрасить все клетки в чётных строках и только чётные клетки в нечётных строках:
| Code | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
| использовать Робот
алг
нач
цел строка := 0
цел столбец := 0
// Перемещаемся в левый верхний угол
нц пока слева свободно
влево
столбец := 0 // Начинаем отсчёт столбцов заново
кц
нц пока сверху свободно
вверх
строка := 0 // Начинаем отсчёт строк заново
кц
// Теперь обрабатываем всё поле
нц пока не снизу стена
// Обрабатываем текущую строку
нц пока не справа стена
если строка mod 2 = 0 то
// Чётная строка - закрашиваем все клетки
закрасить
иначе
// Нечётная строка - закрашиваем только чётные клетки
если столбец mod 2 = 0 то
закрасить
все
все
вправо
столбец := столбец + 1
кц
// Обрабатываем последнюю клетку в строке
если строка mod 2 = 0 то
закрасить
иначе
если столбец mod 2 = 0 то
закрасить
все
все
// Переходим на следующую строку
вниз
строка := строка + 1
// Возвращаемся в начало строки
нц пока не слева стена
влево
кц
столбец := 0
кц
// Обрабатываем последнюю строку
нц пока не справа стена
если строка mod 2 = 0 то
закрасить
иначе
если столбец mod 2 = 0 то
закрасить
все
все
вправо
столбец := столбец + 1
кц
// Обрабатываем правый нижний угол
если строка mod 2 = 0 то
закрасить
иначе
если столбец mod 2 = 0 то
закрасить
все
все
кон |
|
Задача 19: Зигзагообразное движение
Робот должен двигаться зигзагами, закрашивая клетки:
| Code | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
| использовать Робот
алг
нач
лог движение_вправо := истина
нц пока не снизу стена
// Движемся по текущей строке
нц пока (движение_вправо и справа свободно) или (не движение_вправо и слева свободно)
закрасить
если движение_вправо то
вправо
иначе
влево
все
кц
// Закрашиваем последнюю клетку в строке
закрасить
// Если можем, переходим на следующую строку
если снизу свободно то
вниз
// Меняем направление движения
движение_вправо := не движение_вправо
иначе
выход // Достигли нижней границы
все
кц
// Обрабатываем последнюю строку
нц пока (движение_вправо и справа свободно) или (не движение_вправо и слева свободно)
закрасить
если движение_вправо то
вправо
иначе
влево
все
кц
// Закрашиваем последнюю клетку
закрасить
кон |
|
Задача 20: Создание рамки заданной толщины
В этой задаче Робот должен создать рамку определённой толщины вокруг заданной области:
| Code | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
| использовать Робот
алг
нач
цел толщина_рамки := 2 // Можно изменить
// Сначала определяем размеры области
цел ширина := 0
цел высота := 0
// Измеряем ширину
нц пока справа свободно
вправо
ширина := ширина + 1
кц
// Возвращаемся в начальную позицию
нц пока слева свободно
влево
кц
// Измеряем высоту
нц пока снизу свободно
вниз
высота := высота + 1
кц
// Возвращаемся в начальную позицию
нц пока сверху свободно
вверх
кц
// Теперь создаём рамку
// Проходим по каждой строке
нц для i от 0 до высота
// Проходим по каждому столбцу в текущей строке
нц для j от 0 до ширина
// Проверяем, должна ли эта клетка быть частью рамки
если i < толщина_рамки или i > высота - толщина_рамки или
j < толщина_рамки или j > ширина - толщина_рамки то
закрасить
все
// Двигаемся вправо, если можно
если j < ширина то
вправо
все
кц
// Возвращаемся к началу строки
нц пока слева свободно
влево
кц
// Переходим на следующую строку, если можно
если i < высота то
вниз
все
кц
кон |
|
Задачи среднего уровня сложности требуют от нас более глубокого понимания взаимодействия циклов и условий. Они также учат нас оптимизировать наши алгоритмы, избегая повторяющихся вычислений и неэффективных перемещений. По мере решения таких задач вы начнёте замечать, что многие алгоритмические паттерны повторяются в разных контекстах. Это признак того, что вы начинаете мыслить как настоящий программист — замечать закономерности и использовать проверенные решения для новых задач.
В следующем разделе мы рассмотрим ещё более сложные задачи, которые потребуют от нас анализа поля и распознавания геометрических фигур — что выводит программирование Робота на совершенно новый уровень.
Техника анализа поля и распознавание геометрических фигур
При решении сложных задач с Роботом часто требуется анализировать конфигурацию поля, распознавать фигуры или искать определённые паттерны. Такие навыки выходят за рамки простого программирования и приближаются к области компьютерного зрения и распознавания образов. Начнём с базовой техники анализа поля — сканирования. Классический алгоритм сканирования похож на то, как мы читаем текст: слева направо, строка за строкой:
| Code | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
| использовать Робот
алг
нач
// Перемещаемся в левый верхний угол поля
нц пока слева свободно
влево
кц
нц пока сверху свободно
вверх
кц
// Сканируем поле построчно
нц пока не снизу стена
нц пока не справа стена
// Анализируем текущую клетку
если клетка закрашена то
вывод "Найдена закрашенная клетка"
все
вправо
кц
// Анализируем последнюю клетку в строке
если клетка закрашена то
вывод "Найдена закрашенная клетка"
все
// Переходим на следующую строку
вниз
// Возвращаемся в начало строки
нц пока не слева стена
влево
кц
кц
кон |
|
Теперь рассмотрим задачу посложнее — определение периметра замкнутой фигуры. Допустим, на поле есть закрашенная область, и нам нужно подсчитать длину её периметра:
| Code | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
| использовать Робот
алг
нач
цел периметр := 0
// Ищем первую закрашенную клетку
нц пока не клетка закрашена
если справа свободно то
вправо
иначе если снизу свободно то
вниз
нц пока не слева стена
влево
кц
иначе
выход // Не нашли закрашенных клеток
все
кц
// Теперь обходим периметр, считая клетки
цел нач_X, нач_Y
нач_X := текущая_позиция_X() // Предположим, что такие функции существуют
нач_Y := текущая_позиция_Y()
цел текущ_X := нач_X
цел текущ_Y := нач_Y
цел направление := 0 // 0 - вправо, 1 - вниз, 2 - влево, 3 - вверх
повторять
// Пытаемся повернуть налево (относительно текущего направления)
цел новое_направление := (направление + 3) mod 4
лог можно_повернуть := ложь
выбор новое_направление
при 0: можно_повернуть := справа свободно и справа клетка закрашена
при 1: можно_повернуть := снизу свободно и снизу клетка закрашена
при 2: можно_повернуть := слева свободно и слева клетка закрашена
при 3: можно_повернуть := сверху свободно и сверху клетка закрашена
все
если можно_повернуть то
направление := новое_направление
иначе
// Пытаемся двигаться прямо
лог можно_прямо := ложь
выбор направление
при 0: можно_прямо := справа свободно и справа клетка закрашена
при 1: можно_прямо := снизу свободно и снизу клетка закрашена
при 2: можно_прямо := слева свободно и слева клетка закрашена
при 3: можно_прямо := сверху свободно и сверху клетка закрашена
все
если не можно_прямо то
// Поворачиваем направо
направление := (направление + 1) mod 4
все
все
// Двигаемся в выбранном направлении
выбор направление
при 0: вправо; текущ_X := текущ_X + 1
при 1: вниз; текущ_Y := текущ_Y + 1
при 2: влево; текущ_X := текущ_X - 1
при 3: вверх; текущ_Y := текущ_Y - 1
все
периметр := периметр + 1
пока не (текущ_X = нач_X и текущ_Y = нач_Y)
вывод "Периметр фигуры: ", периметр
кон |
|
А как насчёт распознавания конкретных геометрических фигур? Например, определения, является ли закрашенная область квадратом:
| Code | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
| использовать Робот
алг лог ЭтоКвадрат()
нач
// Предполагаем, что Робот находится в левом верхнем углу закрашенной области
// Измеряем длину верхней стороны
цел ширина := 0
нц пока справа свободно и справа клетка закрашена
вправо
ширина := ширина + 1
кц
// Измеряем правую сторону
цел высота := 0
нц пока снизу свободно и снизу клетка закрашена
вниз
высота := высота + 1
кц
// Измеряем нижнюю сторону в обратном направлении
цел нижняя_ширина := 0
нц пока слева свободно и слева клетка закрашена
влево
нижняя_ширина := нижняя_ширина + 1
кц
// Измеряем левую сторону в обратном направлении
цел левая_высота := 0
нц пока сверху свободно и сверху клетка закрашена
вверх
левая_высота := левая_высота + 1
кц
// Для квадрата все стороны должны быть равны
рез := (ширина = высота) и (ширина = нижняя_ширина) и (ширина = левая_высота)
кон |
|
Иногда требуется не просто распознать фигуру, но и выполнить с ней определённые операции. Например, заполнить внутреннюю часть прямоугольника:
| Code | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
| использовать Робот
алг
нач
// Находим левый верхний угол прямоугольника
нц пока не клетка закрашена
если справа свободно то
вправо
иначе если снизу свободно то
вниз
нц пока не слева стена
влево
кц
иначе
выход // Не нашли закрашенных клеток
все
кц
// Измеряем ширину прямоугольника
цел ширина := 1
нц пока справа свободно и справа клетка закрашена
вправо
ширина := ширина + 1
кц
// Возвращаемся в левый верхний угол
нц для i от 1 до ширина - 1
влево
кц
// Заполняем прямоугольник по строкам
нц пока снизу свободно и снизу клетка закрашена
вниз
// Заполняем текущую строку
нц для i от 0 до ширина - 1
закрасить
если i < ширина - 1 то
вправо
все
кц
// Возвращаемся в начало строки
нц для i от 0 до ширина - 2
влево
кц
кц
кон |
|
| Code | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
| использовать Робот
алг Заливка()
нач
если не клетка закрашена то
закрасить
// Рекурсивно заливаем соседние клетки
если справа свободно то
вправо
Заливка()
влево
все
если снизу свободно то
вниз
Заливка()
вверх
все
если слева свободно то
влево
Заливка()
вправо
все
если сверху свободно то
вверх
Заливка()
вниз
все
все
кон |
|
Все эти техники анализа поля и распознавания фигур имеют широкое применение не только в учебном программировании с Роботом, но и в реальных задачах компьютерного зрения, обработки изображений и даже в робототехнике.
Когда я работал над проектами с распознаванием объектов на изображениях, меня удивило, насколько базовые принципы, изученные на примере Робота в КуМире, перекликаются с продвинутыми алгоритмами в этой области. Конечно, в реальности используются более сложные математические модели, но концептуальная основа очень похожа. Самое важное в анализе поля — выбрать правильную стратегию сканирования, которая позволит эффективно найти искомые объекты или паттерны. Иногда оптимально использовать систематический обход всего поля, в других случаях лучше работают "жадные" алгоритмы, которые сразу движутся к потенциально интересным областям.
Продвинутые задачи с комбинированием циклов и условий
Переходим к ещё более сложному уровню задач для нашего Робота. Если вы уже освоились с базовыми циклами и условиями, самое время попробовать задачи, где эти конструкции переплетаются в сложные алгоритмические структуры. Комбинирование циклов и условий открывает двери к решению по-настоящему интересных головоломок.
Задача 21: Поиск кратчайшего пути в лабиринте
Эта задача требует применения алгоритма поиска в ширину (BFS), который находит кратчайший путь между двумя точками:
| Code | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
| использовать Робот
алг
нач
// Создаём структуры для хранения очереди точек
цел N := 100 // Максимальное количество точек в очереди
цел queue_x[N] // Координаты X точек в очереди
цел queue_y[N] // Координаты Y точек в очереди
цел front := 0, rear := 0 // Указатели на начало и конец очереди
// Массивы для хранения расстояний и предыдущих точек
цел dist[100][100] // Расстояния от начальной точки
цел prev_x[100][100], prev_y[100][100] // Координаты предыдущей точки
// Инициализация массива расстояний
нц для i от 0 до 99
нц для j от 0 до 99
dist[i][j] := 1000000 // "Бесконечность"
кц
кц
// Получаем текущие координаты Робота
цел start_x := текущая_позиция_x()
цел start_y := текущая_позиция_y()
// Начальная точка
dist[start_x][start_y] := 0
queue_x[rear] := start_x
queue_y[rear] := start_y
rear := (rear + 1) mod N
// Найдём целевую точку (закрашенную клетку)
цел target_x := -1, target_y := -1
// BFS
нц пока front != rear
цел x := queue_x[front]
цел y := queue_y[front]
front := (front + 1) mod N
// Проверяем соседние клетки
нц для dx от -1 до 1
нц для dy от -1 до 1
если (dx = 0 и dy = 0) или (dx != 0 и dy != 0) то
продолжай // Пропускаем текущую клетку и диагонали
все
цел nx := x + dx
цел ny := y + dy
// Проверяем, что соседняя клетка доступна
если nx >= 0 и nx < 100 и ny >= 0 и ny < 100 то
// Перемещаем Робота в точку (x, y)
переместиться_в(x, y)
// Проверяем, доступна ли соседняя клетка
лог доступна := ложь
если dx = 1 и справа свободно то доступна := истина
иначе если dx = -1 и слева свободно то доступна := истина
иначе если dy = 1 и снизу свободно то доступна := истина
иначе если dy = -1 и сверху свободно то доступна := истина
все
если доступна и dist[nx][ny] = 1000000 то
dist[nx][ny] := dist[x][y] + 1
prev_x[nx][ny] := x
prev_y[nx][ny] := y
queue_x[rear] := nx
queue_y[rear] := ny
rear := (rear + 1) mod N
// Перемещаем Робота в точку (nx, ny)
переместиться_в(nx, ny)
// Проверяем, не нашли ли мы цель
если клетка закрашена то
target_x := nx
target_y := ny
front := rear // Выходим из цикла
все
все
все
кц
кц
кц
// Восстанавливаем путь от target до start
если target_x != -1 то
цел cur_x := target_x
цел cur_y := target_y
нц пока cur_x != start_x или cur_y != start_y
цел px := prev_x[cur_x][cur_y]
цел py := prev_y[cur_x][cur_y]
// Перемещаем Робота в точку (px, py) и закрашиваем путь
переместиться_в(px, py)
закрасить
cur_x := px
cur_y := py
кц
все
кон |
|
Задача 22: Распознавание и анализ замкнутых областей
В этой задаче Робот должен распознать все замкнутые области на поле и проанализировать их размеры:
| Code | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
| использовать Робот
алг
нач
// Создаём матрицу для хранения меток областей
цел метки[100][100] // Предполагаем, что поле не больше 100x100
цел текущая_метка := 1
// Инициализируем матрицу
нц для i от 0 до 99
нц для j от 0 до 99
метки[i][j] := 0
кц
кц
// Перемещаемся в левый верхний угол
нц пока слева свободно
влево
кц
нц пока сверху свободно
вверх
кц
// Сканируем поле построчно
цел y := 0
нц пока не снизу стена
цел x := 0
нц пока не справа стена
если не клетка закрашена и метки[x][y] = 0 то
// Нашли незакрашенную и неотмеченную клетку
// Заполняем область и помечаем её номером
ЗаполнитьОбласть(x, y, текущая_метка, метки)
текущая_метка := текущая_метка + 1
все
вправо
x := x + 1
кц
// Проверяем последнюю клетку в строке
если не клетка закрашена и метки[x][y] = 0 то
ЗаполнитьОбласть(x, y, текущая_метка, метки)
текущая_метка := текущая_метка + 1
все
// Переходим на следующую строку
вниз
y := y + 1
// Возвращаемся в начало строки
нц пока не слева стена
влево
кц
кц
// Анализируем размеры каждой области
цел размеры[текущая_метка]
нц для i от 1 до текущая_метка - 1
размеры[i] := 0
кц
// Снова сканируем поле для подсчёта размеров
y := 0
нц пока не снизу стена
x := 0
нц пока не справа стена
если метки[x][y] > 0 то
размеры[метки[x][y]] := размеры[метки[x][y]] + 1
все
вправо
x := x + 1
кц
// Проверяем последнюю клетку
если метки[x][y] > 0 то
размеры[метки[x][y]] := размеры[метки[x][y]] + 1
все
вниз
y := y + 1
нц пока не слева стена
влево
кц
кц
// Выводим результаты
вывод "Найдено ", текущая_метка - 1, " областей"
нц для i от 1 до текущая_метка - 1
вывод "Область ", i, " - размер: ", размеры[i]
кц
кон
// Вспомогательная функция для заполнения области методом рекурсивной заливки
алг ЗаполнитьОбласть(x, y, метка, метки: массив цел)
нач
// Проверяем границы
если x < 0 или x >= 100 или y < 0 или y >= 100 то
выход
все
// Перемещаем Робота в точку (x, y)
переместиться_в(x, y)
// Если клетка уже помечена или закрашена, выходим
если метки[x][y] > 0 или клетка закрашена то
выход
все
// Помечаем клетку
метки[x][y] := метка
// Рекурсивно заполняем соседние клетки
если справа свободно то ЗаполнитьОбласть(x + 1, y, метка, метки) все
если снизу свободно то ЗаполнитьОбласть(x, y + 1, метка, метки) все
если слева свободно то ЗаполнитьОбласть(x - 1, y, метка, метки) все
если сверху свободно то ЗаполнитьОбласть(x, y - 1, метка, метки) все
кон |
|
Задача 23: Алгоритм заполнения лабиринта
Здесь Робот должен закрасить всё доступное пространство, последовательно расширяя закрашенную область:
| Code | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
| использовать Робот
алг
нач
// Закрашиваем начальную клетку
закрасить
лог изменения := истина
// Продолжаем, пока есть изменения
нц пока изменения
изменения := ложь
// Ищем границу между закрашенными и незакрашенными клетками
// Для этого сканируем всё поле
цел y := 0
нц пока не снизу стена
цел x := 0
нц пока не справа стена
// Если клетка закрашена, проверяем её соседей
если клетка закрашена то
// Проверяем соседей во всех направлениях
если справа свободно то
вправо
если не клетка закрашена то
закрасить
изменения := истина
все
влево
все
если снизу свободно то
вниз
если не клетка закрашена то
закрасить
изменения := истина
все
вверх
все
если слева свободно то
влево
если не клетка закрашена то
закрасить
изменения := истина
все
вправо
все
если сверху свободно то
вверх
если не клетка закрашена то
закрасить
изменения := истина
все
вниз
все
все
вправо
x := x + 1
кц
вниз
y := y + 1
нц пока не слева стена
влево
кц
кц
// Возвращаемся в начальное положение
нц пока сверху свободно
вверх
кц
кц
кон |
|
Задача 24: Детекция формы и симметрии
В этой задаче Робот должен определить, является ли закрашенная фигура симметричной:
| Code | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
| использовать Робот
алг
нач
// Находим прямоугольник, охватывающий фигуру
цел min_x := 1000, max_x := -1
цел min_y := 1000, max_y := -1
// Сканируем поле для нахождения границ
цел y := 0
нц пока не снизу стена
цел x := 0
нц пока не справа стена
если клетка закрашена то
если x < min_x то min_x := x все
если x > max_x то max_x := x все
если y < min_y то min_y := y все
если y > max_y то max_y := y все
все
вправо
x := x + 1
кц
// Проверяем последнюю клетку в строке
если клетка закрашена то
если x < min_x то min_x := x все
если x > max_x то max_x := x все
если y < min_y то min_y := y все
если y > max_y то max_y := y все
все
вниз
y := y + 1
нц пока не слева стена
влево
кц
кц
// Проверяем горизонтальную симметрию
лог горизонтальная_симметрия := истина
цел центр_y := (min_y + max_y) / 2
y := min_y
нц пока y <= max_y
x := min_x
нц пока x <= max_x
// Находим симметричную точку
цел sym_y := 2 * центр_y - y
// Проверяем, что симметричная точка находится в границах
если sym_y >= min_y и sym_y <= max_y то
// Перемещаем Робота в точку (x, y)
переместиться_в(x, y)
лог текущая := клетка закрашена
// Перемещаем Робота в симметричную точку
переместиться_в(x, sym_y)
лог симметричная := клетка закрашена
если текущая != симметричная то
горизонтальная_симметрия := ложь
выход
все
все
x := x + 1
кц
если не горизонтальная_симметрия то
выход
все
y := y + 1
кц
// Проверяем вертикальную симметрию
лог вертикальная_симметрия := истина
цел центр_x := (min_x + max_x) / 2
y := min_y
нц пока y <= max_y
x := min_x
нц пока x <= max_x
// Находим симметричную точку
цел sym_x := 2 * центр_x - x
// Проверяем, что симметричная точка находится в границах
если sym_x >= min_x и sym_x <= max_x то
// Перемещаем Робота в точку (x, y)
переместиться_в(x, y)
лог текущая := клетка закрашена
// Перемещаем Робота в симметричную точку
переместиться_в(sym_x, y)
лог симметричная := клетка закрашена
если текущая != симметричная то
вертикальная_симметрия := ложь
выход
все
все
x := x + 1
кц
если не вертикальная_симметрия то
выход
все
y := y + 1
кц
// Выводим результаты
если горизонтальная_симметрия то
вывод "Фигура симметрична относительно горизонтальной оси"
иначе
вывод "Фигура не симметрична относительно горизонтальной оси"
все
если вертикальная_симметрия то
вывод "Фигура симметрична относительно вертикальной оси"
иначе
вывод "Фигура не симметрична относительно вертикальной оси"
все
если горизонтальная_симметрия и вертикальная_симметрия то
вывод "Фигура обладает центральной симметрией"
все
кон |
|
Задача 25: Обход поля по спирали с закрашиванием каждой n-й клетки
В этой задаче Робот должен обойти поле по спирали, закрашивая каждую n-ю клетку:
| Code | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
| использовать Робот
алг
нач
цел n := 3 // Каждая третья клетка будет закрашена
цел шагов := 1
цел направление := 0 // 0 - вправо, 1 - вниз, 2 - влево, 3 - вверх
цел счетчик := 1
// Закрашиваем первую клетку, если n = 1
если счетчик mod n = 0 то
закрасить
все
нц
// Выполняем шаги в текущем направлении
нц для i от 1 до шагов
// Перемещаемся в выбранном направлении
выбор направление
при 0: если справа стена то выход все; вправо
при 1: если снизу стена то выход все; вниз
при 2: если слева стена то выход все; влево
при 3: если сверху стена то выход все; вверх
все
счетчик := счетчик + 1
// Закрашиваем каждую n-ю клетку
если счетчик mod n = 0 то
закрасить
все
кц
// Меняем направление
направление := (направление + 1) mod 4
// Увеличиваем количество шагов после каждого второго поворота
если направление = 0 или направление = 2 то
шагов := шагов + 1
все
кц
кон |
|
Задача 26: Создание узора "шахматная доска" с чередованием размеров клеток
В этой задаче Робот должен создать узор типа "шахматная доска", но с чередующимися размерами клеток (1x1, 2x2, 3x3):
| Code | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
| использовать Робот
алг
нач
// Перемещаемся в левый верхний угол
нц пока слева свободно
влево
кц
нц пока сверху свободно
вверх
кц
цел размер_блока := 1 // Начинаем с блока 1x1
цел max_размер := 3 // Максимальный размер блока
цел y := 0
нц пока не снизу стена
цел x := 0
лог текущий_цвет := ((y / размер_блока) mod 2 = 0)
нц пока не справа стена
// Определяем, нужно ли закрашивать текущий блок
лог закрашивать := ((x / размер_блока) mod 2 = 0) xor не текущий_цвет
если закрашивать то
закрасить
все
вправо
x := x + 1
// Проверяем, не пора ли изменить размер блока
если x mod (max_размер * 2) = 0 то
размер_блока := (размер_блока mod max_размер) + 1
все
кц
// Проверяем последнюю клетку в строке
лог закрашивать := ((x / размер_блока) mod 2 = 0) xor не текущий_цвет
если закрашивать то
закрасить
все
вниз
y := y + 1
// Возвращаемся в начало строки
нц пока не слева стена
влево
кц
// Проверяем, не пора ли изменить размер блока по вертикали
если y mod (max_размер * 2) = 0 то
размер_блока := (размер_блока mod max_размер) + 1
все
кц
кон |
|
Оптимизация решений и рекурсивные алгоритмы в сложных лабиринтах
Решение лабиринтов — классическая задача в программировании. С неё начинали многие разработчики систем искусственного интеллекта, и для робота в КуМире она представляет идеальную площадку для демонстрации продвинутых техник. Давайте разберём, как можно оптимизировать наши решения и применить рекурсию для прохождения сложных лабиринтов.
Когда мы говорим об оптимизации решений, речь идёт о двух аспектах: экономии вычислительных ресурсов и поиске кратчайшего пути. В контексте Робота в КуМире нас обычно больше интересует второй аспект.
Задача 27: Поиск выхода из лабиринта с помощью рекурсии
Начнём с рекурсивного алгоритма для поиска выхода из лабиринта:
| Code | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
| использовать Робот
алг лог НайтиВыход()
нач
// Если нашли выход (закрашенную клетку)
если клетка закрашена то
рез := истина
выход
все
// Отмечаем текущую клетку как посещённую
закрасить
// Проверяем все возможные направления
если справа свободно то
вправо
если НайтиВыход() то
рез := истина
выход
все
влево // Возвращаемся назад
все
если снизу свободно то
вниз
если НайтиВыход() то
рез := истина
выход
все
вверх // Возвращаемся назад
все
если слева свободно то
влево
если НайтиВыход() то
рез := истина
выход
все
вправо // Возвращаемся назад
все
если сверху свободно то
вверх
если НайтиВыход() то
рез := истина
выход
все
вниз // Возвращаемся назад
все
// Если выход не найден ни в одном из направлений,
// разрисуем клетку (это тупик)
рез := ложь
кон |
|
| Code | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
| использовать Робот
алг лог НайтиВыход()
нач
// Если нашли выход (клетку определённого цвета)
если клетка закрашена то
рез := истина
выход
все
// Отмечаем текущую клетку временной меткой
закрасить // В реальности нужен был бы другой цвет
// Проверяем все возможные направления
если справа свободно то
вправо
// Проверка, не была ли уже посещена эта клетка
если не клетка закрашена то
если НайтиВыход() то
рез := истина
выход
все
все
влево // Возвращаемся назад
все
// Аналогично для других направлений...
// Если выход не найден, помечаем клетку как тупиковую
рез := ложь
кон |
|
Задача 28: Поиск кратчайшего пути с помощью алгоритма Ли (волнового алгоритма)
Для нахождения кратчайшего пути лучше использовать волновой алгоритм (алгоритм Ли):
| Code | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
| использовать Робот
алг
нач
// Инициализируем двумерный массив для хранения расстояний
цел расстояния[100][100] // Предположим максимальный размер поля
цел макс_расст := 10000 // Условная "бесконечность"
цел i, j
нц для i от 0 до 99
нц для j от 0 до 99
расстояния[i][j] := макс_расст
кц
кц
// Получаем текущие координаты
цел нач_x := ПолучитьТекущийX()
цел нач_y := ПолучитьТекущийY()
расстояния[нач_x][нач_y] := 0
// Создаём очередь для волнового алгоритма
цел очередь_x[10000], очередь_y[10000]
цел начало := 0, конец := 0
// Добавляем начальную точку в очередь
очередь_x[конец] := нач_x
очередь_y[конец] := нач_y
конец := конец + 1
// Запускаем волновой алгоритм
нц пока начало < конец
цел тек_x := очередь_x[начало]
цел тек_y := очередь_y[начало]
начало := начало + 1
// Проверяем все четыре направления
ПроверитьНаправление(тек_x + 1, тек_y, тек_x, тек_y, расстояния, очередь_x, очередь_y, конец)
ПроверитьНаправление(тек_x, тек_y + 1, тек_x, тек_y, расстояния, очередь_x, очередь_y, конец)
ПроверитьНаправление(тек_x - 1, тек_y, тек_x, тек_y, расстояния, очередь_x, очередь_y, конец)
ПроверитьНаправление(тек_x, тек_y - 1, тек_x, тек_y, расстояния, очередь_x, очередь_y, конец)
кц
// Находим выход (закрашенную клетку)
цел выход_x := -1, выход_y := -1
лог найден_выход := ложь
// В реальности нужен был бы скан всего поля для поиска выхода
если найден_выход то
// Восстанавливаем кратчайший путь от выхода к началу
цел путь_x[10000], путь_y[10000]
цел длина_пути := 0
тек_x := выход_x
тек_y := выход_y
нц пока не (тек_x = нач_x и тек_y = нач_y)
путь_x[длина_пути] := тек_x
путь_y[длина_пути] := тек_y
длина_пути := длина_пути + 1
// Ищем соседа с меньшим расстоянием
если расстояния[тек_x + 1][тек_y] = расстояния[тек_x][тек_y] - 1 то
тек_x := тек_x + 1
иначе если расстояния[тек_x][тек_y + 1] = расстояния[тек_x][тек_y] - 1 то
тек_y := тек_y + 1
иначе если расстояния[тек_x - 1][тек_y] = расстояния[тек_x][тек_y] - 1 то
тек_x := тек_x - 1
иначе
тек_y := тек_y - 1
все
кц
// Идём по восстановленному пути в обратном порядке
нц для i от длина_пути - 1 до 0 шаг -1
// В реальности здесь был бы код для физического перемещения робота
кц
все
кон
алг ПроверитьНаправление(цел новый_x, цел новый_y, цел от_x, цел от_y, расстояния: массив цел, очередь_x: массив цел, очередь_y: массив цел, знач конец: цел)
нач
// Проверка границ
если новый_x < 0 или новый_y < 0 или новый_x >= 100 или новый_y >= 100 то
выход
все
// Перемещаем Робота на текущую позицию и проверяем возможность движения
// В реальности это сложнее, так как нужно перемещать робота физически
если расстояния[новый_x][новый_y] = макс_расст то
расстояния[новый_x][новый_y] := расстояния[от_x][от_y] + 1
очередь_x[конец] := новый_x
очередь_y[конец] := новый_y
конец := конец + 1
все
кон |
|
Волновой алгоритм гарантирует нахождение кратчайшего пути, но требует много памяти для хранения расстояний до каждой клетки. В реальных приложениях, когда памяти недостаточно, часто используют алгоритм A* (А-звёздочка), который комбинирует волновой алгоритм с эвристикой.
Задача 29: Применение рекурсивных алгоритмов для исследования лабиринта
Еще одна интересная задача — полное исследование лабиринта. Робот должен посетить каждую доступную клетку:
| Code | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
| использовать Робот
алг ИсследоватьЛабиринт()
нач
// Отмечаем текущую клетку как посещённую
закрасить
// Исследуем все возможные направления
если справа свободно то
вправо
если не клетка закрашена то
ИсследоватьЛабиринт()
все
влево // Возвращаемся назад
все
если снизу свободно то
вниз
если не клетка закрашена то
ИсследоватьЛабиринт()
все
вверх // Возвращаемся назад
все
если слева свободно то
влево
если не клетка закрашена то
ИсследоватьЛабиринт()
все
вправо // Возвращаемся назад
все
если сверху свободно то
вверх
если не клетка закрашена то
ИсследоватьЛабиринт()
все
вниз // Возвращаемся назад
все
кон |
|
Один из способов оптимизации — мемоизация (запоминание результатов промежуточных вычислений). Хотя для Робота это не так актуально, как для классических задач динамического программирования, иногда мы можем использовать эту технику для ускорения вычислений.
Работая со сложными лабиринтами, я выработал несколько практических рекомендаций:
1. Всегда разделяйте логику распознавания конфигурации поля и принятия решений. Сначала создайте "карту" лабиринта, затем планируйте маршрут.
2. Для очень больших лабиринтов используйте итеративные алгоритмы вместо рекурсивных, чтобы избежать переполнения стека.
3. При необходимости выбора между несколькими путями одинаковой длины, используйте дополнительные критерии оптимизации, например, предпочтение движения в определённом направлении.
4. Для особо сложных лабиринтов с множеством тупиков эффективен алгоритм Трэ́мо, который модифицирует лабиринт, удаляя тупиковые пути.
Эти техники выходят далеко за рамки школьного программирования, но именно поэтому они так интересны для изучения. Работа с рекурсивными алгоритмами в контексте Робота КуМир — отличный способ развить алгоритмическое мышление и подготовиться к решению более сложных задач в "настоящем" программировании. В моей практике я часто замечаю, что студенты, которые хорошо освоили рекурсивные алгоритмы для Робота, гораздо легче справляются с концепциями функционального программирования и структурами данных вроде графов и деревьев, когда переходят к изучению "взрослых" языков программирования.
Подводные камни и лайфхаки при программировании Робота
Несмотря на кажущуюся простоту, программирование Робота в КуМире таит в себе множество нюансов и неочевидных моментов, которые могут как усложнить жизнь начинающему программисту, так и открыть новые возможности для опытного. За годы работы с этим исполнителем я накопил целую коллекцию "подводных камней" и полезных приёмов, которыми хочу поделиться.
Неочевидные ограничения Робота
Первое, с чем сталкиваются многие новички — это ограничение на количество шагов в программе. В КуМире существует лимит на число команд, которые может выполнить Робот. Если ваша программа слишком длинная или зацикливается, исполнитель может "устать" и завершить работу аварийно. Особенно часто это происходит с рекурсивными алгоритмами в сложных лабиринтах. Встретившись с этой проблемой впервые, я долго не мог понять, в чём дело — код выглядел правильным, но почему-то не работал на больших полях. Решение оказалось в оптимизации: вместо полного перебора стоило применить более эффективный алгоритм.
Ещё одно коварное ограничение — отсутствие прямого доступа к координатам. В "чистом" КуМире нет функций, возвращающих текущие координаты Робота. Это существенно усложняет написание алгоритмов, требующих запоминания и анализа пути.
Можно, конечно, пытаться эмулировать систему координат самостоятельно:
| Code | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| использовать Робот
алг
нач
цел x := 0, y := 0 // Начальные относительные координаты
// При движении обновляем координаты
если справа свободно то
вправо
x := x + 1
все
если снизу свободно то
вниз
y := y + 1
все
// Теперь мы "знаем" координаты Робота
вывод "Текущие координаты: (", x, ", ", y, ")"
кон |
|
Ограничение на работу с массивами тоже может стать неприятным сюрпризом. В КуМире есть массивы, но их использование не всегда удобно, особенно для двумерных структур, которые идеально подходили бы для представления поля Робота.
Хитрые приемы и лайфхаки
Несмотря на ограничения, существует множество приёмов, которые могут облегчить программирование Робота. Один из моих любимых — использование самого поля как хранилища информации.
Вместо того чтобы пытаться запоминать пройденный путь в переменных, можно маркировать посещённые клетки закрашиванием. В сложных алгоритмах, где нужно различать разные состояния клеток, бывает полезно условиться, что, например, клетка закрашена = посещена, а клетка не закрашена = не посещена.
| Code | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| использовать Робот
алг
нач
// Маркируем текущую клетку как посещённую
закрасить
// Перемещаемся в соседнюю клетку...
вправо
// И проверяем, не были ли мы там уже
если клетка закрашена то
вывод "Мы уже здесь были!"
иначе
вывод "Новая территория!"
все
кон |
|
Ещё один трюк, который выручал меня не раз — предварительное сканирование поля. Прежде чем решать основную задачу, Робот обходит всё доступное пространство, составляя "карту" в виде закрашенных клеток или значений в массиве. Затем эта информация используется для принятия оптимальных решений.
Использование координатной привязки — приём, позволяющий обойти отсутствие прямого доступа к координатам. В начале программы перемещаем Робота в определённую точку (например, левый верхний угол), и отсчитываем все перемещения оттуда.
| Code | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
| использовать Робот
алг
нач
// Перемещаемся в левый верхний угол
нц пока слева свободно
влево
кц
нц пока сверху свободно
вверх
кц
// Теперь мы точно знаем, где находимся - в точке (0,0)
// И можем относительно неё вычислять другие позиции
кон |
|
Типичные ошибки и как их избежать
Самая распространенная ошибка — неучёт граничных условий. Забыв проверить наличие стены перед перемещением, вы гарантированно получите аварийное завершение программы. Я выработал привычку всегда оборачивать перемещения в условный блок:
| Code | 1
2
3
| если справа свободно то
вправо
все |
|
Неправильная интерпретация условий. Новички часто путают условия "справа свободно" и "справа стена". Они противоположны! Если справа свободно — истина, то справа стена — ложь, и наоборот.
Избыточная сложность решения. Нередко я вижу, как начинающие программисты пытаются решить простую задачу сложными методами. Например, для перемещения Робота в правый нижний угол поля достаточно двух вложенных циклов:
| Code | 1
2
3
4
5
6
| нц пока справа свободно
вправо
кц
нц пока снизу свободно
вниз
кц |
|
Секретные возможности КуМира
Некоторые возможности КуМира не очевидны на первый взгляд, но могут сильно упростить жизнь.
Создание собственных подпрограмм — это, пожалуй, самый недооценённый инструмент. Выделив повторяющиеся участки кода в отдельные алгоритмы, вы сделаете программу более понятной и легкой в отладке.
| Code | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
| использовать Робот
алг ЗакраситьКвадрат(сторона: цел)
нач
нц сторона раз
нц сторона раз
закрасить
если справа свободно то вправо все
кц
если снизу свободно то вниз все
нц сторона раз
если слева свободно то влево все
кц
кц
кон
алг
нач
ЗакраситьКвадрат(3) // Закрашиваем квадрат 3x3
вправо
вправо
вправо
вправо
ЗакраситьКвадрат(2) // Закрашиваем квадрат 2x2
кон |
|
| Code | 1
2
3
4
5
6
7
8
9
10
11
12
| использовать Робот
алг
нач
цел направление := 0 // 0 - вправо, 1 - вниз, 2 - влево, 3 - вверх
выбор направление
при 0: если справа свободно то вправо все
при 1: если снизу свободно то вниз все
при 2: если слева свободно то влево все
при 3: если сверху свободно то вверх все
все
кон |
|
| Code | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| использовать Робот
алг лог ВПределахПоля(dx: цел, dy: цел)
нач
// Предполагаем, что у нас есть глобальные переменные x и y
рез := x + dx >= 0 и x + dx < ширина_поля и y + dy >= 0 и y + dy < высота_поля
кон
алг
нач
если ВПределахПоля(1, 1) и справа свободно и снизу свободно то
// Можно безопасно двигаться по диагонали
вправо
вниз
все
кон |
|
Особенности отладки программ для Робота
В отладке программ для Робота есть свои хитрости. Пошаговое выполнение — отличный инструмент, но для сложных алгоритмов может быть утомительным. Я рекомендую использовать "контрольные точки" — моменты, когда программа выводит текущее состояние важных переменных:
| Code | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
| использовать Робот
алг
нач
цел шагов := 0
нц пока справа свободно
вправо
шагов := шагов + 1
если шагов mod 10 = 0 то // Каждые 10 шагов
вывод "Пройдено шагов: ", шагов
все
кц
кон |
|
Наконец, всегда тестируйте алгоритмы на крайних случаях: пустом поле, поле из одной клетки, поле только со стенами и т.д. Часто ошибки проявляются именно в таких ситуациях.
Практическое применение навыков программирования Робота
Программирование Робота в КуМире — это не только увлекательное учебное занятие, но и мощный трамплин для развития реальных навыков, которые пригодятся в будущей карьере. Я часто наблюдаю, как ученики, освоившие программирование через этого простого исполнителя, удивительно быстро осваивают сложные языки и технологии.
Во-первых, работа с Роботом формирует алгоритмическое мышление — способность разбивать сложную задачу на простые шаги и выстраивать их в логическую последовательность. Этот навык применим буквально везде: от программирования микроконтроллеров до анализа больших данных.
Помню один случай из практики: студент, который блестяще справлялся с лабиринтами в КуМире, стал одним из лучших разработчиков алгоритмов маршрутизации в транспортной компании. Он признался, что принципы поиска кратчайшего пути, освоенные им на задачах с Роботом, легли в основу его профессиональных решений.
Моделирование пространств и работа с ограничениями, которые мы практикуем в задачах для Робота, имеют прямые аналогии в реальном мире автономных систем. Современные роботы-пылесосы, автоматизированные склады, беспилотные автомобили — все они используют алгоритмы навигации и планирования маршрутов, похожие на те, что мы создавали для нашего виртуального друга.
Интересно, что задачи на заливку областей имеют практическое применение в компьютерной графике. Сканирование и закрашивание связных областей — это базовая операция во многих графических редакторах. А алгоритмы распознавания геометрических фигур находят применение в системах компьютерного зрения.
Рекурсивные алгоритмы, которые мы использовали для исследования лабиринтов, напрямую связаны с обходом графов и деревьев — фундаментальными структурами данных в информатике. Студенты, которые понимают принцип рекурсии на примере Робота, гораздо легче осваивают такие темы, как древовидные структуры данных, поисковые алгоритмы и даже функциональное программирование.
Дисциплина проверки граничных условий, которую вырабатывают задачи с Роботом, бесценна для написания надежного программного кода в любой сфере. Привычка думать "А что, если здесь стена?" трансформируется в профессиональное "А что, если пользователь введет некорректные данные?" или "А что, если сеть разорвется в середине операции?".
Наконец, навыки отладки и тестирования, полученные при программировании Робота, применимы к любому языку и платформе. Умение локализовать ошибку, изолировать проблему и методично её исправлять — это то, что отличает профессионального программиста от дилетанта.
Некоторые школьники и студенты применяют навыки, полученные при программировании виртуального Робота, в робототехнических соревнованиях. Например, популярные конкурсы, где роботы должны пройти лабиринт или следовать по линии, идеально подходят для применения алгоритмов, отработанных в КуМире.
Я всегда привожу в пример историю одного из своих учеников, который после освоения КуМира заинтересовался конструктором LEGO Mindstorms. Он реализовал алгоритм правой руки для прохождения лабиринта на реальном роботе, практически без изменений перенеся логику из программы для виртуального Робота. Его проект занял первое место на городской олимпиаде по робототехнике.
Многие специалисты по образовательной робототехнике рекомендуют начинать именно с виртуальных исполнителей вроде Робота в КуМире, прежде чем переходить к программированию физических устройств. Это позволяет сосредоточиться на алгоритмической составляющей, не отвлекаясь на проблемы с механикой, электроникой и калибровкой датчиков.
Если говорить о конкретных профессиональных областях, где пригодятся навыки, полученные при программировании Робота, то можно выделить несколько:
1. Разработка навигационных систем — от GPS-навигаторов до систем управления промышленными роботами.
2. Компьютерное зрение и обработка изображений — алгоритмы распознавания образов имеют много общего с тем, как Робот анализирует конфигурацию поля.
3. Разработка компьютерных игр — многие игровые механики, особенно в стратегиях и головоломках, основаны на тех же принципах, что и задачи для Робота.
4. Системное администрирование — навыки отладки и анализа проблем необходимы при управлении сложными компьютерными сетями и системами.
5. Искусственный интеллект — базовые алгоритмы поиска и планирования, которые мы использовали для Робота, являются фундаментом для более сложных систем ИИ.
Программирование Робота в КуМире — это не просто учебное упражнение. Это первый шаг в мир алгоритмов и структур данных, логического мышления и творческого решения проблем. И хотя команды, которые понимает наш виртуальный друг, просты, задачи, которые можно решить с их помощью, могут быть удивительно сложными и интересными.
Я уверен, что время, потраченное на освоение этого простого исполнителя, никогда не будет потрачено зря. Ведь главная цель не в том, чтобы научиться программировать именно Робота, а в том, чтобы научиться мыслить как программист. А это навык, который будет полезен в любой технической профессии XXI века.
[КуМир] Робот: определить длину самой большой из труб
Помогите с заданием. Напишите код в кумире используя Робота
Размеры поля произвольные. Робот находится в левом верхнем углу поля. Где-то в поле... [КуМир] Робот на перекрестке
Второй день пытаюсь составить алгоритм, вроде действие начинается, а дальше никак не проходит. Может кто подскажет.
Условие: Робот находится на... Какое наименьшее количество двоичных знаков может содержать сообщение, кодирующее слово РОБОТ?
Все заглавные буквы русского алфавита закодированы неравномерным двоичным кодом, в котором никакое кодовое слово не является началом другого кодового... [КуМир] Робот: закрасить клетки внутри коридора
дана вот такая задача: Размеры поля фиксированы 16 длина и 10 ширина, Где то в поле находится горизонтальный коридор, который отстоит от внешних стен... [КуМир] Робот: вычислить и напечатать длину стены и расстояние от конца стены до ближайшего края поля
Здравствуйте, имеется вот такое ТЗ
Размеры поля произвольные. Начальное положение Робота произвольное, при этом с одной из сторон (слева, справа, ... [КуМир] Робот: определить, что закрашенная область содержит только одинаковые источники радиации
Способ закраски: (приведен на изображении)
Размеры поля могут варьироваться в пределах:
4 ≤ширина ≤ 11, 4 ≤ высота ≤ 10
Способ построения: ... Задача Гиа: какая фигура появится на экране при выполнении Исполнителем Черепашка данного алгоритма?
Исполнитель Черепашка перемещается на экране компьютера, оставляя след в виде линии. В каждый конкретный момент известно положение исполнителя и... [КуМир] Нарисовать график функции y = tg(x+1)^2, исполнитель Рисователь
Ребят, простите дурака, но я не знаю где найти нужный форум по КУМИРУ, но так как он мне безумно напоминает Паскаь, пишу суда.
Нужно... Исполнитель КУЗНЕЧИК живёт на числовой оси
Исполнитель КУЗНЕЧИК живёт на числовой оси. Начальное положение КУЗНЕЧИКА – точка 0. Система команд Кузнечика:
Вперед 5 – Кузнечик прыгает вперёд... Исполнитель КУЗНЕЧИК живёт на числовой оси
Исполнитель КУЗНЕЧИК живёт на числовой оси. Начальное положение КУЗНЕЧИКА – точка 0. Система команд Кузнечика:
Вперед 7 – Кузнечик прыгает вперёд... Исполнитель Черепаха
Честно говоря, без понятия куда обратиться из разделов.
Не помогли бы разобраться с кодом на кумире(без понятия что за исполнитель...)
... Исполнитель Черепаха
У меня проблема с использованием исполнителя черепахи в кумире: когда я запускаю код, на карте, на которой расположена черепаха, почему-то нет...
|
