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

Программное решение:

Напишем программу, используя библиотеку turtle для визуализации движения Черепахи по заданному алгоритму. Основная цель — построить фигуры по алгоритму, а затем проверить, какие точки с целочисленными координатами лежат внутри их пересечения. Для этого сначала выполняется алгоритм Черепахи, который рисует границы двух фигур. После этого необходимо отрисовать точки с целочисленными координатами, чтобы после завершения построения подсчитать их количество. Для удобства визуализации используется масштабирование через переменную m, иначе фигуры будут слишком маленькими. Все перемещения умножаются на m.

from turtle import *  # Модуль для работы с исполнителем Черепаха

m = 60  # Масштаб
screensize(3000, 3000) # Увеличиваем размер окна
tracer(0) # Ускоряем отрисовку
left(90) # Поворачиваем Черепаху вверх (вдоль оси Y)

# Построение первой фигуры (треугольник по алгоритму)
for i in range(3):      # Повторяем 3 раза
    forward(12*m)       # Вперёд на 12 (с учётом масштаба)
    right(120)          # Поворот направо на 120°

pu() # Поднимаем хвост, чтобы переместиться без рисования
forward(10*m) # Двигаемся вперёд на 10
right(90)     # Поворот направо на 90°
forward(3*m)  # Вперёд на 3
pd()          # Опускаем хвост для рисования второй фигуры

# Построение второй фигуры (квадрат по алгоритму)
for i in range(4):      # Повторяем 4 раза
    forward(5*m)        # Вперёд на 5
    right(90)            # Поворот направо на 90°

pu() # Поднимаем хвост для расстановки точек

# Проставление точек с целочисленными координатами
for x in range(-10, 20):   # Перебор абсцисс точек
    for y in range(-10, 20): # Перебор ординат точек
        goto(x*m, y*m)      # Перемещаем Черепаху в точку (x, y)
        dot(3)              # Ставим точку размера 3

done() # Завершение работы (окно остаётся открытым)

Осталось посчитать точки внутри пересечения фигур, не считая точки на их границах.

 

Решение в Кумире:

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

Программное решение:

Условие:

Определите, сколько различных отрезков нарисует Черепаха при выполнении данного алгоритма.

Решение программой:

Напишем программу, используя библиотеку turtle для визуализации движения Черепахи по заданному алгоритму. Основная цель — выполнить алгоритм Черепахи и зафиксировать все отрезки, которые она проведёт. Для удобства визуализации используется масштабирование через переменную m, иначе отрезки будут слишком маленькими. Все перемещения умножаются на m. После построения алгоритма можно визуально подсчитать различные нарисованные отрезки или использовать дополнительную логику для их учёта.

from turtle import *  # Модуль для работы с исполнителем Черепаха

m = 30  # Масштаб
screensize(3000, 3000) # Увеличение размера окна
tracer(0) # Ускорение анимации
left(90) # Начальная ориентация Черепахи вверх (вдоль оси Y)

# Основной алгоритм Черепахи
for i in range(50): # Повторяем 50 раз
    forward(6*m) # Вперед на 6 (с учётом масштаба)
    left(90)     # Налево на 90°
    forward(6*m) # Вперед на 6
    left(210)    # Налево на 210°

pu() # Поднимаем хвост, чтобы расставлять точки

# Проставление контрольных точек
for x in range(-10, 20): # Перебор абсцисс точек
    for y in range(-10, 20): # Перебор ординат точек
        goto(x*m, y*m) # Перемещаем Черепаху в точку (x, y)
        dot(3) # Ставим точку размера 3

done() # Завершение работы (окно остаётся открытым)

Осталось подсчитать количество различных отрезков, проведённых Черепахой по алгоритму.

 

Решение в Кумире:

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

Программное решение:

Напишем программу, используя библиотеку turtle для визуализации движения Черепахи по заданному алгоритму. Основная цель — построить фигуру по алгоритму, а затем проверить, какие точки с целочисленными координатами лежат внутри неё. Для этого сначала выполняется алгоритм Черепахи, который рисует границу фигуры. После этого необходимо отрисовать точки с целочисленными координатами, чтобы после завершения построения подсчитать их и определить площадь фигуры. Для удобства визуализации применяется масштабирование через переменную m, иначе фигура будет слишком маленькой. Все перемещения умножаются на m.

from turtle import *  # Модуль для работы с исполнителем Черепаха

m = 30  # Масштаб
screensize(3000, 3000) # Увеличиваем размер окна для отображения
tracer(0) # Ускоряем отрисовку
left(90) # Поворачиваем Черепаху вверх (вдоль оси Y)

# Основной алгоритм Черепахи для построения фигуры
for i in range(10):       # Повторяем 10 раз
    for j in range(3):    # Вложенный цикл 3 раза
        forward(3*m)      # Движение вперёд на 3 (с учётом масштаба)
        right(90)         # Поворот направо на 90°
        forward(3*m)      # Вперёд на 3
        right(270)        # Поворот направо на 270° (эквивалентно налево 90°)
    right(90)             # Поворот направо на 90° после внутреннего цикла

pu() # Поднимаем хвост для расстановки точек

# Проставление точек с целочисленными координатами
for x in range(-10, 20): # Перебор абсцисс точек
    for y in range(-10, 20): # Перебор ординат точек
        goto(x*m, y*m)   # Перемещаем Черепаху в точку (x, y)
        dot(3)           # Ставим точку размера 3

done() # Завершение работы (окно остаётся открытым)

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

Общая площадь равна: .

Решение в Кумире:

Переписываем алгоритм в среду программирования Кумир, запускаем черепашку. Разделим получившуюся фигуру на 5 прямоугольников.

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

Программное решение:

Напишем программу используя библиотеку turtle для визуализации движения Черепахи по заданному алгоритму. Основная цель — построить фигуры по алгоритму, а затем проверить, какие точки с целочисленными координатами лежат прямо на контуре объединения двух фигур. Для этого сначала выполняется алгоритм Черепахи, который рисует границу области по заданному в условии алгоритму. После этого необходимо отрисовать точки с целочисленными координатами, для того чтобы после завершения алгоритма посчитать их. Для удобства визуализации применяется масштабирование (через переменную scale), иначе фигура будет слишком маленькой. Все перемещения умножаются на scale.

from turtle import *  # Импортируем все функции из модуля turtle для работы с графикой

m = 15  # Масштабный коэффициент для увеличения размеров фигур
tracer(0)  # Отключаем анимацию для мгновенного отображения результата
left(90)  # Поворачиваем черепаху на 90 градусов влево (теперь смотрит вверх)

# Рисуем квадрат со стороной 12 единиц (умноженной на масштаб)
for i in range(4):
    forward(12*m)  # Двигаемся вперед на 12 единиц (с учетом масштаба)
    left(270)  # Поворот налево на 270 градусов (эквивалентно -90 градусов)

pu()  # Поднимаем "перо" (перестаем рисовать при движении)

# Выполняем перемещение без рисования (3 шага по определенной траектории)
for i in range(3):
    forward(1*m)    # Двигаемся вперед
    left(270)       # Поворачиваем налево на 270 градусов
    forward(1*m)    # Двигаемся вперед
    left(90)        # Поворачиваем налево на 90 градусов

pd()  # Опускаем "перо" (возобновляем рисование при движении)

# Рисуем прямоугольник со сторонами 8 и 12
for i in range(2):
    forward(8*m)    # Двигаемся вперед на 8 единиц (с учетом масштаба)
    left(270)       # Поворачиваем налево на 270 градусов
    forward(12*m)   # Двигаемся вперед на 12 единиц (с учетом масштаба)
    left(270)       # Поворачиваем налево на 270 градусов

pu()  # Снова поднимаем "перо"

# Создаем сетку из точек для визуализации координатной плоскости
for x in range(-10, 20):        # Проходим по x от -10 до 19
    for y in range(-10, 20):    # Проходим по y от -10 до 19
        goto(x*m, y*m)          # Перемещаемся к координатам (x*15, y*15)
        dot(3)                  # Рисуем точку диаметром 3 пикселя

done()  # Завершаем программу, оставляя окно открытым

После запуска программы получаем рисунок, на котором помечаем точки, которые лежат на границы объединения фигур:

Аккуратно считаем их и получаем ответ: 54.

 

Решение в Кумире:

Переписываем алгоритм в среду программирования Кумир, запускаем черепашку. Выделяем общий контур фигур при объединении и считаем количество точек на этом контуре:

Программное решение:

Напишем программу, используя библиотеку turtle для визуализации движения Черепахи по заданному алгоритму. Основная цель — проследить, какие отрезки рисует Черепаха, чтобы определить их количество. Для удобства визуализации применяется масштабирование через переменную m, иначе движения Черепахи будут слишком малы. Все перемещения умножаются на m. После построения отрезков мы можем проставить точки с целочисленными координатами для визуальной проверки результата.

from turtle import *  # Модуль для работы с исполнителем Черепаха

m = 30  # Масштаб
tracer(0) # Ускорение анимации

left(90) # Поворачиваем Черепаху вверх (вдоль оси Y)

# Основной алгоритм Черепахи
for i in range(30):      # Повторяем 30 раз
    forward(6*m)         # Вперед на 6 (с учётом масштаба)
    left(180)             # Поворот налево на 180°
    forward(6*m)         # Вперед на 6
    left(200)             # Поворот налево на 200°

pu() # Поднимаем хвост для расстановки точек

# Проставление точек с целочисленными координатами для визуальной проверки
for x in range(-10, 20):    # Перебор абсцисс точек
    for y in range(-10, 20): # Перебор ординат точек
        goto(x*m, y*m)       # Перемещаем Черепаху в точку (x, y)
        dot(3)               # Ставим точку размера 3

done() # Завершение работы (окно остаётся открытым)

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

 

Решение в Кумире:

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

Программное решение:

Напишем программу, используя библиотеку turtle для визуализации движения Черепахи по заданному алгоритму. Основная цель — построить фигуру по алгоритму, а затем проверить, какие точки с целочисленными координатами лежат внутри неё. Для этого сначала выполняется алгоритм Черепахи, который рисует границы области по заданному алгоритму. После этого необходимо отрисовать точки с целочисленными координатами, чтобы после завершения построения подсчитать их количество. Для удобства визуализации применяется масштабирование через переменную m, иначе фигура будет слишком маленькой. Все перемещения умножаются на m.

from turtle import *  # Модуль для работы с исполнителем Черепаха

m = 30  # Масштаб
tracer(0) # Ускорение анимации
left(90) # Поворачиваем Черепаху вверх (вдоль оси Y)

# Основной алгоритм Черепахи
for i in range(10):          # Повторяем 10 раз
    for j in range(4):       # Строим квадрат в каждой итерации
        forward(4 * m)       # Вперед на 4 (с учётом масштаба)
        right(90)            # Поворот направо на 90°
    backward(6 * m)          # Возврат назад на 6
    right(90)                # Поворот направо на 90°

pu() # Поднимаем хвост для расстановки точек

# Проставление точек с целочисленными координатами
for x in range(-10, 20):     # Перебор абсцисс точек
    for y in range(-10, 20): # Перебор ординат точек
        goto(x * m, y * m)   # Перемещение Черепахи в точку (x, y)
        dot(3)               # Ставим точку размера 3

done() # Завершение работы (окно остаётся открытым)

Осталось посчитать точки внутри фигуры, не считая точки на линиях.

В маленьких квадратах получается по 9 точек: .

В большом квадрате 25 точек. Тогда всего точек: 25 + 36 = 61 точка.

Решение в Кумире:

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

В маленьких квадратах получается по 9 точек: .

В большом квадрате 25 точек. Тогда всего точек: 25 + 36 = 61 точка.

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

Квадрат со стороной 7: .

Шестиугольник со стороной 2: .

Площадь всей фигуры равна: . Тогда в ответ пойдет 90.

Программное решение:

from turtle import * # Модуль для работы с исполнителем Черепаха
m = 30 # Масштаб
tracer(0)
left(90)

for i in range(4):
    forward(7*m)
    right(90)
    for j in range(6):
        right(60)
        backward(2*m)

pu()
for x in range(-10, 20):
    for y in range(-10, 20):
        goto(x*m, y*m)
        dot(3)
done()

Затем рассчитаем площадь получившихся фигур: квадрата и 4-х шестиугольников.

Решение программой:

Напишем программу, используя библиотеку turtle для визуализации движения Черепахи по заданному алгоритму. Основная цель — построить фигуры по алгоритму, а затем проверить, какие точки с целочисленными координатами лежат внутри их объединения. Для этого сначала выполняется алгоритм Черепахи, который рисует границы двух фигур. После этого необходимо отрисовать точки с целочисленными координатами, чтобы после завершения построения подсчитать их количество. Для удобства визуализации используется масштабирование через переменную m, иначе фигуры будут слишком маленькими. Все перемещения умножаются на m.

from turtle import *  # Модуль для работы с исполнителем Черепаха

m = 30 # Масштаб
tracer(0) # Ускорение анимации
left(90) # Поворачиваем Черепаху вверх (вдоль оси Y)

# Построение первой фигуры по алгоритму
for i in range(3):       # Повторяем 3 раза
    forward(8*m)         # Вперёд на 8 (с учётом масштаба)
    right(90)            # Поворот направо на 90°
    forward(6*m)         # Вперёд на 6
    right(90)            # Поворот направо на 90°

pu() # Поднимаем хвост, чтобы переместиться без рисования

# Перемещаемся к месту построения второй фигуры
forward(5*m) # Вперёд на 5
right(90)    # Направо на 90°
forward(1*m) # Вперёд на 1
left(90)     # Налево на 90°

pd() # Опускаем хвост, начинаем рисовать вторую фигуру

# Построение второй фигуры по алгоритму
for i in range(5):       # Повторяем 5 раз
    forward(6*m)         # Вперёд на 6
    right(90)            # Поворот направо на 90°
    forward(8*m)         # Вперёд на 8
    right(90)            # Поворот направо на 90°

pu() # Поднимаем хвост для расстановки точек

# Проставление точек с целочисленными координатами
for x in range(-10, 20): # Перебор абсцисс точек
    for y in range(-10, 20): # Перебор ординат точек
        goto(x*m, y*m)   # Перемещаем Черепаху в точку (x, y)
        dot(3)           # Ставим точку размера 3

done() # Завершение работы (окно остаётся открытым)

Осталось посчитать точки внутри объединения фигур, включая точки на линиях.

Решение на Кумире:

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

Программное решение:

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

from turtle import *  # Модуль для работы с исполнителем Черепаха

m = 15  # Масштаб
tracer(0) # Ускорение анимации
left(90) # Поворачиваем голову Черепахи вверх (вдоль оси Y)

# Основной алгоритм Черепахи
for i in range(62):     # Повторяем 62 раза
    forward(2*m)        # Движение вперёд на 2 (с учётом масштаба)
    right(30)            # Поворот направо на 30°

pu() # Поднимаем хвост для расстановки точек

# Проставление точек с целочисленными координатами для визуализации
for x in range(-10, 20):    # Перебор абсцисс точек
    for y in range(-10, 20): # Перебор ординат точек
        goto(x*m, y*m)       # Перемещаем Черепаху в точку (x, y)
        dot(3)               # Ставим точку размера 3

done() # Завершение работы (окно остаётся открытым)

Осталось подсчитать количество различных отрезков, нарисованных Черепахой.

Решение на Кумире:

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

Решение программой:

Напишем программу, используя библиотеку turtle для визуализации движения Черепахи по заданному алгоритму. Основная цель — построить фигуру по алгоритму, а затем проверить, какие точки с целочисленными координатами лежат внутри неё, включая точки на линии. Для этого сначала выполняется алгоритм Черепахи, который рисует границу области по заданному в условии алгоритму. После этого необходимо отрисовать точки с целочисленными координатами, чтобы после завершения построения подсчитать их количество. Для удобства визуализации используется масштабирование через переменную m, иначе фигура будет слишком маленькой. Все перемещения умножаются на m.

from turtle import *  # Модуль для работы с исполнителем Черепаха

tracer(0) # Ускоряем отрисовку анимации
m = 50    # Масштабирование для увеличения размера фигуры

pendown() # Опускаем хвост для рисования линии

# Основной алгоритм Черепахи — построение пятиугольника
for i in range(5):       # Повторяем 5 раз
    forward(10 * m)      # Двигаемся вперёд на 10 (с учётом масштаба)
    right(144)            # Поворот направо на 144° для формирования пятиугольника

penup() # Поднимаем хвост для расстановки точек

k = 10  # Количество точек по каждой оси

# Проставление точек с целочисленными координатами
for x in range(-k * m, k * m, m):  # Перебор абсцисс точек
    for y in range(-k * m, k * m, m):  # Перебор ординат точек
        goto(x, y)                    # Перемещаем Черепаху в точку (x, y)
        dot(4, ’black’)               # Ставим точку размера 4 чёрного цвета

update() # Обновляем экран после всех точек
done()   # Завершение работы (окно остаётся открытым)

После завершения работы программы получим вот такую фигуру.

Осталось только аккуратно посчитать все точки.

Решение на Кумире:

Запишем алгоритм в программе Кумир-Стандарт:

использовать Черепаха
алг
нач
  опустить хвост
  вправо(90)
  нц 5 раз
      вперед(10)
      вправо(144)
  кц
кон

Получаем следующий рисунок:

Программное решение:

Напишем программу, используя библиотеку turtle для визуализации движения Черепахи по заданному алгоритму. Основная цель — построить фигуры по алгоритму, а затем определить площадь их пересечения. Для этого сначала выполняется алгоритм Черепахи, который рисует границы двух фигур. После этого мы проставляем точки с целочисленными координатами, чтобы визуально оценить область пересечения. Для удобства визуализации используется масштабирование через переменную m, иначе фигуры будут слишком маленькими. Все перемещения умножаются на m.

from turtle import *  # Модуль для работы с исполнителем Черепаха

m = 40  # Масштаб
screensize(3000, 3000) # Увеличение размера окна
tracer(0) # Ускорение анимации
left(90) # Начальная ориентация Черепахи (вдоль оси Y)

# Построение первой фигуры по алгоритму
for i in range(8):       # Повторить 8 раз
    forward(12 * m)      # Вперёд 12 (с учётом масштаба)
    right(90)            # Направо 90
    forward(8 * m)       # Вперёд 8
    right(90)            # Направо 90

pu() # Поднимаем хвост для перемещений без рисования
forward(5 * m)  # Смещение вперёд на 5
right(90)       # Поворот направо
backward(14 * m) # Движение назад на 14
left(90)        # Поворот налево

pd() # Опускаем хвост для рисования второй фигуры

# Построение второй фигуры по алгоритму
for i in range(24):      # Повторить 24 раза
    forward(7 * m)       # Вперёд 7
    right(90)            # Направо 90
    forward(15 * m)      # Вперёд 15
    right(90)            # Направо 90

pu() # Поднимаем хвост для расстановки точек

# Проставление точек с целочисленными координатами
for x in range(-60, 60): # Перебор абсцисс точек
    for y in range(-60, 60): # Перебор ординат точек
        goto(x * m, y * m)   # Перемещение к точке (x, y)
        dot(3)               # Ставим точку размера 3

done() # Завершение работы (окно остаётся открытым)

Осталось посчитать площадь фигуры, которая находится внутри пересечения построенных фигур.

Получаем, что фигура, которая находится на пересечении двух прямоугольников, имеет две стороны: 1 и 7 и является прямоугольником. Значит, ее площадь: .

В программе Кумир:

В программе Кумир:

 

Программное решение:

from turtle import * #модуль для работы с исполнителем Черепаха
m = 15 #масштаб
tracer(0)
left(90)
backward(10*m)
for i in range(3):
    forward(14*m)
    right(90)
    forward(18*m)
    right(90)
pu()
forward(2*m)
right(90)
backward(-4*m)
left(90)
pd()
for i in range(9):
    backward(-2*m)
    left(60)
    forward(10*m)
    right(120)
pu()
for x in range(-25, 25):
    for y in range(-20, 30):
        goto(x*m, y*m)
        dot(3)
#прорисовка осей координат
for x in range(-50, 50):
    goto(x*m, 0)
    pd()
    pencolor("red")
pu()
for y in range(-50, 50):
    goto(0, y*m)
    pd()
    pencolor("red")
done()

Получаем, что в нужную область попадает только координата (13,1). Значит, ответ 1.

В программе Кумир:

Программное решение:

from turtle import * #модуль для работы с исполнителем Черепаха
m = 23 #масштаб
tracer(0)
left(90)
right(60)
for i in range(10):
    backward(5*m)
    right(240)
    forward(11*m)
    left(60)
pu()
for x in range(-25, 25):
    for y in range(-20, 30):
        goto(x*m, y*m)
        dot(3)
#прорисовка осей координат
for x in range(-50, 50):
    goto(x*m, 0)
    pd()
    pencolor("red")
pu()
for y in range(-50, 50):
    goto(0, y*m)
    pd()
    pencolor("red")
done()

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

Кумир:

Python:

Напишем программу, используя библиотеку turtle для визуализации движения Черепахи по заданному алгоритму. Основная цель — построить две фигуры по алгоритму, после чего определить, какие точки с целочисленными координатами лежат внутри области, образованной их объединением. Для этого сначала выполняется алгоритм Черепахи, который рисует обе фигуры, а затем мы проставляем точки с целочисленными координатами для последующего подсчёта. Для удобства визуализации используется масштабирование через переменную m, иначе фигуры будут слишком маленькими. Все перемещения умножаются на m.

from turtle import *  # Модуль для работы с исполнителем Черепаха

m = 30  # Масштабирование
tracer(0) # Ускоряем отрисовку

pu() # Поднимаем хвост, чтобы перемещаться без рисования
forward(10 * m) # Сдвигаемся вперёд на 10 (с учётом масштаба)
pd() # Опускаем хвост, чтобы начать рисовать первую фигуру

# Построение первой фигуры по алгоритму
for i in range(5):       # Повторяем 5 раз
    forward(-6 * m)      # Движение назад на 6
    left(180)            # Поворот налево на 180°
    forward(4 * m)       # Вперёд на 4
    right(90)            # Поворот направо на 90°

forward(-5 * m)          # Перемещение для подготовки ко второй фигуре

# Построение второй фигуры по алгоритму
for i in range(8):       # Повторяем 8 раз
    forward(3 * m)       # Вперёд на 3
    right(135)           # Поворот направо на 135°
    backward(5 * m)      # Движение назад на 5
    right(45)            # Поворот направо на 45°

pu() # Поднимаем хвост для расстановки точек

# Проставление точек с целочисленными координатами
for x in range(-25, 25):  # Перебор абсцисс точек
    for y in range(-20, 30): # Перебор ординат точек
        goto(x * m, y * m)   # Перемещаем Черепаху в точку (x, y)
        dot(3)               # Ставим точку размера 3

done() # Завершение работы (окно остаётся открытым)

Запускаем алгоритм и внимательно считаем точки. Важно не учитывать точки на линиях. Получаем 6 точек внутри параллелограмма и 81 точку внутри квадрата.

В программе Кумир:

Программное решение:

Напишем программу, используя библиотеку turtle для визуализации движения Черепахи по заданному алгоритму. Основная цель — построить две фигуры по алгоритму, а затем проверить, какие точки с целочисленными координатами лежат на их пересечении, включая точки на линиях. Для этого сначала выполняется алгоритм Черепахи, который рисует границы обеих фигур. После этого необходимо отрисовать точки с целочисленными координатами, чтобы после завершения построения подсчитать их количество. Для удобства визуализации используется масштабирование через переменную m, иначе фигуры будут слишком маленькими. Все перемещения умножаются на m.

from turtle import *  # Модуль для работы с исполнителем Черепаха

m = 15  # Масштаб
screensize(1000, 1000)  # Размер окна, чтобы рисунок помещался
tracer(0)  # Ускоряем отрисовку
left(90)   # Поворачиваем Черепаху вверх (вдоль оси Y)

# Построение первой фигуры (квадрат по алгоритму)
for i in range(4):          # Четыре стороны квадрата
    forward(10 * m)         # Движение вперёд на 10 (с учётом масштаба)
    right(90)               # Поворот направо на 90°

pu() # Поднимаем хвост, чтобы перемещаться без рисования

# Перемещаемся к началу второй фигуры
forward(12 * m)  # Вперёд на 12
right(90)        # Поворот направо на 90°
forward(6 * m)   # Вперёд на 6
left(90)         # Поворот налево на 90°
pd()             # Опускаем хвост, начинаем рисовать вторую фигуру

# Построение второй фигуры (шестиугольник по алгоритму)
for i in range(6):          # Шесть повторений для шестиугольника
    forward(13 * m)         # Вперёд на 13
    right(90)               # Поворот направо на 90°
    forward(5 * m)          # Вперёд на 5
    right(90)               # Поворот направо на 90°

pu() # Поднимаем хвост для расстановки точек

# Проставление точек с целочисленными координатами
for x in range(-100, 100):   # Перебор абсцисс точек
    for y in range(-100, 100): # Перебор ординат точек
        goto(x * m, y * m)     # Перемещаем Черепаху в точку (x, y)
        dot(3)                 # Ставим точку размера 3

done() # Завершение работы (окно остаётся открытым)

Фигуры не имеют точек пересечения, поэтому ответ 0.

В программе Кумир:

Программное решение:

Напишем программу, используя библиотеку turtle для визуализации движения Черепахи по заданному алгоритму. Основная цель — построить две фигуры по алгоритму, а затем проверить, какие точки с целочисленными координатами лежат на их пересечении. Для этого сначала выполняется алгоритм Черепахи, который рисует границы фигур. После этого необходимо отрисовать точки с целочисленными координатами, чтобы после завершения построения подсчитать их количество. Для удобства визуализации используется масштабирование через переменную m, иначе фигуры будут слишком маленькими. Все перемещения умножаются на m.

from turtle import *  # Модуль для работы с исполнителем Черепаха

screensize(3000, 3000) # Увеличиваем размер окна для отображения
m = 40  # Масштабирование
tracer(0) # Ускоряем отрисовку
left(90)  # Поворачиваем Черепаху вверх (вдоль оси Y)
pu()      # Поднимаем хвост, чтобы перемещаться без рисования

# Построение первой фигуры по алгоритму
for i in range(7):      # Семь итераций для построения сегментов
    right(60)            # Поворот направо на 60°
    forward(9 * m)       # Движение вперёд на 9 с учётом масштаба
pd() # Опускаем хвост для начала рисования

# Построение второй фигуры по алгоритму
for i in range(5):      # Пять итераций для построения сегментов
    forward(3 * m)      # Движение вперёд на 3
    right(90)            # Поворот направо на 90°

for i in range(8):      # Восемь итераций для построения сегментов
    right(30)            # Поворот направо на 30°
    forward(10 * m)      # Движение вперёд на 10
    right(60)            # Поворот направо на 60°
pu() # Поднимаем хвост для расстановки точек

# Проставление точек с целочисленными координатами
for x in range(-100, 100):  # Перебор абсцисс точек
    for y in range(-100, 100): # Перебор ординат точек
        goto(x * m, y * m)   # Перемещаем Черепаху в точку (x, y)
        dot(3)               # Ставим точку размера 3

done() # Завершение работы (окно остаётся открытым)

Осталось посчитать количество точек, находящихся на пересечении двух фигур.

Всего 6 точек.

В программе Кумир:

Программное решение:

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

from turtle import *  # Модуль для работы с исполнителем Черепаха

m = 40  # Масштаб
screensize(1000, 1000) # Устанавливаем размер окна для возможности скролла
tracer(0) # Ускоряем отрисовку

left(90) # Поворачиваем Черепаху вверх (вдоль оси Y)

# Построение контура по алгоритму
for i in range(4):        # Повторяем 4 раза для создания фрагмента контура
    backward(3*m)         # Движение назад на 3 (с учётом масштаба)
    right(210)            # Поворот направо на 210°
    forward(9*m)          # Движение вперёд на 9
    left(30)              # Поворот налево на 30°

pu() # Поднимаем хвост для расстановки точек

# Проставление точек с целочисленными координатами
for x in range(-100, 100): # Перебор абсцисс точек
    for y in range(-100, 100): # Перебор ординат точек
        goto(x*m, y*m)       # Перемещаем Черепаху в точку (x, y)
        dot(3)               # Ставим точку размера 3

done() # Завершение работы (окно остаётся открытым)

Осталось посчитать точки внутри контура, не считая точки на линиях.

Программное решение:

Напишем программу, используя библиотеку turtle для визуализации движения Черепахи по заданному алгоритму. Основная цель — построить фигуры по алгоритму, чтобы затем вычислить их суммарную площадь. Для удобства визуализации применяется масштабирование через переменную m, иначе фигуры будут слишком маленькими. Все перемещения умножаются на m. После построения фигур мы проставляем точки с целочисленными координатами, что может помочь визуально оценить область фигур.

from turtle import *  # Модуль для работы с исполнителем Черепаха

m = 23  # Масштаб
tracer(0)  # Ускорение анимации

pu()  # Поднимаем хвост, чтобы перемещаться без рисования
forward(12*m)  # Перемещаемся вперед на 12 единиц масштаба
pd()  # Опускаем хвост, начинаем рисовать

# Построение первой фигуры по алгоритму
for i in range(8):  # Повторяем 8 раз
    forward(-6*m)   # Движение назад на 6 (умножаем на масштаб)
    left(240)       # Поворот налево на 240°
backward(12*m)      # Возврат назад на 12 единиц масштаба

# Построение второй фигуры по алгоритму
for i in range(6):  # Повторяем 6 раз
    forward(6*m)    # Движение вперед на 6
    right(240)      # Поворот направо на 240°

pu()  # Поднимаем хвост для расстановки точек

# Проставление точек с целочисленными координатами
for x in range(-25, 25):  # Перебор абсцисс точек
    for y in range(-20, 30):  # Перебор ординат точек
        goto(x*m, y*m)  # Перемещаем Черепаху в точку (x, y)
        dot(3)          # Ставим точку размера 3

done()  # Завершение работы (окно остаётся открытым)

В результате получаем два равносторонних треугольника со стороной 6. Площадь каждого равна: . Суммарная площадь равна

 

Решение в Кумире:

Площадь вычислим аналогично решению на Python.

Решение с помощью программы:

Напишем программу, используя библиотеку turtle для визуализации движения Черепахи по заданному алгоритму. Основная цель — построить фигуру по алгоритму, а затем проверить, какие точки с целочисленными координатами лежат внутри неё. Для этого сначала выполняется алгоритм Черепахи, который рисует границу области по заданному в условии алгоритму. После этого необходимо отрисовать точки с целочисленными координатами, для того чтобы после завершения алгоритма посчитать их и вычислить искомую величину. Для удобства визуализации применяется масштабирование (через переменную m), иначе фигура будет слишком маленькой. Все перемещения умножаются на m.

from turtle import * # Модуль для работы с исполнителем Черепаха
m = 20 # Масштаб
screensize(1000, 1000) # Выставляем размер окна, чтобы иметь возможность скролла в случае,
# если рисунок выйдет за грань.
tracer(0)  # Ускорение анимации
# Начальная ориентация Черепахи
# (по умолчанию — вдоль оси X, поворачиваем на 90° влево)
left(90)
pd() # Опускаем хвост
# Основной алгоритм Черепахи
for i in range(6): # Повторить 6 раз
    right(45) # Направо 45
    forward(5 * m) # Вперёд 5 * m
for i in range(4): # Повторить 4 раза
    forward(12 * m) # Вперёд 12 * m
    right(270) # Направо 270
pu() # Поднять хвост
# Расставляем точки с целыми координатами
for x in range(-25, 25): # Перебор абсцисс точек
    for y in range(-20, 30): # Перебор ординат точек
        goto(x * m, y * m) # Перемещение к точке (x, y)
        dot(3) # Ставим точку размером 3
done() # Завершение работы (окно остаётся открытым)

Заметим, что одна сторона квадрата занимает 12 клеток, а отрезок ломанной, выходящей из него - 5 клеток. Периметр будет равен: .

 

Решение в Кумире:

Заметим, что одна сторона квадрата занимает 12 клеток, а отрезок ломанной, выходящей из него - 5 клеток. Периметр будет равен: .

Решение с помощью программы:

Напишем программу, используя библиотеку turtle для визуализации движения Черепахи по заданному алгоритму. Основная цель — построить фигуру по алгоритму, а затем проверить, какие точки с целочисленными координатами лежат внутри неё. Для этого сначала выполняется алгоритм Черепахи, который рисует границу области по заданному в условии алгоритму. После этого необходимо отрисовать точки с целочисленными координатами, для того чтобы после завершения алгоритма посчитать их и вычислить искомую величину. Для удобства визуализации применяется масштабирование (через переменную m), иначе фигура будет слишком маленькой. Все перемещения умножаются на m.

from turtle import * # Модуль для работы с исполнителем Черепаха
m = 20 # Масштаб для увеличения видимости рисунка
tracer(0) # Ускорение анимации
pd() # Опускаем хвост
# Начальная ориентация Черепахи
# (по умолчанию — вдоль оси X, поворачиваем на 90° влево)
left(90)
left(189) # Налево 189
for i in range(5): # Повторить 5 раз
    left(60) # Налево 60
    for j in range(10): # Повторить 10 раз
        forward(5 * m) # Вперёд на 5 * m
        right(90) # Направо 90
pu() # Поднять хвост
# Расставляем точки с целыми координатами
for x in range(-25, 25): # Перебор абсцисс точек
    for y in range(-20, 30): # Перебор ординат точек
        goto(x * m, y * m) # Перемещение к точке (x, y)
        dot(3) # Ставим точку размером 3
done() # Завершение работы (окно остаётся открытым)

Видим 4 целые точки, что и будет ответом.  

Решение в Кумире:

Видим 4 целые точки внутри пересечения фигур.