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

Решение Python:

from turtle import *  # Модуль для работы с исполнителем Черепаха
# Начальная позиция чертежника
x, y = 0, 0
# Масштаб для удобства отображения
m = 40
tracer(0)
penup()
goto(x * m, y * m)  # Переход в начальную точку
pendown()
# Алгоритм
for i in range(20):
    # Сместиться на (4, 3)
    new_x = x + 4
    new_y = y + 3
    goto(new_x * m, new_y * m)
    # Обновление текущих координат
    x, y = new_x, new_y
    # Сместиться на (-4, -3)
    new_x = x - 4
    new_y = y - 3
    goto(new_x * m, new_y * m)
    # Обновление текущих координат
    x, y = new_x, new_y
    # Сместиться на (-12, -5)
    new_x = x - 12
    new_y = y - 5
    goto(new_x * m, new_y * m)
    # Обновление текущих координат
    x, y = new_x, new_y
    # Сместиться на (12, 5)
    new_x = x + 12
    new_y = y + 5
    goto(new_x * m, new_y * m)
    # Обновление текущих координат
    x, y = new_x, new_y
pu()
for x in range(-25, 25):
    for y in range(-30, 50):
        goto(x*m, y*m)
        dot(3)
done()

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

После анализа алгоритма получаем следующий рисунок.

В одной такой фигуре ровно точек.

У нас таких фигур . Также точки находится на пересечении фигур. Получаем ответ .

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

from turtle import *
left(90)

tracer(0)
k = 5

seth(90)
right(180)
forward(3 * k)
right(90)
forward(48 * k)
right(90)
forward(3 * k)

for i in range(6):
    seth(90)
    circle(-4 * k, 180)
penup()

for x in range(0, -50, -1):
    for y in range(-5, 10):
        goto(x * k, y * k)
        dot(2)
done()

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

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

После анализа алгоритма получаем следующий рисунок.

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

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

from turtle import *
left(90)

tracer(0)
k = 10

for i in range(7):
    seth(0)
    circle(4 * k, 180)
    seth(90)
    circle(4 * k, 180)
    seth(180)
    circle(4 * k, 180)
    seth(270)
    circle(4 * k, 180)
penup()

for x in range(-15, 5):
    for y in range(-5, 15):
        goto(x * k, y * k)
        dot(2)
done()

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

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

После анализа алгоритма получаем следующий рисунок.

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

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

from turtle import *
from math import sqrt
left(90)

tracer(0)
k = 10

left(45)
forward(6 * sqrt(2) * k)
right(45)

for i in range(2):
    seth(90)
    circle(-3 * k, 180)

right(45)
forward(6 * sqrt(2) * k)
penup()

for x in range(-10, 10):
    for y in range(-5, 15):
        goto(x * k, y * k)
        dot(2)
done()

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

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

После анализа алгоритма получаем следующий рисунок.

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

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

from turtle import *

tracer(0)
k = 10

forward(7 * k)
right(90)
forward(3 * k)
left(90)
forward(3 * k)

circle(-1 * k, 180)
forward(2 * k)
left(90)
forward(3 * k)

for i in range(4):
    seth(270)
    circle(-1 * k, 180)
forward(8 * k)
penup()

for x in range(-5, 15):
    for y in range(-10, 10):
        goto(x * k, y * k)
        dot(2)
done()

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

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

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

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

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

# Основной алгоритм построения фигуры
for _ in range(5):           # Внешний цикл: повторяем 5 раз
    for _ in range(3):       # Внутренний цикл: повторяем 3 раза
        forward(4 * scale)   # Вперёд на 4 * scale
        left(90)             # Налево на 90 градусов
    forward(2 * scale)       # Вперёд на 2 * scale

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

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

Осталось посчитать количество квадратов на полученной фигуре – 9 маленьких, 4 средних и 1 большой, итого 14.

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

Запустим алгоритм, в результате получается рисунок:

Остается подсчитать количество квадратов аналогично решению на Python.

Python

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

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

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

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

# Основной алгоритм Черепахи для построения линии
for i in range(6):       # Повторить 6 раз
    left(120)            # Поворот налево на 120°
    forward(6 * scale)   # Движение вперёд на 6 с учётом масштаба

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

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

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

Кумир

Откроем программу "Кумир-Стандарт выберем в качестве исполнителя Черепаху и впишем необходимый алгоритм. Запустив алгоритм, получим, что получившаяся фигура - треугольник. Осталось посчитать количество внутренних точек, которое равно 13. На скриншоте они выделены красным.

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

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

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

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

# Основной алгоритм построения фигуры
for _ in range(36):        # Внешний цикл: повторяем 36 раз
    right(60)              # Поворот направо на 60 градусов
    forward(1 * scale)     # Вперёд на 1 * scale
    right(60)              # Поворот направо на 60 градусов
    forward(1 * scale)     # Вперёд на 1 * scale
    right(270)             # Поворот направо на 270 градусов (эквивалентно налево на 90)

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

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

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

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

Откроем программу «Кумир-Стандарт», выберем в качестве исполнителя Черепаху и впишем необходимый алгоритм. Запустив алгоритм, получим фигуру. Осталось посчитать количество углов — 24.

Python

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

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

tracer(50)  # Ускорение анимации движения Черепахи
screensize(1000, 1000)  # Добавление ползунков для прокрутки
scale = 50  # Масштаб рисунка (вместо x пикселей будет x*scale пикселей)

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

# Основной алгоритм Черепахи для построения линии
for i in range(7):       # Повторяем 7 раз
    right(90)             # Поворот направо на 90°
    forward(4 * scale)    # Движение вперёд на 4 (с учётом масштаба)
    for j in range(2):    # Вложенный цикл, повторяем 2 раза
        left(90)          # Поворот налево на 90°
        forward(4*scale)  # Движение вперёд на 4

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

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

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

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

Кумир

После запуска программы получим следующую фигуру:

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

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

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

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

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

left(90)  # Поворот на 90 градусов влево

# Рисуем первую фигуру (3 раза)
for _ in range(3):           # Повторяем алгоритм 3 раза
    forward(12 * scale)      # Вперед на 12 (с учётом масштаба)
    right(90)                # Поворот направо на 90°
    forward(6 * scale)       # Вперед на 6
    right(90)                # Поворот направо на 90°

up()                         # Поднимаем хвост для перемещения без рисования
forward(5 * scale)           # Перемещаемся вперёд на 5
right(90)                    # Направо на 90°
forward(1 * scale)           # Вперед на 1
left(90)                     # Поворачиваем налево на 90°
down()                       # Опускаем хвост для рисования

# Рисуем вторую фигуру (5 раз)
for _ in range(5):           # Повторяем алгоритм 5 раз
    forward(10 * scale)      # Вперед на 10
    right(90)                # Направо на 90°
    forward(14 * scale)      # Вперед на 14
    right(90)                # Направо на 90°

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

# Ставим точки в диапазоне от -20 до 20
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()     # Завершение работы программы

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

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

Откроем программу «Кумир-Стандарт» и запишем данный алгоритм. При этом в качестве инструмента необходимо прописать «использовать Черепаха». Запустив программу, получим следующий чертёж (красным выделена фигура, полученная в результате пересечения двух прямоугольников):

Как видно из рисунка, высота полученного прямоугольника равна 7, длина — 5. Значит, его площадь равна .

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

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

from turtle import *

tracer(50) # Ускорение анимации (50 — пропуск 50 кадров для быстрой отрисовки)
scale = 60  # Масштаб для увеличения видимости рисунка

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

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

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

down() # Опустить "хвост" (если нужно продолжить рисование)

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

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

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

После запуска программы получим следующую фигуру:

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

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

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

from turtle import *

tracer(0)  # Ускорение анимации
scale = 20  # Масштаб рисунка
left(90)  # Поворот на 90 градусов влево

# Рисуем квадрат (4 стороны)
for _ in range(4):
    forward(12 * scale)  # Вперед на 12
    right(90)            # Направо на 90

# Рисуем треугольник (3 стороны)
for _ in range(3):
    forward(12 * scale)  # Вперед на 12
    right(120)           # Направо на 120

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

# Ставим точки в диапазоне от -20 до 20
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()     # Завершение программы

Получаем рисунок:

Нам нужно найти количество точек внутри квадрата и одновременно вне треугольника. Аккуратно считаем их и получаем общее количество – 65.

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

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

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

from turtle import *

tracer(0)  # Ускорение анимации
scale = 20  # Масштаб рисунка
left(90)  # Поворот на 90 градусов влево
dot(5, "red") # Начальное положение Черепахи

# Рисуем фигуру (9 линий)
for _ in range(9):
    forward(10 * scale)  # Вперед на 10
    right(72)            # Направо на 72
dot(5, "green") # Конечное положение Черепахи
up()  # Поднимаем хвост

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

update()  # Обновление экрана
done()     # Завершение программы

Получаем рисунок:

По теореме Пифагора найдем расстояние как квадратный корень суммы квадратов катетов:

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

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

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

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

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

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

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

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

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(7):       # Повторяем 7 раз
    forward(6*m)         # Движение вперёд на 6 (с учётом масштаба)
    right(60)            # Поворот направо на 60°

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

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

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

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

 

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

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

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

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

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

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

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

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

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

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

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

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

 

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

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

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

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

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

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

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

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

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

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

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

 

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

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

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

Условие:

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

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

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

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

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

# Основной алгоритм Черепахи
for i in range(9):   # Повторяем 9 раз для построения линии
    forward(2*m)     # Двигаемся вперёд на 2 единицы (с учётом масштаба)
    right(45)        # Поворот направо на 45°
    forward(2*m)     # Ещё одно движение вперёд на 2 единицы
    left(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() # Завершение работы (окно остаётся открытым)

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

 

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

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

Заметим, что голова черепахи направлена вдоль положительной оси абсцисс, поэтому до начала программы повернем голову черепахи на 90 градусов вправо.

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

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

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

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

# Основной алгоритм Черепахи для построения линий
for _ in range(20):     # Повторяем 20 раз
    right(225)           # Поворот направо на 225°
    forward(7 * scale)   # Движение вперёд на 7 единиц масштаба

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()     # Завершение работы (окно остаётся открытым)

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

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

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

Заметим, что голова черепахи направлена вдоль положительной оси абсцисс, поэтому до начала программы повернем голову черепахи на 90 градусов вправо.

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

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

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

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

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

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

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

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

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

Заметим, что на протяжении всего маршрута Черепаха всегда выполняла движение вперёд на одинаковое расстояние, значит все треугольники - и маленькие, и большой - имеют стороны равной длины. Значит, в этой фигуре 4 + 1 = 5 равносторонних треугольников.

 

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

Переписываем алгоритм в среду программирования Кумир, запускаем черепашку и внимательно считаем получившиеся фигуры. Большой треугольник образуют 4 маленьких равносторонних треугольника, поэтому в этой фигуре: 4 + 1 = 5 равносторонних треугольников.