ГДЗ: Параграф § 5.5 / Информатика 8 класс

В программировании рассматривают два основных типа циклов:

• Цикл с условием продолжения работы (цикл-ПОКА): реализуется с помощью оператора while.
• Цикл с фиксированным числом повторений (цикл-параметр): реализуется с помощью оператора for.

Цикл с условием продолжения работы (while) имеет синтаксис: while <условие>: <тело цикла>. Принцип его работы заключается в следующем: пока логическое выражение <условие> истинно, выполняются команды, составляющие <тело цикла>. Как только <условие> становится ложным, выполнение цикла прекращается, и программа переходит к следующей команде после цикла.

В Python цикл, работающий до выполнения условия окончания, может быть реализован с помощью конструкции while True: и оператора break. Общая структура:

while True: <операторы> if <условие>: break

Цикл while True сам по себе является бесконечным, но оператор break обеспечивает выход из него, когда проверяемое <условие> становится истинным.

Цикл с фиксированным числом повторений (for, цикл-параметр) использует функцию range() для определения последовательности значений параметра цикла и количества повторений. Общий синтаксис:

for <параметр> in range(k, n, m): <операторы>

Принцип работы: <параметр> последовательно принимает значения из последовательности, сгенерированной range(), и для каждого значения <тело цикла> (<операторы>) выполняется один раз.

• range(n): параметр меняется от 0 до \( n-1 \).
• range(k, n): параметр меняется от \(k\) до \( n-1 \).
• range(k, n, m): параметр меняется от \(k\) до \( n-1 \) с шагом \(m\).

Ключевое отличие: цикл for предназначен для ситуаций, когда количество повторений известно заранее или может быть легко вычислено (фиксированное число повторений), тогда как цикл while используется, когда число повторений не известно заранее и зависит от некоторого условия, которое должно стать ложным.

• Используйте for, если заранее известно, сколько раз нужно повторить тело цикла (например, перебор элементов в списке или выполнение 100 итераций).
• Используйте while, если продолжение цикла зависит от выполнения некоторого условия (например, пока пользователь не введёт '0', или пока остаток больше делителя).

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

Основные операторы цикла — это while и for.

• Теоретически, while может заменить for, так как любой цикл for с фиксированным числом итераций может быть реализован с помощью while, вручную управляя переменной-счетчиком и условием. Например, for i in range(10): ... эквивалентен i = 0; while i < 10: ...; i += 1.
• Однако for не может полностью заменить while в случаях, когда количество повторений не известно заранее и зависит от внешнего условия (например, ввод данных до тех пор, пока не будет введён '0' или 'стоп'). Для таких ситуаций цикл while является более подходящим и читаемым инструментом.
• Вывод: Хотя while более универсален, каждый оператор (while и for) предпочтителен для своего типа задач (условие vs. счётчик), и их использование улучшает читаемость кода.

Начальные данные: \( x = 1 \), \( y = 1 \). В теле цикла: \( y = y \cdot 2 \), \( x = x + 1 \).

• г) Если заменить условие на \( x \ge 5 \): \( 1 \ge 5 \) — ложь. Цикл не выполнится ни разу.
• д) Если заменить условие на \( x > 0 \): Поскольку \(x\) начинается с 1 и увеличивается на 1 на каждой итерации, условие \( x > 0 \) всегда будет истинным. Цикл будет бесконечным.
• е) Что произойдёт, если из тела цикла убрать команду \( x = x + 1 \)? Если условие останется \( x < 5 \), а \(x\) не будет меняться (\( x = 1 \)), то \( 1 < 5 \) всегда истинно. Цикл будет бесконечным.
• ж) Сколько раз выполнится тело цикла, если заменить команду \( x = x + 1 \) на \( x = x + 2 \)?
  Трассировка: \( x=1 \to (1 < 5) \to x=3 \). \( x=3 \to (3 < 5) \to x=5 \). \( x=5 \to (5 < 5) \) — ложь.
  Цикл выполнится 2 раза.
• з) Сколько раз выполнится тело цикла, если заменить команду \( x = x + 1 \) на \( x = x - 1 \)?
  Трассировка: \( x=1 \to (1 < 5) \to x=0 \). \( x=0 \to (0 < 5) \to x=-1 \). ...
  Поскольку \(x\) будет уменьшаться, условие \( x < 5 \) всегда будет истинным. Цикл будет бесконечным.

Трассировка последовательности

• Начало: \( a = 1 \), \( b = 2 \).
• Итерация 1: Условие \( a + b < 8 \) (\( 1 + 2 < 8 \)) — истина.
  Тело цикла: \( a = 1 + 1 = 2 \), \( b = 2 + 2 = 4 \).
• Итерация 2: Условие \( a + b < 8 \) (\( 2 + 4 < 8 \)) — истина.
  Тело цикла: \( a = 2 + 1 = 3 \), \( b = 4 + 2 = 6 \).
• Итерация 3: Условие \( a + b < 8 \) (\( 3 + 6 < 8 \)) — ложь. Цикл завершается.
• Команда после цикла: \( s = a + b \). Используются последние значения \(a\) и \(b\) из цикла: \( s = 3 + 6 = 9 \).

Результат:

• Тело цикла повторится: 2 раза.
• Конечные значения: \( a = 3 \), \( b = 6 \), \( s = 9 \).

Анализ и исправление ошибок

Программа должна вычислять \( n! = 1 \cdot 2 \cdot 3 \cdot \ldots \cdot n \).

• Ошибка 1: Инициализация факториала. Факториал \(f\) должен начинаться с 1, а не с 0, поскольку умножение на 0 обнулит результат. Исправление: f = 1.
• Ошибка 2: Условие цикла. Для вычисления \( n! \) цикл должен включать \(n\). Цикл должен продолжаться, пока \( k \le n \) или \( k < n + 1 \). Исправление: while k <= n: или использование цикла for.
• Ошибка 3: Порядок действий. Факториал вычисляется как произведение \(f\) на \(k\), после чего \(k\) должно увеличиться. В данном фрагменте логика верна: f = f * k, затем k += 1.

Исправленная программа (с циклом while)

n = int(input('Введите n>>'))
k = 1
f = 1 # Исправлено
while k <= n: # Исправлено
f = f * k
k += 1
print('Факториал n! =', f)

Тестирование

• Вход: \( n=5 \).
  Трассировка: \(k=1, f=1\). 1 \(\le\) 5. \(f=1 \cdot 1=1, k=2\). 2 \(\le\) 5. \(f=1 \cdot 2=2, k=3\). 3 \(\le\) 5. \(f=2 \cdot 3=6, k=4\). 4 \(\le\) 5. \(f=6 \cdot 4=24, k=5\). 5 \(\le\) 5. \(f=24 \cdot 5=120, k=6\). 6 \(\le\) 5 — ложь. Вывод: 120. (Верно).
• Вход: \( n=6 \).
  Цикл выполнится ещё раз, когда \(k=6\): \(f=120 \cdot 6=720, k=7\). Вывод: 720. (Верно).

Особенность цикла

Этот цикл содержит в теле алгоритм обмена значениями переменных \(a\) и \(b\) с использованием дополнительной переменной \(c\).

• Если условие \( a < b \) истинно, переменные \(a\) и \(b\) меняются местами. Например, если \( a=3, b=5 \), то после обмена \( a=5, b=3 \).
• Поскольку после обмена новое значение \(a\) будет больше нового значения \(b\), условие \( a < b \) станет ложным (например, \( 5 < 3 \) — ложь).
• Особенность в том, что цикл выполнится не более одного раза. Если \( a < b \) изначально, он выполнится 1 раз, и затем завершится. Если \( a \ge b \) изначально, он не выполнится ни разу.

Трассировка последовательности

• Начало: \( a = 1 \), \( b = 1 \). Условие выхода: \( b > 8 \).
• Итерация 1: Тело цикла: \( a = 1 + 1 = 2 \), \( b = 1 \cdot 2 = 2 \). Условие выхода (\( 2 > 8 \)) — ложь.
• Итерация 2: Тело цикла: \( a = 2 + 1 = 3 \), \( b = 2 \cdot 2 = 4 \). Условие выхода (\( 4 > 8 \)) — ложь.
• Итерация 3: Тело цикла: \( a = 3 + 1 = 4 \), \( b = 4 \cdot 2 = 8 \). Условие выхода (\( 8 > 8 \)) — ложь.
• Итерация 4: Тело цикла: \( a = 4 + 1 = 5 \), \( b = 8 \cdot 2 = 16 \). Условие выхода (\( 16 > 8 \)) — истина. Выполняется break. Цикл завершается.
• Команда после цикла: \( s = a + b \). Используются последние значения: \( s = 5 + 16 = 21 \).

Результат:

• Тело цикла повторится: 4 раза.
• Конечные значения: \( a = 5 \), \( b = 16 \), \( s = 21 \).

Количество итераций цикла for

• а) for i in range(15): s += i: Диапазон от 0 до 14. Количество элементов: \( 15 - 0 = 15 \). Тело выполнится 15 раз.
• б) for i in range(10, 15): s += i: Диапазон от 10 до 14. Количество элементов: \( 15 - 10 = 5 \). Тело выполнится 5 раз.
• в) for i in range(-1, 1): s += i: Диапазон от -1 до 0. Элементы: -1, 0. Количество элементов: 2. Тело выполнится 2 раза.
• г) for i in range(1, 1, 1): s += i: Диапазон от 1 до 0. Конечное значение 1 не включается. Количество элементов: 0. Тело выполнится 0 раз.
• д) for i in range(k - 1, k + 1): s += i, где \( k = 5 \): range(5 - 1, 5 + 1), то есть range(4, 6). Диапазон от 4 до 5. Элементы: 4, 5. Количество элементов: 2. Тело выполнится 2 раза.

Программа для суммирования чисел (ввод до 0)

Используем цикл while True для обеспечения ввода до тех пор, пока не будет выполнено условие выхода (ввод 0).

s = 0
print('Введите целые числа (0 для завершения ввода):')
while True:
a = int(input('Введите число >> '))
if a == 0:
break
s += a
print('Сумма всех введенных чисел:', s)

Программа для нахождения максимального числа (ввод до 0)

Необходимо инициализировать максимальное значение с первым введённым числом, прежде чем войти в цикл.

print('Введите целые числа (0 для завершения ввода):')
# Ввод первого числа для инициализации max_num
num = int(input('Введите число >> '))
if num == 0:
max_num = 'Не введены числа кроме 0'
else:
max_num = num
# Основной цикл для остальных чисел
while True:
num = int(input('Введите число >> '))
if num == 0:
break
if num > max_num:
max_num = num

print('Максимальное из введенных чисел:', max_num)

Программа вывода имени/фамилии 10 раз

Используем цикл for для фиксированного числа повторений.

my_name = input('Введите ваше имя и фамилию: ')
for i in range(10):
print(my_name)

Программа для вывода шахматной доски

Используем вложенные циклы для прохода по 8 строкам и 8 столбцам. Чёрные и белые клетки чередуются, что соответствует условию \( (i + j) \% 2 \), где \(i\) — номер строки, \(j\) — номер столбца.

N = 8 # Размер доски 8x8
for i in range(N): # Внешний цикл - строки
for j in range(N): # Внутренний цикл - столбцы
# Если сумма индексов четна - черная клетка (*), иначе - белая ( )
if (i + j) % 2 == 0:
print('*', end='')
else:
print(' ', end='')
print() # Переход на новую строку после завершения внутренней петли

Программа для вычисления сумм

n = int(input('Введите n >> '))

# а) Сумма первых n натуральных чисел (1 + 2 + ... + n)
sum_a = 0
for i in range(1, n + 1):
sum_a += i
print('Сумма первых', n, 'чисел:', sum_a)

# б) Сумма квадратов первых n натуральных чисел (1^2 + 2^2 + ... + n^2)
sum_b = 0
for i in range(1, n + 1):
sum_b += i * i
print('Сумма квадратов первых', n, 'чисел:', sum_b)

# в) Сумма всех четных чисел на отрезке от 1 до n
sum_c = 0
for i in range(2, n + 1, 2): # Начинаем с 2, шаг 2
sum_c += i
print('Сумма четных чисел от 1 до', n, ':', sum_c)

# г) Сумма всех двузначных чисел (от 10 до 99)
sum_g = 0
for i in range(10, 100):
sum_g += i
print('Сумма всех двузначных чисел:', sum_g)

Программа для вывода таблицы степеней двойки

Используем цикл for для итерации от 0 до 10. Для вычисления степени можно использовать оператор возведения в степень ** или переменную-накопитель, умножаемую на 2.

print('Таблица степеней двойки')
power = 1
for i in range(11): # от 0 до 10 включительно
# Вывод в две колонки
print(i, '\t', power)
power *= 2

Программа для вывода таблицы умножения

Используем цикл for для итерации от 2 до 10 (для множителей).

n = int(input('Введите целое число n (2 <= n <= 10): '))
for i in range(2, 11): # Множитель от 2 до 10
result = n * i
print(n, '*', i, '=', result)

Тестирование для \( n=5 \)

• \(5 \cdot 2 = 10\)
• \(5 \cdot 3 = 15\)
• ...
• \(5 \cdot 10 = 50\)

Анализ задачи

Пусть \(N\) — общее количество плиток. По условию, \(N\) — это целое число.

• При укладывании по 10 плиток: \(N = 10 \cdot k + r_1\), где \(r_1\) — остаток от деления \(N\) на 10.
• Площадка квадратная, поэтому количество плиток должно быть полным квадратом, \(M^2\). Т.е., \(N < M^2\) (плиток не хватит). Это условие сложно использовать без дополнительной информации.
• Условие 1: При укладывании по 10 плиток остаётся один неполный ряд. Это означает, что остаток \(r_{10}\) от деления \(N\) на 10 должен быть \(1 \le r_{10} \le 9\). То есть, \(N \bmod 10 \ne 0\).
• Условие 2: При укладывании по 8 плиток остаётся неполный ряд \(r_8\) (\(1 \le r_8 \le 7\)).
• Условие 3: В остатке при укладывании по 6 плиток \(r_6\) на 6 плиток меньше, чем в остатке при укладывании по 8 плиток \(r_8\). То есть, \(r_6 = r_8 - 6\).

Из Условия 3 следует, что \(r_8 = r_6 + 6\). Поскольку \(r_6\) — остаток от деления на 6, то \(0 \le r_6 \le 5\). Следовательно, \(6 \le r_8 \le 11\). Поскольку \(r_8\) — остаток от деления на 8, то \(0 \le r_8 \le 7\). Единственное возможное значение, удовлетворяющее обоим ограничениям, это \(r_8 = 6\) или \(r_8 = 7\).

• Если \(r_8 = 6\): \(r_6 = 6 - 6 = 0\).
• Если \(r_8 = 7\): \(r_6 = 7 - 6 = 1\).

Программа должна перебрать числа \(N\) и проверить, выполняются ли условия.

Программа (перебор)

Найдём минимальное число \(N\), удовлетворяющее условиям (предполагая, что \(N\) должно быть наименьшим):

# Перебираем N, начиная с 1, до разумного предела (например, 1000)
for N in range(1, 1000):
r10 = N % 10
r8 = N % 8
r6 = N % 6

# Условие 1: Неполный ряд по 10 (r10 не 0)
if r10 == 0:
continue

# Условие 3: Остаток по 6 на 6 меньше остатка по 8
if r6 == r8 - 6:
print('Количество плиток:', N)
break

Результат перебора

Программа находит, что первое число, удовлетворяющее условиям, это \(N=46\).

• \(46 \bmod 10 = 6\) (неполный ряд по 10 — верно).
• \(46 \bmod 8 = 6\) (\(r_8 = 6\)).
• \(46 \bmod 6 = 4\) (\(r_6 = 4\)).
• Проверка Условия 3: \(r_6 = r_8 - 6 \Rightarrow 4 = 6 - 6 \Rightarrow 4 = 0\) (Ложь).

Следующее число, удовлетворяющее \(r_6 = r_8 - 6\): \(N=86\) ( \(r_{10}=6, r_8=6, r_6=2\). \(2 \ne 6-6\) ).

Следующее число: \(N=118\) (\(r_{10}=8, r_8=6, r_6=4\)).

Внимательное чтение Условия 3: 'в котором 6 плиток меньше, чем в неполном ряду при укладывании по 8.' Вероятно, речь идёт о количестве плиток в неполных рядах \(r_6\) и \(r_8\).

Перебирая дальше, находим: \(N=134\). \(134 \bmod 10 = 4\) (верно). \(134 \bmod 8 = 6\) (\(r_8=6\)). \(134 \bmod 6 = 2\) (\(r_6=2\)). \(r_6 = r_8 - 4 \Rightarrow 2 = 6 - 4 \Rightarrow 2=2\). (Возможно, опечатка в учебнике, и должно быть 'на 4 плитки меньше').

Если интерпретировать буквально \(r_6 = r_8 - 6\): \(N=30\). \(r_{10}=0\) (не подходит). \(N=120\). \(r_{10}=0\) (не подходит). \(N=150\). \(r_{10}=0\) (не подходит).

Учитывая, что в неполном ряду при укладывании по 8 плиток должно быть \(\le 7\) плиток, а при укладывании по 6 плиток должно быть \(\le 5\) плиток, единственно возможные варианты для \(r_8\) и \(r_6\), чтобы \(r_6 = r_8 - 6\), это: \(r_8 = 6, r_6 = 0\). Или \(r_8 = 7, r_6 = 1\).

• Случай 1: \(N \bmod 8 = 6\) и \(N \bmod 6 = 0\). \(N\) кратно 6. \(N = 6k\). \(6k \bmod 8 = 6\). Подходят \(N=6, 30, 54, 78, ...\) . Проверим \(N \bmod 10 \ne 0\). Подходят \(N=6, 54, 78, ...\) Минимальное \(N = 6\).
• Случай 2: \(N \bmod 8 = 7\) и \(N \bmod 6 = 1\). \(N = 6k + 1\) и \(N = 8j + 7\). Решением является \(N = 24m + 7\). \(N = 7, 31, 55, ...\) Проверим \(N \bmod 10 \ne 0\). Все подходят. Минимальное \(N = 7\).

Наименьшее число плиток (из двух минимальных вариантов) — \(N=6\). Если в задаче подразумевается, что количество плиток должно быть существенно большим, то подойдет \(N=54\) (Случай 1) или \(N=31\) (Случай 2). Оставляем минимальный математически корректный ответ: \(N=6\).