Робот глубже: счётчики, обход стен, накопление

Соединяем циклы, условия и переменные в реальные алгоритмы Робота — то, что и требует ОГЭ.

Сила Робота раскрывается, когда цикл и ветвление работают вместе: Робот идёт по полю и принимает решения на каждом шаге.

Закрашивать выборочно: цикл + условие

Классический приём: Робот идёт вдоль ряда и закрашивает только клетки, удовлетворяющие условию. Например, закрашивать клетку лишь там, где снизу есть стена:

использовать Робот
алг
нач
  нц пока справа свободно
    если снизу стена
      то закрасить
    всё
    вправо
  кц
  если снизу стена
    то закрасить
  всё
кон

Здесь цикл двигает Робота вправо, а вложенное если решает, красить ли текущую клетку. Обратите внимание: после цикла мы ещё раз проверяем последнюю клетку — её цикл не обработал.

Счётчик: считаем закрашенные клетки

Заведём переменную-счётчик и будем её увеличивать. Так Робот может «посчитать», сколько клеток он закрасил:

использовать Робот
алг
нач
  цел k
  k := 0
  нц пока справа свободно
    закрасить
    k := k + 1
    вправо
  кц
  закрасить
  k := k + 1
  вывод "Закрашено клеток: ", k, нс
кон

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

Движение вдоль стены

Очень частый сюжет: Робот должен идти вдоль стены, которая тянется сбоку. Идея — двигаться, пока стена рядом сохраняется. Например, идти вправо вдоль нижней стены:

нц пока снизу стена и справа свободно
  вправо
кц

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

Обход препятствия (выступа)

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

| Робот упёрся в выступ справа, обходим сверху
нц пока справа стена
  вверх
кц
вправо
нц пока снизу свободно
  вниз
кц

Сначала поднимаемся, пока справа стена (вдоль выступа), затем шаг вправо за выступ, затем спускаемся обратно. Такие «лесенки» — типичный сюжет 15.1.

Вложенные циклы: обойти прямоугольник построчно

Чтобы пройти поле построчно, внешний цикл двигает Робота по строкам, внутренний — по клеткам строки:

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

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

Имитация на Python: подсчёт «полок»

Смоделируем ряд клеток, где под некоторыми есть стена (1 в массиве pod), и посчитаем, сколько клеток Робот закрасит:

pod = [1, 0, 1, 1, 0, 1]   # 1 = под клеткой стена
k = 0
result = []
for i in range(len(pod)):
    if pod[i] == 1:        # если снизу стена
        result.append("#") # закрасить
        k += 1
    else:
        result.append(".")
print("".join(result))
print("Закрашено клеток:", k)

Вывод:

#.##.#
Закрашено клеток: 4

Робот закрасил ровно те 4 клетки, под которыми была стена — как и задумано вложенным условием.

Попробуй сам

Напишите алгоритм: Робот идёт вправо до стены и считает, сколько уже закрашенных клеток встретил по пути (используйте проверку клетка закрашена и счётчик).

Частые ошибки

Не обработать последнюю клетку после нц пока (цикл выходит до неё).
Забыть вернуть Робота в начало строки во вложенных циклах.
При обходе выступа перепутать «пока стена» и «пока свободно».
Инициализировать счётчик не нулём или забыть его увеличивать.

Итог

Цикл + ветвление = выборочная закраска по условию обстановки.
Счётчик-переменная позволяет Роботу «считать» клетки.
Движение вдоль стены и обход выступа — типовые приёмы 15.1.
Вложенные циклы обходят поле построчно; не забывайте про возврат и последнюю клетку.