40 задач на Python

Глава 1: Задачи на логику и сообразительность

Условие:

Пастух охраняет стадо овец на лугу. На лугу также находятся волки. Луг можно представить в виде сетки (N \times M) клеток. Каждая клетка может быть либо пустой, либо содержать овцу, либо волка, либо пастуха.

Пастух может двигаться на одну клетку вверх, вниз, влево или вправо (но не по диагонали). Волки также могут двигаться на одну клетку в любом из четырех направлений. В каждом ходу все волки и пастух делают один шаг одновременно. Если волк попадает на клетку с овцой, он съедает овцу. Если волк попадает на клетку с пастухом, волк останавливается, и пастух побеждает в этом раунде.

Ваша задача – написать программу, которая моделирует передвижения пастуха и волков на лугу, чтобы пастух мог спасти как можно больше овец.

Входные данные:

– Размер луга (N \times M)

– Позиции овец, волков и пастуха на лугу

– Количество ходов, которые нужно смоделировать

Выходные данные:

– Позиции всех овец, волков и пастуха после заданного количества ходов

– Количество спасённых овец

Пример входных данных:

5 5

Пастух: 2 2

Овцы: 1 1, 3 3, 4 4

Волки: 0 0, 4 0

Ходы: 5

Пример выхода:

Пастух: 3 3

Овцы: 1 1, 3 3

Волки: 0 1, 4 1

Спасённые овцы: 2

Пояснение:

1. На вход подаются размеры луга (5x5), стартовые позиции пастуха (2,2), овец (1,1), (3,3), (4,4), волков (0,0), (4,0) и количество ходов (5).

2. Программа моделирует передвижение пастуха и волков в течение 5 ходов и выводит финальные позиции и количество спасённых овец.

Примечания:

– Считайте, что пастух и волки могут двигаться на одну клетку в одном направлении за один ход.

– Волки преследуют овец или пастуха, выбирая направление, которое минимизирует расстояние до ближайшей овцы или пастуха.

– Овцы остаются на месте.

– Если несколько волков попадают на одну клетку одновременно, один волк съедает овцу, остальные остаются на этой клетке.

Идея решения задачи о пастухе и волках

1. Представление поля

Представим луг в виде двумерного массива (списка списков). Каждая клетка может содержать одну из следующих сущностей:

– Пустая клетка (`.`)

– Пастух (`P`)

– Овца (`S`)

– Волк (`W`)

2. Чтение и обработка входных данных

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

3. Логика движения

– Пастух движется в направлении ближайшей овцы, чтобы защитить её.

– Можно использовать алгоритм поиска кратчайшего пути, например, алгоритм A* или простейший жадный алгоритм, чтобы определить направление движения пастуха к ближайшей овце.

– Волки движутся в направлении ближайшей овцы или пастуха.

– Для каждого волка определяем кратчайший путь до ближайшей цели и движемся в этом направлении.

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

4. Обработка столкновений

– Если волк попадает на клетку с овцой, овца съедается.

– Если волк попадает на клетку с пастухом, волк останавливается и считается побеждённым, и пастух побеждает в этом раунде.

5. Моделирование ходов

– Повторяем процесс движения и обновления поля для заданного количества ходов.

– Отслеживаем количество спасённых овец.

6. Вывод результатов

– По завершении всех ходов выводим конечные позиции пастуха, овец и волков.

– Выводим количество спасённых овец.

Пример реализации на Python

```python

from collections import deque

# Чтение входных данных

N, M = map(int, input().split())

pastukh = tuple(map(int, input().split()))

sheep_positions = [tuple(map(int, pos.split())) for pos in input().split(',')]

wolf_positions = [tuple(map(int, pos.split())) for pos in input().split(',')]

K = int(input())

# Инициализация поля

field = [['.' for _ in range(M)] for _ in range(N)]

field[pastukh[0]][pastukh[1]] = 'P'

for x, y in sheep_positions:

field[x][y] = 'S'

for x, y in wolf_positions:

field[x][y] = 'W'

# Вспомогательные функции

def is_valid(x, y):

return 0 <= x < N and 0 <= y < M

def bfs(start, goals):

queue = deque([start])

visited = set()

visited.add(start)

dist = {start: 0}

while queue:

x, y = queue.popleft()

if (x, y) in goals:

return dist[(x, y)], (x, y)

for dx, dy in [(-1, 0), (1, 0), (0, -1), (0, 1)]:

nx, ny = x + dx, y + dy

if is_valid(nx, ny) and (nx, ny) not in visited:

queue.append((nx, ny))

visited.add((nx, ny))

dist[(nx, ny)] = dist[(x, y)] + 1

return float('inf'), None

# Основная логика движения и моделирования

for _ in range(K):

# Движение пастуха

_, nearest_sheep = bfs(pastukh, sheep_positions)

if nearest_sheep:

px, py = pastukh

sx, sy = nearest_sheep

if px < sx: px += 1

elif px > sx: px -= 1

elif py < sy: py += 1

elif py > sy: py -= 1

pastukh = (px, py)

# Движение волков

new_wolf_positions = []

for wx, wy in wolf_positions:

_, target = bfs((wx, wy), sheep_positions + [pastukh])

if target:

tx, ty = target

if wx < tx: wx += 1

elif wx > tx: wx -= 1

elif wy < ty: wy += 1

elif wy > ty: wy -= 1

new_wolf_positions.append((wx, wy))

wolf_positions = new_wolf_positions

# Обновление поля и проверка столкновений

field = [['.' for _ in range(M)] for _ in range(N)]

field[pastukh[0]][pastukh[1]] = 'P'

new_sheep_positions = []

for x, y in sheep_positions:

if (x, y) not in wolf_positions:

field[x][y] = 'S'

new_sheep_positions.append((x, y))

sheep_positions = new_sheep_positions

for x, y in wolf_positions:

if field[x][y] == 'P':

field[x][y] = 'P'

else:

field[x][y] = 'W'

# Вывод результатов

print(f"Пастух: {pastukh[0]} {pastukh[1]}")

print("Овцы:", ', '.join(f"{x} {y}" for x, y in sheep_positions))

print("Волки:", ', '.join(f"{x} {y}" for x, y in wolf_positions))

print(f"Спасённые овцы: {len(sheep_positions)}")

```

Давайте разберем код более подробно на каждом этапе.

Чтение входных данных

```python

N, M = map(int, input().split())

pastukh = tuple(map(int, input().split()))

sheep_positions = [tuple(map(int, pos.split())) for pos in input().split(',')]

wolf_positions = [tuple(map(int, pos.split())) for pos in input().split(',')]

K = int(input())

```

1. `N, M = map(int, input().split())`: Считываем размеры луга (количество строк и столбцов).

2. `pastukh = tuple(map(int, input().split()))`: Считываем координаты пастуха и сохраняем их как кортеж.

3. `sheep_positions = [tuple(map(int, pos.split())) for pos in input().split(',')]`: Считываем позиции всех овец. Каждая позиция считывается как кортеж координат, и все позиции сохраняются в список.

4. `wolf_positions = [tuple(map(int, pos.split())) for pos in input().split(',')]`: Считываем позиции всех волков аналогично овцам.

5. `K = int(input())`: Считываем количество ходов.

Инициализация поля

```python

field = [['.' for _ in range(M)] for _ in range(N)]

field[pastukh[0]][pastukh[1]] = 'P'

for x, y in sheep_positions:

field[x][y] = 'S'

for x, y in wolf_positions:

field[x][y] = 'W'

1. `field = [['.' for _ in range(M)] for _ in range(N)]`: Создаем двумерный массив, представляющий луг, заполняя его пустыми клетками (`.`).

2. `field[pastukh[0]][pastukh[1]] = 'P'`: Размещаем пастуха на лугу в начальной позиции.

3. `for x, y in sheep_positions: field[x][y] = 'S'`: Размещаем овец на их начальных позициях.

4. `for x, y in wolf_positions: field[x][y] = 'W'`: Размещаем волков на их начальных позициях.

Вспомогательные функции

Проверка валидности координат

```python

def is_valid(x, y):

return 0 <= x < N and 0 <= y < M

```

1. `def is_valid(x, y): return 0 <= x < N and 0 <= y < M`: Функция проверяет, находятся ли координаты в пределах луга. Если координаты выходят за границы, возвращается False, иначе True.

Поиск кратчайшего пути (BFS)

```python

from collections import deque

def bfs(start, goals):

queue = deque([start])

visited = set()

visited.add(start)

dist = {start: 0}

while queue:

x, y = queue.popleft()

if (x, y) in goals:

return dist[(x, y)], (x, y)

for dx, dy in [(-1, 0), (1, 0), (0, -1), (0, 1)]:

nx, ny = x + dx, y + dy

if is_valid(nx, ny) and (nx, ny) not in visited:

queue.append((nx, ny))

visited.add((nx, ny))

dist[(nx, ny)] = dist[(x, y)] + 1

return float('inf'), None

```

1. `from collections import deque`: Импортируем deque для реализации очереди.

2. `def bfs(start, goals):`: Определяем функцию для поиска кратчайшего пути от `start` до ближайшей цели из `goals`.

3. `queue = deque([start])`: Инициализируем очередь с начальной позицией.

4. `visited = set()`: Создаем множество для отслеживания посещённых клеток.

5. `visited.add(start)`: Добавляем начальную позицию в множество посещённых.

6. `dist = {start: 0}`: Инициализируем словарь для хранения расстояний от начальной точки.

7. `while queue: …`: Запускаем цикл, пока есть элементы в очереди.

8. `x, y = queue.popleft()`: Извлекаем текущую позицию из очереди.

9. `if (x, y) in goals: …`: Если текущая позиция является целью, возвращаем расстояние и координаты.

10. `for dx, dy in [(-1, 0), (1, 0), (0, -1), (0, 1)]: …`: Перебираем все возможные направления движения (вверх, вниз, влево, вправо).

11. `nx, ny = x + dx, y + dy`: Вычисляем новые координаты.

12. `if is_valid(nx, ny) and (nx, ny) not in visited: …`: Если новые координаты валидны и не были посещены, добавляем их в очередь и множество посещённых, обновляем расстояние.

Основная логика движения и моделирования

Основной цикл для моделирования ходов

```python

for _ in range(K):

```

1. `for _ in range(K):`: Запускаем цикл для моделирования каждого хода.

Движение пастуха

```python

_, nearest_sheep = bfs(pastukh, sheep_positions)

if nearest_sheep:

px, py = pastukh

sx, sy = nearest_sheep

if px < sx: px += 1

elif px > sx: px -= 1

elif py < sy: py += 1

elif py > sy: py -= 1

pastukh = (px, py)

1. `_, nearest_sheep = bfs(pastukh, sheep_positions)`: Ищем ближайшую овцу для пастуха.

2. `if nearest_sheep: …`: Если найдена овца, определяем направление движения пастуха.

3. `px, py = pastukh`: Текущие координаты пастуха.

4. `sx, sy = nearest_sheep`: Координаты ближайшей овцы.

5. `if px < sx: px += 1 …`: Если пастух находится левее овцы, он движется вправо. Аналогично для других направлений.

6. `pastukh = (px, py)`: Обновляем координаты пастуха.

Движение волков

```python

new_wolf_positions = []

for wx, wy in wolf_positions:

_, target = bfs((wx, wy), sheep_positions + [pastukh])

if target:

tx, ty = target

if wx < tx: wx += 1

elif wx > tx: wx -= 1

elif wy < ty: wy += 1

elif wy > ty: wy -= 1

new_wolf_positions.append((wx, wy))

wolf_positions = new_wolf_positions

1. `new_wolf_positions = []`: Создаем список для обновленных позиций волков.

2. `for wx, wy in wolf_positions: …`: Перебираем текущие позиции всех волков.

3. `_, target = bfs((wx, wy), sheep_positions + [pastukh])`: Ищем ближайшую цель (овца или пастух) для волка.

4. `if target: …`: Если найдена цель, определяем направление движения волка.

5. `tx, ty = target`: Координаты ближайшей цели.

6. `if wx < tx: wx += 1 …`: Если волк находится левее цели, он движется вправо. Аналогично для других направлений.

7. `new_wolf_positions.append((wx, wy))`: Добавляем обновленные координаты волка в список.

8. `wolf_positions = new_wolf_positions`: Обновляем позиции волков.

Обновление поля и проверка столкновений

```python

field = [['.' for _ in range(M)] for _ in range(N)]

field[pastukh[0]][pastukh[1]] = 'P'

new_sheep_positions = []

for x, y in sheep_positions:

if (x, y) not in wolf_positions:

field[x][y] = 'S'

new_sheep_positions.append((x, y))

sheep_positions = new_sheep_positions

for x, y in wolf_positions:

if field[x][y] == 'P':

field[x][y] = 'P'

else:

field[x][y] = 'W'

1. `field = [['.' for _ in range(M)] for _ in range(N)]`: Пересоздаем поле, заполняя его пустыми клетками.

2. `field[pastukh[0]][pastukh[1]] = 'P'`: Обновляем позицию пастуха на поле.

3. `new_sheep_positions = []`: Создаем список для обновленных позиций овец.

4. `for x, y in sheep_positions: …`: Перебираем текущие позиции овец.

5. `if (x, y) not in wolf_positions: …`: Если овца не съедена волком, добавляем её в обновленное поле

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

Условие задачи: Даны координаты центров и радиусы двух кругов на плоскости. Необходимо определить, пересекаются ли эти круги.

Входные данные:

– Четыре вещественных числа: ( x_1, y_1, r_1, r_2 )

– ( x_1, y_1 ) – координаты центра первого круга.

– ( r_1 ) – радиус первого круга.

– ( x_2, y_2 ) – координаты центра второго круга.

– ( r_2 ) – радиус второго круга.

Выходные данные:

– Одно слово "YES", если круги пересекаются, и "NO" в противном случае.

Примеры:

Пример 1:

Входные данные: 0 0 5 3 0 0 3

Выходные данные: YES

Пример 2:

Входные данные: 0 0 2 6 0 0 3

Выходные данные: NO

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

1. Вычислим расстояние ( d ) между центрами кругов.

2. Если ( d ) меньше суммы радиусов ( r_1 ) и ( r_2 ) и больше разности радиусов ( |r_1 – r_2| ), то круги пересекаются.

3. Если ( d ) равно сумме радиусов, то круги касаются друг друга внешне.

4. Если ( d ) равно разности радиусов, то круги касаются друг друга внутренне.

5. Во всех других случаях круги не пересекаются.

Формула для вычисления расстояния между центрами кругов:

[ d = \sqrt{(x_2 – x_1)^2 + (y_2 – y_1)^2} \]

Псевдокод:

ввод x1, y1, r1, x2, y2, r2

вычислить d = sqrt((x2 – x1)^2 + (y2 – y1)^2)

если d <= r1 + r2 и d >= |r1 – r2| тогда

вывод "YES"

иначе

вывод "NO"

```

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

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

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

Реализация на Python:

```python

import math

# Чтение входных данных

x1, y1, r1 = map(float, input().split())

x2, y2, r2 = map(float, input().split())

# Вычисление расстояния между центрами кругов

d = math.sqrt((x2 – x1) ** 2 + (y2 – y1) ** 2)

# Проверка пересечения кругов

if d <= r1 + r2 and d >= abs(r1 – r2):

print("YES")

else:

print("NO")

```

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

Условие задачи: На улице расположены пять домов, пронумерованных от 1 до 5. Каждый дом занят каким-то жителем. Дома расположены вдоль прямой, и между некоторыми соседними домами есть заборы. Необходимо определить минимальное количество переездов, чтобы жители домов удовлетворили следующим условиям:

1. Житель дома 1 не должен жить с жителем дома 2.

2. Житель дома 2 не должен жить с жителем дома 3.

3. Житель дома 3 не должен жить с жителем дома 4.

4. Житель дома 4 не должен жить с жителем дома 5.

Каждый переезд стоит одну единицу. В начальный момент времени все жители уже живут в соответствии с условиями задачи.

Входные данные:

– Пять чисел от 1 до 5, представляющих номера домов, в которых в настоящее время живут жители.

Выходные данные:

– Одно целое число – минимальное количество переездов, которое необходимо совершить.

Примеры:

Пример 1:

Входные данные: 1 2 3 4 5

Выходные данные: 0

Пример 2:

Входные данные: 1 3 2 4 5

Выходные данные: 1

Решение:

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

Псевдокод:

ввод номера_домов

подсчет_переездов = 0

если номера_домов[0] == 1 и номера_домов[1] == 2, тогда подсчет_переездов += 1

если номера_домов[1] == 2 и номера_домов[2] == 3, тогда подсчет_переездов += 1

если номера_домов[2] == 3 и номера_домов[3] == 4, тогда подсчет_переездов += 1

если номера_домов[3] == 4 и номера_домов[4] == 5, тогда подсчет_переездов += 1

вывод подсчет_переездов

Реализация на Python:

```python

# Чтение входных данных

house_numbers = list(map(int, input().split()))

# Подсчет минимального количества переездов

moves_count = 0

for i in range(4):

if house_numbers[i] == i + 1 and house_numbers[i + 1] == i + 2:

moves_count += 1

# Вывод результата

print(moves_count)

```

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

Условие задачи: Дана последовательность чисел. Необходимо определить, является ли эта последовательность логической цепочкой. Логическая цепочка – это последовательность чисел, где каждое последующее число в последовательности является результатом выполнения определенной логической операции над предыдущим числом.

Входные данные:

– Последовательность целых чисел, разделенных пробелами.

Выходные данные:

– Если последовательность является логической цепочкой, вывести "YES". Иначе вывести "NO".

Примеры:

Пример 1:

Входные данные: 1 3 6 10 15

Выходные данные: YES

Пример 2:

Входные данные: 2 4 7 12 18

Выходные данные: NO

Решение:

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

Псевдокод:

ввод последовательности_чисел

для каждого i от 1 до длины(последовательности_чисел) – 1:

если последовательность_чисел[i] != последовательность_чисел[i – 1] + i:

вывод "NO"

завершить выполнение

вывод "YES"

Реализация на Python:

```python

# Чтение входных данных

sequence = list(map(int, input().split()))

# Проверка на логическую цепочку

for i in range(1, len(sequence)):

if sequence[i] != sequence[i – 1] + i:

print("NO")

break

else:

print("YES")

```

Эта задача иллюстрирует способ проверки последовательности чисел на соответствие логической цепочке. Мы можем пройтись по всей последовательности и проверить выполнение условия для каждой пары чисел. Если условие не выполняется хотя бы для одной пары чисел, мы можем сразу вывести "NO".

Условие задачи: Группа исследователей отправилась исследовать древний лабиринт, о котором ходят легенды. Они обнаружили, что лабиринт состоит из комнат, соединенных таинственными проходами. Каждая комната имеет уникальный номер, а проходы между комнатами двунаправленные. Они обнаружили, что вход в лабиринт находится в комнате с номером 1, а выход – в комнате с номером N.

Каждый проход имеет определенную стоимость прохождения, которая может быть как положительной, так и отрицательной. Исследователи хотят найти путь с минимальной суммарной стоимостью прохождения из комнаты 1 в комнату N.

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

Входные данные:

– Первая строка содержит два целых числа: N (2 <= N <= 10^5) – количество комнат, и M (1 <= M <= 2*10^5) – количество проходов между комнатами.

– Следующие M строк содержат описание проходов. Каждая строка содержит три целых числа: a, b и w (1 <= a, b <= N, -10^3 <= w <= 10^3), где a и b – номера комнат, соединенных проходом, а w – стоимость прохождения этого прохода.

Выходные данные:

– Одно целое число – минимальная суммарная стоимость прохождения из комнаты 1 в комнату N. Если путь не существует, вывести -1.

Примеры:

Пример 1:

Входные данные:

5 7

1 2 4

1 3 2

2 3 5

2 4 10

3 4 -3

3 5 3

4 5 4

Выходные данные: 6

Пример 2:

Входные данные:

3 2

1 2 1

2 3 1

Выходные данные: 2

Решение:

Для нахождения минимальной суммарной стоимости прохождения лабиринта из комнаты 1 в комнату N мы можем воспользоваться алгоритмом поиска кратчайшего пути в графе. Мы будем использовать алгоритм Дейкстры для нахождения кратчайшего пути от вершины 1 до вершины N.

Псевдокод:

ввод N, M

инициализация графа G

для каждого i от 1 до M:

ввод a, b, w

добавить ребро (a, b) со стоимостью w в граф G

вызвать алгоритм Дейкстры для поиска кратчайшего пути от вершины 1 до вершины N в графе G

вывод результат

Реализация на Python:

```python

import heapq

def dijkstra(graph, start, end):

pq = [(0, start)]

distances = {v: float('inf') for v in graph}

distances[start] = 0

while pq:

dist, node = heapq.heappop(pq)

if node == end:

return dist

if dist > distances[node]:

continue

for neighbor, weight in graph[node]:

if (new_dist := dist + weight) < distances[neighbor]:

distances[neighbor] = new_dist

heapq.heappush(pq, (new_dist, neighbor))

return -1

# Чтение входных данных

N, M = map(int, input().split())

graph = {i: [] for i in range(1, N + 1)}

for _ in range(M):

a, b, w = map(int, input().split())

graph[a].append((b, w))

graph[b].append((a, w))

# Вызов алгоритма Дейкстры для нахождения кратчайшего пути

min_cost = dijkstra(graph, 1, N)

# Вывод результата

print(min_cost)

```

Эта задача демонстрирует применение алгоритма Дейкстры для нахождения минимального пути в графе. Мы строим граф, где вершинами являются комнаты, а ребрами – проходы между комнатами с их стоимостью прохождения. Затем мы вызываем алгоритм Дейкстры для нахождения кратчайшего пути от комнаты 1 до комнаты N.