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

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

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

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

m = 20  # Масштаб
tracer(0) # Ускорение анимации
screensize(1200,1200) # Увеличение размера окна
pd() # Опускаем хвост
# Начальная ориентация Черепахи
# (по умолчанию — вдоль оси X, поворачиваем на 90° влево)
lt(90)

# Основной алгоритм Черепахи
for i in range(10000): # Повторить 10000 раз
    forward(10 * m) # Вперед 10 (умножаем на m для масштабирования)
    right(30) # Направо 30
    left(210) # Налево 210
    forward(10 * m) # Вперед 10
    left(90) # Налево 90
    forward(25 * m) # Вперед 25
    left(180) # Налево 180
    forward(5 * m) # Вперед 5
    right(180) # Направо 180
    forward(5 * m) # Вперед 5
    left(90) # Налево 90
    forward(10 * m) # Вперед 10
    left(90) # Налево 90
    forward(20 * m) # Вперед 20
    forward(5 * m) # Вперед 5
    left(90) # Налево 90
    forward(10 * m) # Вперед 10
    left(180) # Налево 180

pu() # Поднимаем хвост
# Проставление точек
for x in range(-45, 45): # Перебор абсцисс точек
    for y in range(-30, 40): # Перебор ординат точек
        goto(x * m, y * m) # Перемещение к точке (x, y)
        dot(3) # Ставим точку размера 3
done() # Завершение работы (окно остаётся открытым)

Вывод программы:

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

Решение с помощью Кумира:

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

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

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

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

from turtle import * # Импортируем модуль для работы с Черепахой
screensize(1000, 1000) # Увеличение размера окна
tracer(0) # Ускорение анимации
update() # Обновление экрана после отрисовки
r = 25 # Масштаб для увеличения видимости рисунка
# Начальная ориентация Черепахи
# (по умолчанию — вдоль оси X, поворачиваем на 90° влево)
left(90)
for x in range(10): # Повторить 10 раз
    right(30) # Направо 30
    forward(20 * r) # Вперед 20 (умножаем на r для масштабирования)
    right(120) # Направо 120
    forward(20 * r) # Вперед 20
    right(120) # Направо 120
    forward(20 * r) # Вперед 20
    right(90) # Направо 90
up() # Поднимаем хвост
# Расставляем точки с целыми координатами
for x in range(-20, 20): # Перебор абсцисс точек
    for y in range(-20, 20): # Перебор ординат точек
        goto(x*r, y*r) # Перемещение к точке (x, y)
        dot(3) # Ставим точку размера 3
done() # Завершение работы (окно остаётся открытым)

Вывод программы:

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

Решение с помощью Кумира:

Открываем программу Кумир и вводим условие.

Считаем количество точек в полученной фигуре и получаем ответ .

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

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

from turtle import * # Модуль для работы с исполнителем Черепаха
m = 20 # Масштаб для увеличения видимости рисунка
tracer(0) # Ускорение анимации
pd() # Поднимаем хвост
# Начальная ориентация Черепахи
# (по умолчанию — вдоль оси X, поворачиваем на 90° влево)
left(90)

# Основной алгоритм Черепахи
for i in range(10): # Повторить 10 раз
    forward(10*m) # Вперед 10 (умножаем на m для масштабирования)
    right(60) # Направо 60

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

Вывод программы:

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

Решение с помощью Кумира:

Открываем программу Кумир и вводим условие.

Считаем количество точек в полученной фигуре и получаем ответ .

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

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

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

tracer(50)  # Ускорение анимации движения черепахи
scale = 10  # Масштаб рисунка
# Начальная ориентация Черепахи
# (по умолчанию — вдоль оси X, поворачиваем на 90° влево)
left(90)

# Основной алгоритм Черепахи

for _ in range(2):  # Повторяем 2 раза
    forward(5 * scale)   # Вперёд 5 (умножаем на scale для масштабирования)
    right(90)            # Направо 90
    forward(25 * scale)  # Вперёд 25
    right(90)            # Направо 90

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


forward(4 * scale)   # Вперёд 4
right(90)            # Направо 90
forward(6 * scale)   # Вперёд 6
left(90)             # Налево 90

# Опустить хвост, чтобы снова рисовать
down()

for _ in range(4):  # Повторяем 4 раза
    forward(10 * scale)   # Вперёд 10
    right(45)             # Направо 45
    forward(10 * scale)   # Вперёд 10
    right(45)             # Направо 45

# Расставляем точки с целыми координатами
up()  # Поднимаем хвост чтобы не рисовать лишние линии
for x in range(-35, 35):  # Перебор абсцисс точек
    for y in range(-35, 35):  # Перебор ординат точек
        goto(x * scale, y * scale)  # Перемещение к точке (x, y)
        dot(3, "blue")  # Ставим точку синего цвета размера 3

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

Площадь фигуры можно найти разницей площади прямоугольника и треугольника. Прямоугольник имеет стороны 19 и 5, следовательно площадь равна 95. Катеты треугольника равны 4, тогда плошадь треугольника равна 8. Тогда ответ 95-8=87.

Решение с помощью Кумира:

В результате выполнения алгоритма через программу «Кумир» пересечением фигур является прямоугольник с отрезанным треугольником:

Площадь фигуры можно найти разницей площади прямоугольника и треугольника. Прямоугольник имеет стороны 19 и 5, следовательно площадь равна 95. Катеты треугольника равны 4, тогда плошадь треугольника равна 8. Тогда ответ 95-8=87.

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

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

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

tracer(50)  # Ускорение анимации движения черепахи
scale = 20  # Масштаб для увеличения видимости рисунка
# Начальная ориентация Черепахи
# (по умолчанию — вдоль оси X, поворачиваем на 90° влево)
left(90)

# Основной алгоритм Черепахи
forward(10 * scale)  # Вперёд 10 (умножаем на scale для масштабирования)
right(90)            # Направо 90
forward(6 * scale)   # Вперёд 6
right(90)            # Направо 90
forward(6 * scale)   # Вперёд 6
right(90)            # Направо 90
forward(10 * scale)  # Вперёд 10

# Расставляем точки с целыми координатами
up()  # Поднимаем хвост чтобы не рисовать лишние линии
for x in range(-20, 20):  # Перебор абсцисс точек
    for y in range(-20, 20):  # Перебор ординат точек
        goto(x * scale, y * scale)  # Перемещение к точке (x, y)
        dot(3, "blue")  # Ставим точку синего цвета размера 3

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

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

Решение с помошью Кумира:

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

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

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

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

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

tracer(50)  # Ускорение анимации движения черепахи
scale = 15  # Масштаб для увеличения видимости рисунка
# Начальная ориентация Черепахи
# (по умолчанию — вдоль оси X, поворачиваем на 90° влево)
left(90)

# Основной алгоритм Черепахи

for _ in range(6):  # Повторить 6 раз
    for _ in range(2):  # Повторить 2 раза
        forward(5 * scale)  # Вперёд 5 (умножаем на scale для масштабирования)
        right(90)           # Направо 90
        forward(5 * scale)  # Вперёд 5
        right(270)          # Направо 270 (или налево на 90)
    right(90)               # Направо 90

# Расставляем точки с целыми координатами
up()  # Поднимаем хвост чтобы не рисовать лишние линии
for x in range(-30, 30):  # Перебор абсцисс точек
    for y in range(-30, 30):  # Перебор ординат точек
        goto(x * scale, y * scale)  # Перемещение к точке (x, y)
        dot(3, "blue")  # Ставим точку синего цвета размером 3

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

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

Решение с помощью Кумира:

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

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

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

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

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

tracer(50)  # Ускорение анимации движения черепахи
scale = 15  # Масштаб для увеличения видимости рисунка
# Начальная ориентация Черепахи
# (по умолчанию — вдоль оси X, поворачиваем на 90° влево)
left(90)

# Основной алгоритм Черепахи
for _ in range(10):  # Повторить 10 раз
    for _ in range(4):  # Повторить 4 раза
        forward(5 * scale)  # Вперёд 5 (умножаем на scale для масштабриования)
        right(90)  # Направо 90
    backward(10 * scale)  # Назад 10
    right(90)  # Направо 90

# Расставляем точки с целыми координатами
up()  # Поднимаем хвост чтобы не рисовать лишние линии
for x in range(-30, 30):  # Перебор абсцисс точек
    for y in range(-30, 30):  # Перебор ординат точек
        goto(x * scale, y * scale)  # Перемещение к точку (x, y)
        dot(3, "blue")  # Ставим точку синего цвета размера 3

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

Она состоит из четырех равных квадратов и одного большого. Сторона большого квадрата равна 10, значит его площадь равна 100. Сторона маленького квадрата равна 5, его площадь - 25. Площадь всех квадратов в сумме равна:

Решение с помощью Кумира:

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

Она состоит из четырех равных квадратов и одного большого. Сторона большого квадрата равна 10, значит его площадь равна 100. Сторона маленького квадрата равна 5, его площадь - 25. Площадь всех квадратов в сумме равна:

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

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

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

tracer() # Ускорение анимации
k = 20 # Масштаб для увеличения видимости рисунка
dot(3, ’red’) # Точка (0,0)

# Функция для смещения с логированием координат
# xcor, ycor - Текущие координаты черепахи
def move(a, b):
    x = xcor() + a # Изменение координаты x
    y = ycor() + b # Изменение координаты y
    goto(x, y) # Перемещение к точке (x, y)

# Основной алгоритм Черепахи

for i in range(2): # Повторить два раза
    move(2 * k, 1 * k) # Сместиться на (2, 1)
    move(-2 * k, -1 * k) # Сместиться на (-2, -1)
    move(3 * k, 5 * k) # Сместиться на (3, 5)
pu() # Поднимаем хвост

# Расставляем точки с целыми координатами
for x in range(0, 10): # Перебор абсцисс точек
    for y in range(0, 12): # Перебор ординат точек
        goto(x * k, y * k) # Перемещение к точке (x, y)
        dot(2) # Ставим точку размера 2
done() # Завершение работы (окно остаётся открытым)

Остается лишь посчитать количество точек у получившейся фигуры. Всего их 4 штуки.

Решение с помощью Кумира:

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

Как видно из рисунка, целочисленные координаты имеют точки: (2,1), (3,5), (5,6), (6,10). Всего их 4 штуки.

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

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

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

tracer(0)  # Ускорение анимации
scale = 40  # Масштаб для увеличения видимости рисунка
# Начальная ориентация Черепахи
# (по умолчанию — вдоль оси X, поворачиваем на 90° влево)
left(90)

# Основной алгоритм Черепахи

for _ in range(20): # Повторить 20 раз
    right(225)  # Поворот направо на 225 градусов
    forward(7 * scale)  # Вперед на 7 (умножаем на scale для масштабирования)

up() # Поднимаем хвост

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

update()  # Принудительное обновление экрана после отрисовки
done() # Завершение работы (окно остаётся открытым)

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

Решение с помощью Кумира:

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

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

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

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

tracer(50)  # Ускорение анимации движения черепахи
scale = 20  # Масштаб для увеличения видимости рисунка
# Начальная ориентация Черепахи
# (по умолчанию — вдоль оси X, поворачиваем на 90° влево)
left(90)

# Основной алгоритм Черепахи

for _ in range(100):  # Повторяем 100 раз
    forward(10 * scale)   # Вперёд 10 (умножаем на scale для масштабирования)
    right(180)            # Направо 180
    forward(10 * scale)   # Вперёд 10
    right(198)            # Направо 198

# Расставляем точки с целыми координатами
up()  # Поднимаем хвост чтобы не рисовать лишние линии
for x in range(-15, 15):  # Перебор абсцисс точек
    for y in range(-15, 15):  # Перебор ординат точек
        goto(x * scale, y * scale)  # Перемещаем черепаху на точку (x, y)
        dot(3, "blue")  # Ставим точку синего цвета размера 3

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

Отрезков здесь 20, а не 10, так как по самой программе мы можем увидеть, что проводятся отрезки длиной 10 клеток, а не 20, то есть они маленькие.

Решение с помощью Кумира:

Не забываем убирать галочку рядом с "авто"для корректной оценки длин!

Отрезков здесь 20, а не 10, так как по самой программе мы можем увидеть, что проводятся отрезки длиной 10 клеток, а не 20, то есть они маленькие.

Решение 1: Руками

Чтобы Черепаха вернулась в исходное направление, суммарный поворот должен быть кратен .

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

=

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

Для нахождения замкнутой ломаной линии нужно, чтобы сумма поворотов была кратна 360. n можно найти простой программой на питоне:

for n in range(1, 100):
    if (50 * n) % 360 == 0:
        print(n)

Получаем 36.

Python

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

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

tracer(50)  # Ускорение анимации движения Черепахи
screensize(4000, 4000)  # Увеличиваем размер окна, добавляем прокрутку
scale = 60  # Масштаб рисунка (каждый шаг умножаем на scale)

# По умолчанию Черепаха смотрит вдоль оси X,
# поворачиваем её на 90° влево для начала алгоритма
lt(90)

# Основной алгоритм построения фигуры
right(40)           # Поворачиваем направо на 40°
for i in range(2):  # Повторяем дважды
    forward(15*scale)  # Движение вперёд на 15 (с учётом масштаба)
    right(60)          # Поворот направо на 60°
    forward(5*scale)   # Движение вперёд на 5 (с учётом масштаба)
    right(120)         # Поворот направо на 120°

# Расставляем точки с целыми координатами
up()  # Поднимаем хвост, чтобы не рисовать при перемещении
for x in range(-5, 20):       # Перебор абсцисс точек
    for y in range(-5, 20):   # Перебор ординат точек
        goto(x * scale, y * scale)  # Переходим в точку (x, y)
        dot(4, "blue")  # Рисуем точку синего цвета размером 4

update()  # Обновляем экран с готовым изображением
done()    # Завершаем работу (окно остаётся открытым)

На полученном рисунке посчитаем количество точек. Заметим одну сомнительную точку. Чтобы её проверить, уменьшим радиус точки на 3, а масштаб на 150, чтобы её рассмотреть поближе. В итоге она лежит внутри фигуры, учитываем её в ответ.

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

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

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

tracer(50)  # Ускорение анимации движения Черепахи
scale = 40  # Масштаб рисунка

left(90) # Начальная ориентация: поворачиваем голову вверх

# Внешний цикл: повторяем 16 раз
for _ in range(16):
    # Внутренний цикл: повторяем 6 раз
    for _ in range(6):
        forward(3 * scale)  # Вперёд на 3 (с учётом масштаба)
        left(60)            # Налево на 60°
    left(120)               # Налево на 120° (после завершения внутреннего цикла)

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

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

update() # Обновление экрана для отображения результата
done()   # Завершение работы (окно остаётся открытым)

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

Решение Кумиром

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

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

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

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

tracer(50)  # Ускоряем анимацию движения Черепахи
scale = 30  # Масштаб рисунка

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

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

# Расставляем точки с целыми координатами
up()  # Поднимаем хвост, чтобы перемещаться без рисования линий
for x in range(-15, 15):       # Перебор абсцисс точек
    for y in range(-15, 15):   # Перебор ординат точек
        goto(x * scale, y * scale)    # Переход в точку (x, y)
        dot(3, "blue")               # Ставим точку синего цвета

update()  # Обновляем экран (выводим итоговый рисунок)
done()    # Завершаем работу (окно остаётся открытым)

Осталось вычислить площадь построенной фигуры. Первая сторона равна 8, вторая — 10, поэтому . Это и будет ответом.

Решение Кумиром

Посмотрев на алгоритм, можно понять, что черепаха просто рисует прямоугольник со сторонами 8 и 10. Или можно переписать алгоритм в программу «Kumir», запустить, тогда получится фигура, представленная на картинке. Осталось посчитать, первая сторона равна 8, вторая — 10, поэтому . Это и будет ответом.

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

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

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

tracer(50)  # Ускорение анимации движения Черепахи
scale = 20  # Масштаб рисунка
left(90)    # Поворот Черепахи вверх (вдоль оси Y)

# Выполнение последовательности команд, рисующих фигуру
forward(15 * scale)   # Вперёд на 15 * scale
right(90)             # Направо на 90 градусов
forward(5 * scale)    # Вперёд на 5 * scale
right(90)             # Направо на 90 градусов
forward(7 * scale)    # Вперёд на 7 * scale
left(90)              # Налево на 90 градусов
forward(10 * scale)   # Вперёд на 10 * scale
right(90)             # Направо на 90 градусов
forward(8 * scale)    # Вперёд на 8 * scale
right(90)             # Направо на 90 градусов
forward(15 * scale)   # Вперёд на 15 * scale

# Расставляем точки с целыми координатами
up()  # Поднимаем хвост, чтобы не рисовать лишние линии
for x in range(-20, 20):           # Перебор абсцисс точек
    for y in range(-20, 20):       # Перебор ординат точек
        goto(x * scale, y * scale) # Перемещаем Черепаху на точку (x, y)
        dot(3, "blue")             # Ставим точку синего цвета

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

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

Решение Кумиром

Посмотрев на алгоритм, можно понять, что черепаха просто рисует замкнутую фигуру со сторонами 15, 5, 7, 10, 8, 15, если сложить эти стороны, то получим периметр: . Можно также переписать алгоритм и посчитать на рисунке.

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

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

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

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

# Построение фигуры по алгоритму
# Внешний цикл: повторяем 10 раз
for _ in range(10):
    forward(15 * scale)  # Движение вперёд на 15 (с учётом масштаба)
    right(60)            # Поворот направо на 60°

# Расстановка точек с целыми координатами для наглядности
up()  # Поднимаем хвост, чтобы не рисовать линии при перемещении
for x in range(-40, 40):        # Перебор абсцисс точек
    for y in range(-40, 40):    # Перебор ординат точек
        goto(x * scale, y * scale)  # Переход к точке (x, y)
        dot(3, "blue")              # Ставим точку синего цвета

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

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

Решение Кумиром

Алгоритм заставляет черепаху двигаться вперед на 15 единиц и затем поворачивать на 60 градусов направо. Это повторяется 10 раз.

Шесть таких циклов (60 градусов * 6) возвращают черепаху к исходной точке, образуя шестиугольник. Таким образом, итоговая фигура состоит из 6 сторон.

Решение 1: Руками

Основываясь на алгоритме действий Черепахи, она перемещается по следующей траектории:

1. Она идёт вперед на 5 единиц (вдоль оси Y).

2. Затем поворачивает на 45 градусов вправо. Теперь её направление отклоняется от оси Y на 45 градусов.

3. Она идёт назад на 5 единиц, возвращаясь ближе к оси X, но не полностью возвращаясь к началу координат.

Этот цикл повторяется R раз. Чтобы Черепаха вернулась к началу координат, она должна сделать полный оборот (360 градусов) и вернуться к первоначальному направлению. Каждый цикл поворачивает Черепаху на 45 градусов вправо. Следовательно, для полного оборота ей потребуется повторить цикл 8 раз.

Ответ: число R, при котором Черепаха впервые вернётся в начало координат, равно 8.

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

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

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

tracer() # Включаем пошаговую отрисовку

# Перебор возможных значений R от 1 до 19
for r in range(1,20):
    f = 0                  # Флаг для выхода из цикла
    home()                 # Возвращаем Черепаху в начало координат (0,0)
    for i in range(r):     # Повторяем r раз
        forward(5)         # Двигаемся вперёд на 5
        right(45)          # Поворот направо на 45°
        backward(5)        # Двигаемся назад на 5
    x = xcor()             # Получаем текущую координату по X
    y = ycor()             # Получаем текущую координату по Y
    if round(x) == 0.0 and round(y) == 0.0: # Проверяем, вернулась ли Черепаха в (0,0)
        f = 1              # Устанавливаем флаг
        print(r)           # Выводим значение R
        break              # Прерываем цикл
    if f == 1: break       # Выход из внешнего цикла, если условие выполнено

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

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

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

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

tracer(50)  # Ускорение анимации движения Черепахи
scale = 60  # Масштаб рисунка

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

# Внешний цикл: повторяем 6 раз построение звеньев ломаной
for _ in range(6):
    left(28)             # Поворот налево на 28 градусов
    forward(2 * scale)   # Вперёд на 2*scale (одно звено ломаной)
    left(28)             # Ещё один поворот налево на 28 градусов

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

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

update()  # Обновляем экран для отображения результата
done()    # Завершение работы (окно остаётся открытым)

Осталось посчитать количество линий между вершинами фигуры.

Решение Кумиром

Имеется алгоритм «Повтори 6 [Налево 28 Вперёд 2 Налево 28]». Команда «Налево 28» меняет направление Черепахи. «Вперёд 2» — это команда, которая создаёт звено ломанной. Она повторяется 6 раз в алгоритме, поэтому полученная ломанная будет содержать 6 звеньев.

Python:

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

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

m = 20  # Масштабирование
tracer(0) # Ускорение анимации
pd() # Опускаем хвост, чтобы Черепаха рисовала линии

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

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

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

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

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

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

Кумир:

Алгоритм, который вы представили, означает, что Черепаха двигается вперед на 9 единиц, затем поворачивает направо на 60 градусов. Это повторяется 1000 раз. Алгоритм поворачивает Черепаху на 60 градусов после каждого шага вперед. Поскольку полный круг равен 360 градусов, Черепаха совершит полный оборот после 6 шагов (360 градусов / 60 градусов на шаг = 6 шагов). Это значит, что за 6 шагов Черепаха сформирует шестиугольник.

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

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

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

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

# Основной алгоритм Черепахи: построение фигуры
for _ in range(4):          # Внешний цикл: повторяем 4 раза
    forward(6 * scale)       # Вперёд на 6 * scale
    right(135)               # Поворот направо на 135 градусов
    forward(6 * scale)       # Вперёд на 6 * scale

# Расставляем точки с целыми координатами для наглядности
up()  # Поднимаем хвост чтобы не рисовать лишние линии
for x in range(-10, 10):    # Перебор абсцисс точек
    for y in range(-10, 10): # Перебор ординат точек
        goto(x * scale, y * scale)  # Перемещаем черепаху на точку
        dot(3, "blue")              # Ставим точку синего цвета

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

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

Решение Кумиром

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