Kitobni o'qish: «Решаем задачи Python»

Shrift:

Логическое мышление и базовые конструкции Python

1. Задача о числе Пи: Используя метод Монте-Карло, приблизить число Пи.

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

Идея метода: Представим, что у нас есть круг с радиусом 1, вписанный в квадрат со стороной 2. Площадь круга равна π, а площадь квадрата равна 4. Если мы случайным образом генерируем точки внутри квадрата, то вероятность попадания точки внутрь круга равна отношению площади круга к площади квадрата, то есть π/4. Зная это, мы можем использовать метод Монте-Карло для оценки числа π.

Шаги решения:

1. Создание квадрата со стороной 2 и вписанного в него круга с радиусом 1.

2. Генерация случайных точек внутри квадрата.

3. Подсчет количества точек, попавших внутрь круга.

4. Оценка числа π как отношение числа точек, попавших внутрь круга, к общему числу сгенерированных точек, умноженное на 4.

Чем больше точек мы используем, тем более точное приближение числа π мы получим.

Пример кода на Python:

```python

import random

def monte_carlo_pi(num_points):

points_inside_circle = 0

total_points = num_points

for _ in range(num_points):

x = random.uniform(-1, 1)

y = random.uniform(-1, 1)

distance = x**2 + y**2

if distance <= 1:

points_inside_circle += 1

pi_estimate = 4 * points_inside_circle / total_points

return pi_estimate

# Пример использования

num_points = 1000000

estimated_pi = monte_carlo_pi(num_points)

print(f"Приближенное значение числа Пи с использованием {num_points} точек: {estimated_pi}")

```

Этот код генерирует миллион случайных точек в квадрате и оценивает значение числа π с помощью метода Монте-Карло.

Пояснения к каждой части кода:

1. `import random`: Эта строка импортирует модуль `random`, который мы будем использовать для генерации случайных чисел.

2. `def monte_carlo_pi(num_points)`: Это определение функции `monte_carlo_pi`, которая принимает один аргумент `num_points`, представляющий количество случайных точек, которые мы сгенерируем.

3. `points_inside_circle = 0`: Эта переменная будет использоваться для отслеживания количества точек, попавших внутрь круга.

4. `total_points = num_points`: Эта переменная хранит общее количество сгенерированных точек.

5. `for _ in range(num_points):`: Этот цикл генерирует `num_points` случайных точек внутри квадрата.

6. `x = random.uniform(-1, 1)` и `y = random.uniform(-1, 1)`: Эти строки генерируют случайные координаты `x` и `y` для каждой точки в диапазоне от -1 до 1, что соответствует координатам квадрата.

7. `distance = x**2 + y**2`: Это вычисляет квадрат расстояния от начала координат до сгенерированной точки.

8. `if distance <= 1:`: Этот оператор проверяет, попадает ли точка внутрь круга, используя тот факт, что расстояние от начала координат до точки меньше или равно радиусу круга (который равен 1).

9. `points_inside_circle += 1`: Если точка попадает внутрь круга, увеличиваем счетчик точек внутри круга.

10. `pi_estimate = 4 * points_inside_circle / total_points`: Эта строка оценивает значение числа π, умножая отношение точек внутри круга к общему числу точек на 4, так как отношение площади круга к площади квадрата равно π/4.

11. `return pi_estimate`: Функция возвращает оценку числа π.

12. `num_points = 1000000`: Это количество случайных точек, которые мы сгенерируем для оценки числа π.

13. `estimated_pi = monte_carlo_pi(num_points)`: Эта строка вызывает функцию `monte_carlo_pi` с указанным количеством точек и сохраняет результат в переменной `estimated_pi`.

14. `print(f"Приближенное значение числа Пи с использованием {num_points} точек: {estimated_pi}")`: Эта строка выводит приближенное значение числа π на экран вместе с количеством сгенерированных точек. Используется форматированная строка (f-string) для вставки значений переменных в текст.

2. Задача о нахождении площади круга: Приблизить площадь круга с радиусом 1 с помощью метода Монте-Карло.

Описание задачи: Представим, что у нас есть круг с радиусом 1. Мы хотим приблизить его площадь, используя метод Монте-Карло. Для этого мы будем генерировать случайные точки внутри квадрата, описывающего этот круг, и считать, сколько из этих точек попадают внутрь круга.

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

Пример кода на Python:

```python

import random

def monte_carlo_circle_area(num_points):

points_inside_circle = 0

total_points = num_points

for _ in range(num_points):

x = random.uniform(-1, 1)

y = random.uniform(-1, 1)

distance = x**2 + y**2

if distance <= 1:

points_inside_circle += 1

circle_area_estimate = points_inside_circle / total_points * 4

return circle_area_estimate

# Пример использования

num_points = 1000000

estimated_area = monte_carlo_circle_area(num_points)

print(f"Приближенная площадь круга с использованием {num_points} точек: {estimated_area}")

```

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

Пояснения к каждой части кода:

1. `import random`: Эта строка импортирует модуль `random`, который мы будем использовать для генерации случайных чисел.

2. `def monte_carlo_circle_area(num_points)`: Это определение функции `monte_carlo_circle_area`, которая принимает один аргумент `num_points`, представляющий количество случайных точек, которые мы сгенерируем.

4. `total_points = num_points`: Эта переменная хранит общее количество сгенерированных точек.

5. `for _ in range(num_points):`: Этот цикл генерирует `num_points` случайных точек внутри квадрата.

7. `distance = x**2 + y**2`: Это вычисляет квадрат расстояния от начала координат до сгенерированной точки.

8. `if distance <= 1:`: Этот оператор проверяет, попадает ли точка внутрь круга, используя тот факт, что расстояние от начала координат до точки меньше или равно квадрату радиуса круга (который равен 1).

9. `points_inside_circle += 1`: Если точка попадает внутрь круга, увеличиваем счетчик точек внутри круга.

10. `circle_area_estimate = points_inside_circle / total_points * 4`: Эта строка оценивает значение площади круга, умножая отношение точек внутри круга к общему числу точек на 4. Таким образом, мы получаем оценку площади круга, используя формулу для площади круга πr^2, где r = 1.

11. `return circle_area_estimate`: Функция возвращает оценку площади круга.

12. `num_points = 1000000`: Это количество случайных точек, которые мы сгенерируем для оценки площади круга.

13. `estimated_area = monte_carlo_circle_area(num_points)`: Эта строка вызывает функцию `monte_carlo_circle_area` с указанным количеством точек и сохраняет результат в переменной `estimated_area`.

14. `print(f"Приближенная площадь круга с использованием {num_points} точек: {estimated_area}")`: Эта строка выводит приближенное значение площади круга на экран вместе с количеством сгенерированных точек. Используется форматированная строка (f-string) для вставки значений переменных в текст.

3. Задача о простых числах: Найти все простые числа в заданном диапазоне.

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

Идея решения:

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

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

3. Для проверки простоты числа будем делить его на все натуральные числа от 2 до корня из этого числа.

4. Если число делится нацело хотя бы на одно из этих чисел, то оно не является простым и мы переходим к следующему числу.

5. Если число не делится нацело на ни одно из чисел от 2 до корня из него, то оно простое и мы добавляем его в список простых чисел.

6. После завершения проверки для всех чисел в диапазоне возвращаем список простых чисел.

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

Пример решения задачи о поиске всех простых чисел в заданном диапазоне на Python:

```python

def find_primes(start, end):

primes = []

for num in range(start, end + 1):

if num > 1:

for i in range(2, int(num**0.5) + 1):

if (num % i) == 0:

break

else:

primes.append(num)

return primes

# Пример использования

start_range = 1

end_range = 100

prime_numbers = find_primes(start_range, end_range)

print(f"Простые числа в диапазоне от {start_range} до {end_range}:")

print(prime_numbers)

```

Этот код создает функцию `find_primes`, которая принимает начальное и конечное значения диапазона. Функция затем проходит по всем числам в этом диапазоне и проверяет, является ли каждое число простым.

Пояснения к коду:

1. `primes = []`: Эта переменная будет использоваться для хранения простых чисел в диапазоне.

2. `for num in range(start, end + 1)`: Этот цикл проходит по всем числам в заданном диапазоне.

3. `if num > 1:`: Этот оператор проверяет, что число больше 1, так как простые числа определяются как числа, большие 1.

4. `for i in range(2, int(num**0.5) + 1)`: Этот вложенный цикл проверяет, делится ли число нацело на любое число от 2 до корня из этого числа. Мы используем `int(num**0.5) + 1`, чтобы оптимизировать процесс проверки.

5. `if (num % i) == 0:`: Если число делится нацело на какое-либо число от 2 до корня из этого числа, то оно не является простым, и мы выходим из внутреннего цикла.

6. `else:`: Если число не делится нацело на ни одно из чисел от 2 до корня из него, то оно простое, и мы добавляем его в список `primes`.

7. `return primes`: Функция возвращает список простых чисел в заданном диапазоне.

8. `start_range = 1` и `end_range = 100`: Это начальное и конечное значения диапазона, в котором мы ищем простые числа.

9. `prime_numbers = find_primes(start_range, end_range)`: Эта строка вызывает функцию `find_primes` с указанным диапазоном и сохраняет найденные простые числа в переменной `prime_numbers`.

10. `print(f"Простые числа в диапазоне от {start_range} до {end_range}:")`: Эта строка выводит сообщение о том, какой диапазон мы рассматриваем.

11. `print(prime_numbers)`: Эта строка выводит найденные простые числа на экран.

4. Задача о проверке простоты числа: Определить, является ли заданное число простым или составным.

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

Идея решения:

1. Создаем функцию, которая принимает на вход одно целое число.

2. Проверяем базовые случаи: если число меньше или равно 1, то оно не является простым.

3. Иначе, для всех чисел от 2 до квадратного корня из заданного числа, проверяем, делится ли оно нацело на эти числа.

4. Если число делится нацело хотя бы на одно из этих чисел, оно является составным.

5. Если число не делится нацело ни на одно из этих чисел, оно является простым.

Пример кода на Python для реализации этой задачи:

```python

def is_prime(num):

if num <= 1:

return False

for i in range(2, int(num**0.5) + 1):

if num % i == 0:

return False

return True

# Пример использования

number = 17

if is_prime(number):

print(f"{number} – простое число")

else:

print(f"{number} – составное число")

```

Этот код определяет, является ли заданное число простым, используя алгоритм проверки на простоту. Если число делится нацело хотя бы на одно число от 2 до корня из него, оно считается составным. Если число не делится нацело ни на одно из этих чисел, оно считается простым.

Пояснения к коду:

1. `def is_prime(num):`: Это определение функции `is_prime`, которая принимает один аргумент `num`, представляющий число, которое мы хотим проверить на простоту.

2. `if num <= 1:`: Эта строка проверяет базовый случай – если число меньше или равно 1, оно не является простым, поскольку простые числа определяются как числа, большие 1.

3. `for i in range(2, int(num**0.5) + 1):`: Этот цикл перебирает все числа от 2 до корня из заданного числа (включительно), чтобы проверить, делится ли число нацело на какое-либо из этих чисел.

4. `if num % i == 0:`: Если заданное число делится нацело на текущее число `i`, то оно не является простым, и мы возвращаем `False`, указывая на то, что число составное.

5. `return True`: Если число не делится нацело на ни одно из чисел от 2 до корня из него, оно считается простым, и мы возвращаем `True`.

6. `number = 17`: Это пример задания числа, которое мы хотим проверить на простоту.

7. `if is_prime(number):`: Этот оператор проверяет, является ли заданное число простым, используя функцию `is_prime`.

8. `print(f"{number} – простое число")`: Если число простое, то выводится сообщение о том, что число является простым.

9. `else:`: Если число не является простым, то выводится сообщение о том, что число является составным.

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

5. Задача о палиндромах: Определить, является ли строка палиндромом.

Описание задачи: Палиндром – это слово, фраза, число или другая последовательность символов, которая читается одинаково как с начала, так и с конца. Например, слово "level" и фраза "а роза упала на лапу Азора" являются палиндромами.

Идея решения:

1. Создаем функцию, которая принимает на вход строку.

2. Приводим строку к нижнему регистру, чтобы учитывать регистр символов (например, "Lеvеl" должно считаться палиндромом также, как и "level").

3. Удаляем из строки все пробелы, чтобы игнорировать пробелы при проверке на палиндром.

4. Проверяем, равна ли исходная строка своему обратному представлению. Если да, то строка является палиндромом.

5. Если строка равна своему обратному представлению, возвращаем `True`, иначе возвращаем `False`.

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

Пример решения задачи о палиндромах на Python:

```python

def is_palindrome(string):

# Преобразуем строку в нижний регистр для учета регистра символов

string = string.lower()

# Удаляем пробелы из строки

string = string.replace(" ", "")

# Проверяем, является ли строка равной обратной строке

return string == string[::-1]

# Пример использования

word = "level"

if is_palindrome(word):

print(f"Строка '{word}' является палиндромом.")

else:

print(f"Строка '{word}' не является палиндромом.")

```

Этот код определяет, является ли заданная строка палиндромом или нет. Палиндром – это строка, которая читается одинаково как с начала, так и с конца.

Пояснения к коду:

1. `def is_palindrome(string):`: Это определение функции `is_palindrome`, которая принимает один аргумент `string`, представляющий строку, которую мы хотим проверить на палиндром.

2. `string = string.lower()`: Эта строка преобразует всю строку в нижний регистр, чтобы учесть регистр символов. Это позволяет нам игнорировать различия в регистре при проверке палиндромности.

3. `string = string.replace(" ", "")`: Эта строка удаляет все пробелы из строки. Это необходимо для корректной проверки палиндрома, если строка содержит пробелы.

4. `return string == string[::-1]`: Эта строка проверяет, является ли исходная строка `string` равной обратной строке `string[::-1]`. Если строки равны, то функция возвращает `True`, что означает, что строка является палиндромом, в противном случае возвращает `False`.

5. `word = "level"`: Это пример задания строки, которую мы хотим проверить на палиндром.

6. `if is_palindrome(word):`: Этот оператор проверяет, является ли заданная строка палиндромом, используя функцию `is_palindrome`.

7. `print(f"Строка '{word}' является палиндромом.")`: Если строка является палиндромом, выводится сообщение о том, что строка является палиндромом.

8. `else:`: Если строка не является палиндромом, выводится сообщение о том, что строка не является палиндромом.

Таким образом, этот код позволяет определить, является ли заданная строка палиндромом или нет.

6. Задача о калькуляторе: Создать калькулятор для базовых математических операций в обратной польской записи.

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

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

Польская запись была предложена польским математиком Яном Лукасевичем в 1920-х годах и впоследствии получила широкое применение в компьютерных науках, в частности, в вычислительных системах.

Идея решения:

1. Используем стек для хранения операндов.

2. Итерируемся по каждому символу в строке обратной польской записи.

3. Если символ – число, помещаем его в стек.

4. Если символ – оператор, извлекаем из стека нужное количество операндов, выполняем операцию и помещаем результат обратно в стек.

5. После завершения итерации, в стеке должен остаться только один элемент – результат вычислений.

Код на Python:

```python

def calculate(expression):

stack = []

operators = {'+': lambda x, y: x + y,

'-': lambda x, y: x – y,

'*': lambda x, y: x * y,

'/': lambda x, y: x / y}

for token in expression:

if token.isdigit():

stack.append(int(token))

elif token in operators:

operand2 = stack.pop()

operand1 = stack.pop()

result = operators[token](operand1, operand2)

stack.append(result)

return stack[0]

# Пример использования:

expression = "53+"

result = calculate(expression)

print("Результат вычислений:", result)

```

Объяснения к коду:

1. Функция `calculate` принимает строку обратной польской записи и возвращает результат вычислений.

2. Создается пустой стек `stack` для хранения операндов.

3. Словарь `operators` содержит операторы и соответствующие им функции для выполнения операций.

4. В цикле `for` происходит итерация по каждому символу в строке.

5. Если символ является числом, он добавляется в стек как операнд.

6. Если символ является оператором, из стека извлекаются два операнда, выполняется операция и результат помещается обратно в стек.

7. После завершения итерации, в стеке остается только один элемент – результат вычислений, который возвращается функцией.

7. Задача вычисления выражения в обратной польской записи

Пусть у нас есть следующее выражение: "5 3 + 8 * 4 /".

Чтобы вычислить это выражение в обратной польской записи, мы будем использовать алгоритм, описанный ранее:

1. Создаем пустой стек.

2. Итерируемся по каждому символу в выражении.

3. Если символ – число, помещаем его в стек.

5. После завершения итерации, в стеке должен остаться только один элемент – результат вычислений.

Применяя этот алгоритм к нашему выражению, мы получим:

1. Помещаем 5 в стек.

2. Помещаем 3 в стек.

3. Встречаем оператор "+", извлекаем из стека 3 и 5, выполняем операцию сложения и помещаем результат (8) обратно в стек.

4. Помещаем 8 в стек.

5. Помещаем 4 в стек.

6. Встречаем оператор "*", извлекаем из стека 4 и 8, выполняем операцию умножения и помещаем результат (32) обратно в стек.

7. Помещаем 32 в стек.

8. Встречаем оператор "/", извлекаем из стека 32 и 4, выполняем операцию деления и помещаем результат (8) обратно в стек.

После завершения итераций, в стеке остается только один элемент – результат вычислений, который равен 8.

Давайте напишем код для вычисления выражения в обратной польской записи:

```python

def evaluate_reverse_polish_notation(expression):

stack = []

operators = {'+': lambda x, y: x + y,

'-': lambda x, y: x – y,

'*': lambda x, y: x * y,

'/': lambda x, y: x / y}

for token in expression.split():

if token.isdigit():

stack.append(int(token))

elif token in operators:

operand2 = stack.pop()

operand1 = stack.pop()

result = operators[token](operand1, operand2)

stack.append(result)

return stack[0]

# Пример использования:

expression = "5 3 + 8 * 4 /"

result = evaluate_reverse_polish_notation(expression)

print("Результат вычислений:", result)

```

Этот код работает аналогично предыдущему, но мы добавил функцию `evaluate_reverse_polish_notation`, которая принимает строку в обратной польской записи и возвращает результат вычислений. Каждый токен выражения разделяется пробелами при помощи метода `split()`, чтобы создать список токенов. Затем итерируется по этому списку. Если текущий токен является числом, он добавляется в стек. Если текущий токен – оператор, извлекаются два операнда из стека, выполняется операция и результат помещается обратно в стек. После завершения итераций в стеке остается только один элемент – результат вычислений, который возвращается из функции.

8. Задача о сортировке: Реализовать свой алгоритм сортировки и сравнить его производительность с встроенной функцией сортировки Python.

Идея решения:

Для реализации собственного алгоритма сортировки, мы можем использовать один из классических алгоритмов, таких как сортировка пузырьком, сортировка вставками, сортировка выбором или быстрая сортировка. Давайте выберем быструю сортировку (Quick Sort) из-за ее высокой производительности в среднем случае.

Идея быстрой сортировки заключается в следующем:

1. Выбирается опорный элемент из массива.

2. Массив разделяется на две подгруппы: одна содержит элементы, меньшие опорного, а другая – большие.

3. Рекурсивно применяется алгоритм к каждой подгруппе.

Для сравнения производительности нашего алгоритма сортировки с встроенной функцией сортировки Python (например, `sorted()`), мы можем измерить время выполнения каждого метода на одних и тех же данных.

Код:

```python

import time

import random

def quick_sort(arr):

if len(arr) <= 1:

return arr

pivot = arr[len(arr) // 2]

left = [x for x in arr if x < pivot]

middle = [x for x in arr if x == pivot]

right = [x for x in arr if x > pivot]

return quick_sort(left) + middle + quick_sort(right)

# Функция для замера времени выполнения

def measure_time(sort_function, arr):

start_time = time.time()

sorted_arr = sort_function(arr)

end_time = time.time()

return sorted_arr, end_time – start_time

# Генерация случайного списка для сортировки

arr = [random.randint(0, 1000) for _ in range(1000)]

# Сравнение производительности с собственной и встроенной сортировкой

sorted_arr_custom, time_custom = measure_time(quick_sort, arr)

sorted_arr_builtin, time_builtin = measure_time(sorted, arr)

print("Время выполнения собственной сортировки:", time_custom)

print("Время выполнения встроенной сортировки:", time_builtin)

```

Объяснения к коду:

– `quick_sort`: Это наша реализация алгоритма быстрой сортировки. Он разбивает массив на подмассивы вокруг опорного элемента, рекурсивно сортируя каждую подгруппу, а затем объединяет их в один отсортированный массив.

– `measure_time`: Это функция, которая принимает на вход функцию сортировки и список для сортировки, замеряет время выполнения этой функции над списком и возвращает отсортированный список и время выполнения.

– Мы генерируем случайный список `arr` для сортировки.

– Затем мы вызываем `measure_time` для нашей собственной реализации быстрой сортировки и для встроенной функции сортировки Python (`sorted()`).

– Наконец, мы выводим время выполнения каждой из функций сортировки для сравнения.

9. Задача о рекурсии: Реализовать алгоритм бинарного поиска с использованием рекурсии.

Идея решения:

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

Код:

```python

def binary_search_recursive(arr, target, left, right):

if left > right:

return -1

mid = (left + right) // 2

if arr[mid] == target:

return mid

elif arr[mid] < target:

return binary_search_recursive(arr, target, mid + 1, right)

else:

return binary_search_recursive(arr, target, left, mid – 1)

# Пример использования:

arr = [1, 3, 5, 7, 9, 11, 13, 15, 17]

target = 11

index = binary_search_recursive(arr, target, 0, len(arr) – 1)

if index != -1:

print(f"Элемент {target} найден в позиции {index}.")

else:

print(f"Элемент {target} не найден.")

```

Объяснения к коду:

– Функция `binary_search_recursive` принимает отсортированный массив `arr`, искомый элемент `target`, левую границу `left` и правую границу `right`.

– Если `left` больше `right`, значит, искомый элемент не найден, поэтому функция возвращает `-1`.

– Иначе, находим индекс `mid` элемента в середине отрезка между `left` и `right`.

– Если значение в `arr[mid]` равно `target`, возвращаем `mid`.

– Если `arr[mid]` меньше `target`, рекурсивно вызываем функцию для правой половины массива, начиная с `mid + 1`.

– Если `arr[mid]` больше `target`, рекурсивно вызываем функцию для левой половины массива, заканчивая `mid – 1`.

– Пример использования демонстрирует поиск элемента `11` в массиве `arr`, результатом будет сообщение о том,что элемент найден в позиции `5`.

10. Задача о проверке на анаграмму: Написать программу, которая определяет, являются ли две строки анаграммами (состоят ли они из одних и тех же символов, но в другом порядке).

Для решения этой задачи мы можем воспользоваться следующим подходом:

1. Убедимся, что длины обеих строк равны. Если нет, то они не могут быть анаграммами.

2. Преобразуем обе строки в нижний регистр (для упрощения сравнения).

3. Отсортируем символы в обеих строках.

4. Сравним отсортированные строки. Если они равны, то строки являются анаграммами, иначе нет.

Пример кода на Python, реализующий этот подход:

```python

def are_anagrams(str1, str2):

# Проверяем, равны ли длины строк

if len(str1) != len(str2):

return False

# Преобразуем строки в нижний регистр

str1 = str1.lower()

str2 = str2.lower()

# Сортируем символы в обеих строках

sorted_str1 = ''.join(sorted(str1))

sorted_str2 = ''.join(sorted(str2))

# Сравниваем отсортированные строки

if sorted_str1 == sorted_str2:

return True

else:

return False

# Пример использования

string1 = "listen"

string2 = "silent"

if are_anagrams(string1, string2):

print(f"{string1} и {string2} – анаграммы.")

else:

print(f"{string1} и {string2} – не анаграммы.")

```

Этот код сначала проверяет, равны ли длины строк. Если да, он преобразует обе строки в нижний регистр и сортирует их символы. Затем он сравнивает отсортированные строки. Если они равны, функция возвращает `True`, что указывает на то, что строки являются анаграммами. В противном случае возвращается `False`.

Пояснения к коду:

Определение функции `are_anagrams`:

– Эта функция принимает две строки в качестве аргументов и возвращает булево значение, указывающее, являются ли они анаграммами.

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

– Сначала функция проверяет длины обеих строк. Если они не равны, то они не могут быть анаграммами, и функция возвращает `False`.

Преобразование строк в нижний регистр:

– Затем обе строки преобразуются в нижний регистр при помощи метода `lower()`. Это делается для упрощения сравнения, так как мы не хотим учитывать регистр при проверке на анаграмму.

Сортировка символов в строках:

– После этого символы в каждой строке сортируются в алфавитном порядке при помощи функции `sorted()`.

– Мы объединяем отсортированные символы обратно в строки при помощи метода `join()`. Это дает нам отсортированные версии строк.

Сравнение отсортированных строк:

– Отсортированные строки сравниваются. Если они равны, то строки являются анаграммами, и функция возвращает `True`. Если они не равны, функция возвращает `False`.

Пример использования:

– В конце кода показан пример использования функции, где две строки `"listen"` и `"silent"` проверяются на анаграмму.

– Выводится соответствующее сообщение в зависимости от результата проверки.

Таким образом, этот код эффективно проверяет строки на анаграммы, используя описанный выше алгоритм.

11. Задача о поиске наибольшего общего делителя (НОД): Написать программу, которая находит наибольший общий делитель двух целых чисел.

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

Пример кода на Python:

```python

def gcd(a, b):

while b:

a, b = b, a % b

return a

# Пример использования

num1 = 48

num2 = 18

result = gcd(num1, num2)

print(f"Наибольший общий делитель чисел {num1} и {num2}:", result)

```