diff --git "a/data/train.jsonl" "b/data/train.jsonl" new file mode 100644--- /dev/null +++ "b/data/train.jsonl" @@ -0,0 +1,187 @@ +{"messages": [{"role": "system", "content": "Ты эксперт по Python."}, {"role": "user", "content": "Напишите функцию get_even_numbers(lst), которая возвращает список только четных чисел."}, {"role": "assistant", "content": "`python\ndef get_even_numbers(lst):\n return [x for x in lst if isinstance(x, (int, float)) and x % 2 == 0]\n`"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Используя генераторы списков и модуль `itertools`, создайте итератор, который объединяет бесконечную последовательность квадратов чисел и циклическое повторение заданного набора строк. Реализуйте функцию с оператором `yield`, которая будет возвращать только те элементы, которые соответствуют условию фильтрации при заданном `seed=119621`."}, {"role": "assistant", "content": "```python\nimport itertools\nimport random\n\ndef filtered_sequence_generator(strings, seed=119621):\n \"\"\"\n Creates an iterator combining infinite squares and cyclic strings,\n filtering elements based on a random condition seeded with seed.\n \"\"\"\n random.seed(seed)\n \n # Infinite sequence of squares: 0, 1, 4, 9, 16...\n squares = (x**2 for x in itertools.count())\n \n # Cyclic repetition of strings\n cyclic_strings = itertools.cycle(strings)\n \n # Combine sequences using zip\n combined = itertools.zip_longest(squares, cyclic_strings)\n \n for item in combined:\n # item is a tuple (square, string) or (square, None) or (None, string)\n # Since squares is infinite, we focus on the combined stream\n \n # Condition: yield only if a random check passes \n # (simulating complex filtering logic as requested)\n if random.random() > 0.5:\n yield item\n\nif __name__ == \"__main__\":\n sample_strings = [\"alpha\", \"beta\", \"gamma\"]\n gen = filtered_sequence_generator(sample_strings)\n \n # Print first 10 filtered results\n for _ in range(10):\n print(next(gen))\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Дан список идентификаторов товаров, где некоторые значения являются кортежами, а другие — одиночными числами. Напишите функцию, которая подсчитает уникальные элементы, учитывая, что при поиске пересечений множеств кортежи должны считаться едиными объектами, а не набором отдельных значений."}, {"role": "assistant", "content": "```python\nfrom typing import List, Any, Set\n\ndef count_unique_elements(items: List[Any]) -> int:\n \"\"\"\n Counts unique elements in a list where elements can be integers or tuples.\n Tuples are treated as single atomic objects.\n \"\"\"\n # Using a set to store unique elements. \n # Since tuples are hashable in Python, they will be treated as single entities.\n unique_elements: Set[Any] = set(items)\n return len(unique_elements)\n\n# Example usage:\nif __name__ == \"__main__\":\n data = [1, (1, 2), 3, (1, 2), 1, (4, 5), 3, (1, 2)]\n # Expected unique: {1, (1, 2), 3, (4, 5)} -> count: 4\n print(count_unique_elements(data))\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите функцию для вычисления n-го числа Фибоначчи, которая при использовании стандартной рекурсии вызывает ошибку переполнения стека или работает бесконечно долго при больших значениях. Реализуйте оптимизацию с помощью мемоизации, чтобы алгоритм возвращал корректный результат для заданного seed=210054 за константное время после первого вызова."}, {"role": "assistant", "content": "```python\nimport sys\n\ndef fibonacci_recursive_naive(n):\n \"\"\"\n Standard recursive implementation that causes StackOverflow or \n takes exponential time for large n.\n \"\"\"\n if n <= 1:\n return n\n return fibonacci_recursive_naive(n - 1) + fibonacci_recursive_naive(n - 2)\n\nclass FibonacciOptimized:\n def __init__(self):\n self.memo = {0: 0, 1: 1}\n\n def get_n(self, n):\n \"\"\"\n Optimized implementation using memoization.\n \"\"\"\n if n in self.memo:\n return self.memo[n]\n \n # Using iterative approach to fill memo to avoid RecursionError \n # while maintaining the memoization property for O(1) subsequent calls.\n last_computed = max(self.memo.keys())\n \n # If n is larger than what we have, compute up to n\n # We use an iterative approach here to ensure we don't hit stack limits\n # during the initial population of the cache.\n a, b = self.memo[last_computed - 1], self.memo[last_computed]\n \n # If n is smaller than last_computed, we still need to handle it, \n # but the logic below handles n > last_computed.\n # For simplicity in this specific requirement, we fill the gap.\n \n # Re-calculating sequence to fill memo up to n\n # This ensures that after the first call, any n <= target is O(1)\n curr_a = 0\n curr_b = 1\n # Find starting point for iteration\n # To be safe and efficient, we find\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите программу, которая с помощью модуля `pathlib` находит в заданной директории все CSV-файлы, считывает их содержимое и преобразует данные в единый структурированный список словарей. Полученный результат необходимо отфильтровать по определенному критерию и сохранить в новый JSON-файл, создав при этом целевую папку, если она отсутствует."}, {"role": "assistant", "content": "```python\nimport csv\nimport json\nfrom pathlib import Path\n\ndef process_csv_data(input_dir: str, output_dir: str, output_filename: str, filter_key: str, filter_value: str):\n \"\"\"\n Находит все CSV файлы в директории, объединяет их в список словарей,\n фильтрует по значению ключа и сохраняет в JSON.\n \"\"\"\n base_path = Path(input_dir)\n target_path = Path(output_dir)\n \n # Создаем целевую папку, если она не существует\n target_path.mkdir(parents=True, exist_ok=True)\n \n combined_data = []\n\n # Проверяем существование исходной директории\n if not base_path.exists():\n raise FileNotFoundError(f\"Directory {input_dir} does not exist.\")\n\n # Ищем все .csv файлы в директории\n csv_files = list(base_path.glob(\"*.csv\"))\n\n for file_path in csv_files:\n with open(file_path, mode='r', encoding='utf-8') as f:\n reader = csv.DictReader(f)\n for row in reader:\n combined_data.append(row)\n\n # Фильтрация данных: оставляем только те записи, где значение filter_key равно filter_value\n # (Приводим к строке для корректного сравнения, так как DictReader возвращает строки)\n filtered_data = [\n item for item in combined_data \n if str(item.get(filter_key)) == str(filter_value)\n ]\n\n # Путь к итоговому файлу\n output_file_path = target\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Данная строка содержит скрытый идентификатор, который кажется числом, но на самом деле является результатом склейки фрагментов, разделенных спецсимволами. Извлеките из текста только те подстроки, которые соответствуют паттерну «число-буква-число», используя срезы для предварительной очистки и регулярные выражения для финальной фильтрации."}, {"role": "assistant", "content": "```python\nimport re\n\ndef extract_hidden_identifier(text: str) -> list:\n \"\"\"\n Extracts substrings matching the pattern 'digit-letter-digit' \n using slicing for cleaning and regex for filtering.\n \"\"\"\n # Step 1: Preliminary cleaning using slicing/splitting\n # We split by non-alphanumeric characters to isolate potential fragments\n fragments = re.split(r'[^a-zA-Z0-9]', text)\n \n # Step 2: Final filtering using regular expressions\n # Pattern: one digit, one letter, one digit\n pattern = re.compile(r'^\\d[a-zA-Z]\\d$')\n \n results = [f for f in fragments if pattern.match(f)]\n return results\n\nif __name__ == \"__main__\":\n # Test case with various separators and noise\n input_data = \"id: 1a2, error_code: 9z0; status: [4b5]!#_7k8_temp_99x9_invalid\"\n \n identifiers = extract_hidden_identifier(input_data)\n print(identifiers)\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Реализуйте систему мониторинга, которая одновременно запускает три асинхронные корутины для имитации сбора данных из разных источников с использованием `asyncio.sleep`. Необходимо обеспечить корректное завершение всех процессов по истечении заданного таймера с помощью `asyncio.wait_for` без прерывания работы основной программы."}, {"role": "assistant", "content": "```python\nimport asyncio\nimport random\n\nasync def collect_data(source_name: str):\n \"\"\"Имитация сбора данных из источника.\"\"\"\n try:\n while True:\n # Имитируем разную скорость поступления данных\n wait_time = random.uniform(0.5, 2.0)\n await asyncio.sleep(wait_time)\n print(f\"[INFO] {source_name}: данные получены (задержка {wait_time:.2f}s)\")\n except asyncio.CancelledError:\n print(f\"[CLEANUP] {source_name}: процесс остановлен, ресурсы освобождены\")\n raise\n\nasync def monitoring_system(timeout: float):\n \"\"\"Запуск системы мониторинга с ограничением по времени.\"\"\"\n sources = [\"Sensor_A\", \"Sensor_B\", \"Sensor_C\"]\n \n # Создаем список задач\n tasks = [asyncio.create_task(collect_data(name)) for name in sources]\n \n try:\n # Ожидаем выполнения задач в течение заданного времени\n # Так как задачи бесконечные, wait_for выбросит TimeoutError\n await asyncio.wait_for(asyncio.gather(*tasks), timeout=timeout)\n except asyncio.TimeoutError:\n print(f\"\\n[SYSTEM] Таймер ({timeout}s) истек. Завершение мониторинга...\")\n finally:\n # Корректно отменяем все запущенные задачи\n for task in tasks:\n task.cancel()\n \n # Ждем завершения отмены, чтобы избежать предупреждений в логах\n await asyncio.gather(*tasks, return_exceptions=True)\n print(\"[SYSTEM] Все процессы мониторинга успешно остановлены.\")\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Дан список слов, из которого необходимо составить словарь, где ключами будут уникальные слова, а значениями — количество их повторений. Для решения задачи используйте инструменты из модуля `collections`, чтобы эффективно подсчитать частоту каждого элемента."}, {"role": "assistant", "content": "```python\nfrom collections import Counter\n\ndef count_word_frequencies(word_list: list[str]) -> dict[str, int]:\n \"\"\"\n Counts the frequency of each unique word in the provided list.\n \"\"\"\n return dict(Counter(word_list))\n\nif __name__ == \"__main__\":\n # Example usage\n words = [\"apple\", \"banana\", \"apple\", \"orange\", \"banana\", \"apple\", \"grape\"]\n result = count_word_frequencies(words)\n print(result)\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите программу, которая находит наибольший общий делитель (НОД) между факториалом заданного числа $n$ и произведением всех простых чисел, не превосходящих это число. Результат вычислений должен быть представлен в виде остатка от деления этого НОД на 1000."}, {"role": "assistant", "content": "```python\nimport math\n\ndef solve():\n try:\n line = input().strip()\n if not line:\n return\n n = int(line)\n except EOFError:\n return\n except ValueError:\n return\n\n if n < 2:\n # n! for n < 2 is 1. \n # Product of primes <= n is 1 (empty product).\n # GCD(1, 1) = 1. 1 % 1000 = 1.\n # However, if n=0 or n=1, there are no primes <= n.\n # The product of an empty set is 1.\n print(1 % 1000)\n return\n\n def get_primes(limit):\n primes = []\n sieve = [True] * (limit + 1)\n for p in range(2, limit + 1):\n if sieve[p]:\n primes.append(p)\n for i in range(p * p, limit + 1, p):\n sieve[i] = False\n return primes\n\n primes = get_primes(n)\n \n # Let P be the product of primes <= n.\n # Let F be n!.\n # Since every prime p <= n is a factor in n!, \n # the product of all such primes must divide n!.\n # Therefore, GCD(n!, Product of primes <= n) is simply the Product of primes <= n.\n \n product_of_primes = 1\n for p in primes:\n product_of_primes = (product_of_primes * p) % 1000\n \n # Wait, the problem asks for GCD(n!,\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Дан список слов, из которого необходимо извлечь только уникальные элементы, сохранив их порядок появления. Затем подсчитайте количество вхождений каждого слова и представьте результат в виде словаря, где ключами являются слова, а значениями — их частота."}, {"role": "assistant", "content": "```python\ndef process_words(words_list):\n # Извлекаем уникальные элементы, сохраняя порядок появления\n unique_words = []\n seen = set()\n for word in words_list:\n if word not in seen:\n unique_words.append(word)\n seen.add(word)\n \n # Подсчитываем количество вхождений каждого слова\n frequency_dict = {}\n for word in words_list:\n frequency_dict[word] = frequency_dict.get(word, 0) + 1\n \n # Формируем итоговый словарь только для уникальных слов в порядке их появления\n result = {word: frequency_dict[word] for word in unique_words}\n \n return result\n\n# Пример использования:\nif __name__ == \"__main__\":\n input_data = [\"apple\", \"banana\", \"apple\", \"orange\", \"banana\", \"apple\", \"grape\"]\n result = process_words(input_data)\n print(result)\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Реализуйте функцию, которая должна выбрасывать кастомное исключение `ValidationError` при неверном формате данных, но при этом корректно обрабатывает стандартное `ValueError`, возникающее внутри блока `try`. Логическая ловушка заключается в том, что порядок перехвата исключений и их иерархия определяют, будет ли ошибка обработана вашим классом или перейдет на уровень выше."}, {"role": "assistant", "content": "```python\nclass ValidationError(Exception):\n \"\"\"Custom exception for data validation errors.\"\"\"\n pass\n\ndef validate_data(data):\n \"\"\"\n Validates input data. \n Raises ValidationError if data is not a positive integer.\n Handles ValueError internally if it occurs during processing.\n \"\"\"\n try:\n # Simulate a potential ValueError from a built-in operation\n # e.g., if data is a string that cannot be converted to int\n value = int(data)\n \n if value <= 0:\n # We manually trigger our custom exception for business logic failure\n raise ValidationError(f\"Value must be positive, got {value}\")\n \n return value\n\n except ValueError as e:\n # We catch the standard ValueError (e.g., int('abc')) \n # and wrap it into our custom ValidationError to maintain a consistent API\n raise ValidationError(f\"Invalid data format: {e}\") from e\n\ndef main():\n test_cases = [\"10\", \"-5\", \"abc\", 0]\n\n for case in test_cases:\n try:\n result = validate_data(case)\n print(f\"Success: {result}\")\n except ValidationError as ve:\n print(f\"Caught expected ValidationError: {ve}\")\n except Exception as e:\n print(f\"Caught unexpected exception: {type(e).__name__}: {e}\")\n\nif __name__ == \"__main__\":\n main()\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите функцию для вычисления количества уникальных способов разбить число $N$ на сумму нескольких натуральных чисел, где каждое последующее число в сумме должно быть строго больше предыдущего. Для оптимизации работы алгоритма при больших значениях $N$ необходимо реализовать механизм мемоизации, чтобы избежать избыточных рекурсивных вызовов."}, {"role": "assistant", "content": "```python\ndef count_partitions(n):\n memo = {}\n\n def solve(remaining, last_val):\n # Base case: if remaining is 0, we found a valid partition\n if remaining == 0:\n return 1\n \n # State is defined by the remaining sum and the last number used\n state = (remaining, last_val)\n if state in memo:\n return memo[state]\n \n count = 0\n # The next number must be strictly greater than the last number\n # and cannot exceed the remaining sum\n for next_val in range(last_val + 1, remaining + 1):\n count += solve(remaining - next_val, next_val)\n \n memo[state] = count\n return count\n\n # We start with last_val = 0 because the first number must be >= 1\n return solve(n, 0)\n\n# Example usage:\nif __name__ == \"__main__\":\n import sys\n # Increase recursion depth for large N\n sys.setrecursionlimit(2000)\n \n test_n = 10\n print(f\"N={test_n}, ways={count_partitions(test_n)}\")\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите функцию, которая с помощью генератора списков находит все квадраты чисел из заданного диапазона, кратных трем. Затем реализуйте функцию с использованием `yield`, которая возвращает эти значения через выражение-генератор, и продемонстрируйте работу с `itertools.islice` для получения первых пяти элементов."}, {"role": "assistant", "content": "```python\nimport itertools\n\ndef get_squares_list(start, end):\n \"\"\"Находит квадраты чисел из диапазона, кратных трем, через генератор списков.\"\"\"\n return [x**2 for x in range(start, end + 1) if x % 3 == 0]\n\ndef get_squares_generator(start, end):\n \"\"\"Возвращает значения через генератор с использованием yield.\"\"\"\n for x in range(start, end + 1):\n if x % 3 == 0:\n yield x**2\n\nif __name__ == \"__main__\":\n # Параметры диапазона\n START, END = 1, 50\n\n # 1. Демонстрация через генератор списков\n squares_list = get_squares_list(START, END)\n print(f\"Squares list: {squares_list}\")\n\n # 2. Демонстрация через yield и itertools.islice\n squares_gen = get_squares_generator(START, END)\n first_five = list(itertools.islice(squares_gen, 5))\n print(f\"First five elements via islice: {first_five}\")\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Найдите произведение всех простых чисел, которые являются делителями факториала числа $N$, где $N$ — это наибольший общий делитель чисел 733973 и 100. Учтите, что результат должен быть вычислен с учетом того, что само число $N$ может оказаться составным или простым."}, {"role": "assistant", "content": "```python\nimport math\n\ndef gcd(a, b):\n while b:\n a, b = b, a % b\n return a\n\ndef solve():\n # Step 1: Find N = gcd(733973, 100)\n # 100 = 2^2 * 5^2. \n # 733973 is not divisible by 2 (it's odd) and not divisible by 5 (ends in 3).\n # Therefore, gcd(733973, 100) must be 1.\n n = gcd(733973, 100)\n \n # Step 2: Find the product of all prime numbers that are divisors of N!\n # The prime divisors of N! are all prime numbers p such that p <= N.\n # If N = 1, N! = 1. 1 has no prime divisors.\n # The product of an empty set of numbers is typically defined as 1 (multiplicative identity).\n \n if n < 2:\n print(1)\n return\n\n primes = []\n is_prime = [True] * (n + 1)\n for p in range(2, n + 1):\n if is_prime[p]:\n primes.append(p)\n for i in range(p * p, n + 1, p):\n is_prime[i] = False\n \n product = 1\n for p in primes:\n product *= p\n \n print(product)\n\nif __name__ == \"__main__\":\n solve()\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Дан список целых чисел, из которого необходимо отфильтровать только положительные значения. Полученный подсписок следует отсортировать по возрастанию и вывести на экран первый элемент, найденный с помощью алгоритма линейного поиска."}, {"role": "assistant", "content": "```python\ndef solve(numbers):\n # Фильтруем только положительные значения\n positive_numbers = [x for x in numbers if x > 0]\n \n # Сортируем по возрастанию\n positive_numbers.sort()\n \n # Если список не пуст, находим первый элемент (линейный поиск первого элемента)\n if positive_numbers:\n # В отсортированном списке первый элемент — это минимальный\n # Линейный поиск первого элемента в контексте задачи подразумевает доступ по индексу 0\n result = positive_numbers[0]\n print(result)\n\nif __name__ == \"__main__\":\n # Пример входных данных\n data = [-5, 12, 0, 3, -1, 8, 1, 7]\n solve(data)\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Используя генератор списка и функцию с оператором `yield`, создайте последовательность квадратов всех четных чисел в заданном диапазоне. Затем примените функцию `itertools.islice`, чтобы извлечь первые пять элементов из полученного выражения-генератора."}, {"role": "assistant", "content": "```python\nimport itertools\n\ndef even_squares_generator(start, end):\n for i in range(start, end + 1):\n if i % 2 == 0:\n yield i ** 2\n\n# Заданный диапазон (например, от 0 до 50)\nstart_range = 0\nend_range = 50\n\n# Создание генератора через функцию с yield\n# (Согласно условию задачи, используем генератор списка для демонстрации логики, \n# но по сути работаем с итератором)\ngen = even_squares_generator(start_range, end_range)\n\n# Применение itertools.islice для извлечения первых пяти элементов\nfirst_five_squares = list(itertools.islice(gen, 5))\n\nprint(first_five_squares)\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите функцию, которая с помощью генератора списков находит все простые числа в заданном диапазоне, а затем возвращает их через выражение-генератор. Используя модуль `itertools`, реализуйте функцию с ключевым словом `yield`, которая возвращает первые $N$ найденных чисел."}, {"role": "assistant", "content": "```python\nimport itertools\n\ndef get_primes_in_range(start, end):\n \"\"\"Находит все простые числа в диапазоне с помощью ге��ератора списков.\"\"\"\n return [n for n in range(max(2, start), end + 1) if all(n % i!= 0 for i in range(2, int(n**0.5) + 1))]\n\ndef get_first_n_primes(start, end, n):\n \"\"\"Возвращает первые N простых чисел из диапазона с помощью yield и itertools.\"\"\"\n primes_gen = (p for p in get_primes_in_range(start, end))\n for prime in itertools.islice(primes_gen, n):\n yield prime\n\n# Пример использования:\nif __name__ == \"__main__\":\n start_range = 1\n end_range = 100\n limit = 10\n \n # Получаем первые N простых чисел\n result = list(get_first_n_primes(start_range, end_range, limit))\n print(result)\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Создайте класс `Vector`, который при сложении двух объектов через `__add__` возвращает новый объект того же класса, но при попытке вывести его через `__repr__` всегда возвращает строку с координатами исходного объекта. Проверьте, изменится ли тип возвращаемого значения и содержимое строкового представления, если один из операндов будет наследником этого класса, переопределившим логику сложения."}, {"role": "assistant", "content": "```python\nclass Vector:\n def __init__(self, x, y):\n self.x = x\n self.y = y\n\n def __add__(self, other):\n if isinstance(other, Vector):\n return Vector(self.x + other.x, self.y + other.y)\n return NotImplemented\n\n def __repr__(self):\n return f\"Vector({self.x}, {self.y})\"\n\nclass CustomVector(Vector):\n def __add__(self, other):\n # Переопределенная логика: возвращает не Vector, а CustomVector\n if isinstance(other, Vector):\n return CustomVector(self.x + other.x, self.y + other.y)\n return NotImplemented\n\n# Тестирование базового класса\nv1 = Vector(1, 2)\nv2 = Vector(3, 4)\nv3 = v1 + v2\n\nprint(f\"Base addition result type: {type(v3)}\")\nprint(f\"Base addition repr: {repr(v3)}\")\n\n# Проверка наследования и переопределения\ncv1 = CustomVector(10, 20)\ncv2 = CustomVector(5, 5)\ncv3 = cv1 + cv2\n\nprint(f\"Custom addition result type: {type(cv3)}\")\nprint(f\"Custom addition repr: {repr(cv3)}\")\n\n# Проверка смешанного сложения (Custom + Base)\ncv4 = cv1 + v2\nprint(f\"Mixed addition (Custom + Base) type: {type(cv4)}\")\nprint(f\"Mixed addition repr: {repr(cv4)}\")\n\n# Проверка того, что __repr__ всегда возвращает координаты (согласно условию задачи)\n# В данной\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Используя генератор списка или выражение-генератор, создайте последовательность квадратов всех чётных чисел в заданном диапазоне. Затем примените функцию `yield` в пользовательской функции и модуль `itertools`, чтобы эффективно извлечь и вывести первые пять элементов этой последовательности."}, {"role": "assistant", "content": "```python\nimport itertools\n\ndef get_even_squares(start, end):\n # Генераторное выражение для квадратов чётных чисел\n squares_gen = (x**2 for x in range(start, end + 1) if x % 2 == 0)\n \n # Функция-генератор, использующая yield для передачи элементов\n def generator_wrapper(gen):\n for value in gen:\n yield value\n \n return generator_wrapper(squares_gen)\n\nif __name__ == \"__main__\":\n # Задаем диапазон\n start_range, end_range = 1, 100\n \n # Создаем экземпляр генератора\n sequence = get_even_squares(start_range, end_range)\n \n # Используем itertools.islice для эффективного извлечения первых пяти элементов\n first_five = itertools.islice(sequence, 5)\n \n # Вывод результата\n print(list(first_five))\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчи��. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Реализуйте функцию, которая выбрасывает кастомное исключение `ValidationError` при неверном формате данных, но при этом должна корректно обрабатывать стандартное `ValueError`, возникающее внутри блока `try`. Логический подвох заключается в том, что порядок перехвата исключений в блоке `except` может привести к перехвату специфичного ошибки общим обработчиком, что сделает невозможным выполнение уникальной логики для кастомного типа."}, {"role": "assistant", "content": "```python\nclass ValidationError(Exception):\n \"\"\"Custom exception for validation errors.\"\"\"\n pass\n\ndef validate_data(data):\n \"\"\"\n Validates input data.\n Raises ValidationError if format is wrong.\n Raises ValueError if data is not a number.\n \"\"\"\n if not isinstance(data, (int, float)):\n raise ValidationError(f\"Invalid format: expected number, got {type(data).__name__}\")\n \n if data < 0:\n # Simulating a standard ValueError that might occur during processing\n raise ValueError(\"Value must be non-negative\")\n \n return data ** 2\n\ndef process_input(data):\n try:\n result = validate_data(data)\n print(f\"Success: {result}\")\n except ValidationError as ve:\n # Specific handler for our custom exception\n print(f\"Caught specific error: {ve}\")\n except ValueError as ve:\n # Handler for standard ValueError\n print(f\"Caught standard error: {ve}\")\n except Exception as e:\n # Catch-all for any other unexpected errors\n print(f\"Caught unexpected error: {e}\")\n\nif __name__ == \"__main__\":\n # Test Case 1: Correct data\n print(\"Test 1 (Valid):\")\n process_input(10)\n\n # Test Case 2: ValidationError (Wrong type)\n print(\"\\nTest 2 (ValidationError):\")\n process_input(\"string\")\n\n # Test Case 3: ValueError (Negative number)\n print(\"\\nTest 3 (ValueError):\")\n process_input(-5)\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Создайте класс «Книга» с атрибутами названия и автора, реализовав метод `__repr__` для красивого отображения объекта и метод `__add__` для сложения количества страниц двух книг. Затем создайте подкласс «Электронная книга», который наследует основные свойства и добавляет атрибут размера файла."}, {"role": "assistant", "content": "```python\nclass Book:\n def __init__(self, title: str, author: str, pages: int):\n self.title = title\n self.author = author\n self.pages = pages\n\n def __repr__(self) -> str:\n return f\"Book(title='{self.title}', author='{self.author}', pages={self.pages})\"\n\n def __add__(self, other: 'Book') -> int:\n if isinstance(other, Book):\n return self.pages + other.pages\n return NotImplemented\n\n\nclass EBook(Book):\n def __init__(self, title: str, author: str, pages: int, file_size_mb: float):\n super().__init__(title, author, pages)\n self.file_size_mb = file_size_mb\n\n def __repr__(self) -> str:\n return f\"EBook(title='{self.title}', author='{self.author}', pages={self.pages}, file_size={self.file_size_mb}MB)\"\n\n\nif __name__ == \"__main__\":\n book1 = Book(\"War and Peace\", \"Leo Tolstoy\", 1225)\n book2 = Book(\"The Hobbit\", \"J.R.R. Tolkien\", 310)\n ebook1 = EBook(\"Digital Fortress\", \"Dan Brown\", 400, 2.5)\n\n print(book1)\n print(book2)\n print(ebook1)\n \n total_pages = book1 + book2\n print(f\"Total pages: {total_pages}\")\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите функцию, которая с помощью `yield` генерирует бесконечную последовательность чисел, а затем используя `itertools` и генераторное выражение, извлекает из неё первые $N$ элементов, удовлетворяющих заданному условию. Результат должен быть представлен в виде отфильтрованного списка, полученного путем преобразования этого генератора."}, {"role": "assistant", "content": "```python\nimport itertools\n\ndef infinite_sequence():\n \"\"\"Генератор бесконечной последовательности чисел.\"\"\"\n num = 0\n while True:\n yield num\n num += 1\n\ndef get_first_n_matching(n, condition_func):\n \"\"\"\n Извлекает первые N элементов из бесконечной последовательности,\n удовлетворяющих условию condition_func.\n \"\"\"\n gen = infinite_sequence()\n # Используем генераторное выражение для фильтрации\n filtered_gen = (x for x in gen if condition_func(x))\n # Используем itertools.islice для извлечения первых N элементов\n result_slice = itertools.islice(filtered_gen, n)\n # Преобразуем в список\n return list(result_slice)\n\nif __name__ == \"__main__\":\n # Пример: найти первые 10 четных чисел, которые больше 5\n N = 10\n condition = lambda x: x % 2 == 0 and x > 5\n \n result = get_first_n_matching(N, condition)\n print(result)\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите рекурсивную функцию для вычисления n-го числа Фибоначчи, используя словарь для сохранения уже вычисленных значений. Оптимизируйте алгоритм с помощью мемоизации, чтобы обеспечить эффективную работу программы при больших значениях входных данных."}, {"role": "assistant", "content": "```python\ndef fibonacci_memo(n, memo=None):\n if memo is None:\n memo = {0: 0, 1: 1}\n \n if n in memo:\n return memo[n]\n \n memo[n] = fibonacci_memo(n - 1, memo) + fibonacci_memo(n - 2, memo)\n return memo[n]\n\nif __name__ == \"__main__\":\n # Пример использования\n n = 100\n print(f\"n-th Fibonacci number ({n}): {fibonacci_memo(n)}\")\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Дан список чисел, из которого необходимо отфильтровать только положительные значения, превышающие заданный порог. Полученный отфильтрованный список нужно отсортировать по убыванию и вывести на экран."}, {"role": "assistant", "content": "```python\ndef filter_and_sort_numbers(numbers: list[float], threshold: float) -> list[float]:\n \"\"\"\n Filters positive numbers greater than the threshold and sorts them in descending order.\n \"\"\"\n filtered_list = [num for num in numbers if num > threshold and num > 0]\n filtered_list.sort(reverse=True)\n return filtered_list\n\nif __name__ == \"__main__\":\n # Example usage\n input_data = [10, -5, 0, 25, 3, 15, -2, 8, 40, 1]\n threshold_value = 5\n \n result = filter_and_sort_numbers(input_data, threshold_value)\n print(result)\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Реализуйте систему управления умным домом, где несколько асинхронных задач одновременно запускают таймеры на выполнение различных действий (включение света, полив растений, проверка датчиков). Программа должна корректно обрабатывать отмену выполнения конкретного таймера по истечении заданного времени, не прерывая работу остальных корутин."}, {"role": "assistant", "content": "```python\nimport asyncio\nimport random\n\nclass SmartHomeSystem:\n def __init__(self):\n self.active_tasks = {}\n\n async def _action_wrapper(self, name, delay, action_func):\n \"\"\"Внутренний воркер для выполнения действия с задержкой.\"\"\"\n try:\n print(f\"[Система] Таймер для '{name}' запущен (ожидание {delay}с)...\")\n await asyncio.sleep(delay)\n await action_func()\n print(f\"[Система] Действие '{name}' успешно выполнено.\")\n except asyncio.CancelledError:\n print(f\"[Система] Таймер для '{name}' был ОТМЕНЕН.\")\n raise\n except Exception as e:\n print(f\"[Система] Ошибка в '{name}': {e}\")\n\n async def schedule_action(self, name, delay, action_func):\n \"\"\"Планирует действие и сохраняет ссылку на задачу для возможности отмены.\"\"\"\n task = asyncio.create_task(self._action_wrapper(name, delay, action_func))\n self.active_tasks[name] = task\n # Удаляем задачу из словаря по завершении, чтобы не копились ссылки\n task.add_done_callback(lambda t: self.active_tasks.pop(name, None))\n\n def cancel_action(self, name):\n \"\"\"Отменяет конкретное запланированное действие.\"\"\"\n if name in self.active_tasks:\n print(f\"[Команда] Отмена запланированного действия: {name}\")\n self.active_tasks[name].cancel()\n else:\n print(f\"[Команда] Действие '{name}' не найдено в очереди.\")\n\n# --- При\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите рекурсивную функцию для вычисления n-го числа Фибоначчи, которая использует словарь для сохранения уже вычисленных значений. Ваша реализация должна эффективно справляться с большими входными данными, избегая избыточных повторных вычислений."}, {"role": "assistant", "content": "```python\ndef fibonacci_memo(n, memo=None):\n if memo is None:\n memo = {0: 0, 1: 1}\n \n if n in memo:\n return memo[n]\n \n memo[n] = fibonacci_memo(n - 1, memo) + fibonacci_memo(n - 2, memo)\n return memo[n]\n\n# Пример использования:\nif __name__ == \"__main__\":\n import sys\n # Увеличиваем лимит рекурсии для работы с большими n\n sys.setrecursionlimit(2000)\n \n n = 100\n print(fibonacci_memo(n))\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите функцию для обработки банковских транзакций, которая выбрасывает кастомное исключение `InsufficientFundsError` при попытке списать сумму, превышающую текущий баланс пользователя. Реализуйте блок обработки, который перехватывает это специфическое исключение и возвращает информативное сообщение об ошибке, не прерывая выполнение основной программы."}, {"role": "assistant", "content": "```python\nclass InsufficientFundsError(Exception):\n \"\"\"Custom exception for insufficient funds in a bank account.\"\"\"\n def __init__(self, balance, amount):\n self.balance = balance\n self.amount = amount\n self.message = f\"Attempted to withdraw {amount}, but balance is only {balance}.\"\n super().__init__(self.message)\n\nclass BankAccount:\n def __init__(self, initial_balance: float):\n self.balance = initial_balance\n\n def withdraw(self, amount: float):\n if amount > self.balance:\n raise InsufficientFundsError(self.balance, amount)\n self.balance -= amount\n return f\"Successfully withdrew {amount}. New balance: {self.balance}\"\n\ndef process_transaction(account: BankAccount, amount: float):\n try:\n result = account.withdraw(amount)\n print(result)\n except InsufficientFundsError as e:\n print(f\"Transaction failed: {e.message}\")\n except Exception as e:\n print(f\"An unexpected error occurred: {e}\")\n\nif __name__ == \"__main__\":\n user_account = BankAccount(1000.0)\n\n # Successful transaction\n process_transaction(user_account, 400.0)\n\n # Transaction that triggers InsufficientFundsError\n process_transaction(user_account, 700.0)\n\n # Another successful transaction to prove program continuity\n process_transaction(user_account, 100.0)\n\n print(f\"Final account balance: {user_account.balance}\")\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите функцию, которая принимает строку и возвращает её очищенную версию, удалив все спецсимволы и лишние пробелы с помощью регулярных выражений. Результат должен быть представлен в виде отформатированной строки, где каждое слово начинается с заглавной буквы, а общая длина текста ограничена заданным срезом."}, {"role": "assistant", "content": "```python\nimport re\n\ndef clean_and_format_string(text: str, max_length: int) -> str:\n \"\"\"\n Очищает строку от спецсимволов, удаляет лишние пробелы,\n делает каждое слово с заглавной буквы и ограничивает длину.\n \"\"\"\n # 1. Удаляем все спецсимволы (оставляем только буквы, цифры и пробелы)\n # [^\\w\\s] находит всё, что не является буквой, цифрой или пробелом\n # Включая подчеркивание, если нужно удалить и его, используем [^a-zA-Z0-9\\s]\n cleaned = re.sub(r'[^a-zA-Zа-яА-Я0-9\\s]', '', text)\n \n # 2. Удаляем лишние пробелы (заменяем множественные пробелы на один и обрезаем края)\n cleaned = re.sub(r'\\s+', ' ', cleaned).strip()\n \n # 3. Делаем каждое слово с заглавной буквы\n formatted = cleaned.title()\n \n # 4. Ограничиваем длину текста срезом\n return formatted[:max_length]\n\n# Пример использования:\nif __name__ == \"__main__\":\n input_str = \" Привет, Мир!!! Это @тестовая #строка... \"\n limit = 20\n result = clean_and_format_string(input_str, limit)\n print(f\"'{result}'\") # Ожидаемый результат: 'Привет Мир Это Тест'\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите программу, которая извлекает из заданной строки все последовательности цифр с помощью регулярных выражений и объединяет их в один список. Затем выведите этот список в виде отформатированной строки, где каждое число отделено от другого запятой и пробелом."}, {"role": "assistant", "content": "```python\nimport re\n\ndef extract_numbers(input_string):\n # Используем регулярное выражение \\d+ для поиска последовательностей цифр\n numbers = re.findall(r'\\d+', input_string)\n # Преобразуем список в строку с разделителем \", \"\n return \", \".join(numbers)\n\nif __name__ == \"__main__\":\n # Пример входной строки\n test_string = \"В 2023 году было найдено 15 объектов, а в 2024 году — еще 42.\"\n \n result = extract_numbers(test_string)\n print(result)\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Создайте класс `Book` с атрибутами названия и автора, реализовав метод `__repr__` для красивого вывода информации об объекте. Добавьте поддержку сложения двух объектов через метод `__add__`, чтобы результатом их суммирования становилось общее количество страниц или объединенная строка с названиями."}, {"role": "assistant", "content": "```python\nclass Book:\n def __init__(self, title: str, author: str, pages: int = 0):\n self.title = title\n self.author = author\n self.pages = pages\n\n def __repr__(self) -> str:\n return f\"Book(title='{self.title}', author='{self.author}', pages={self.pages})\"\n\n def __add__(self, other: 'Book') -> str:\n if isinstance(other, Book):\n return f\"Combined Titles: {self.title} + {other.title}\"\n return NotImplemented\n\n def __add_pages__(self, other: 'Book') -> int:\n if isinstance(other, Book):\n return self.pages + other.pages\n return NotImplemented\n\n# Пример использования для демонстрации логики\nif __name__ == \"__main__\":\n book1 = Book(\"The Hobbit\", \"J.R.R. Tolkien\", 310)\n book2 = Book(\"1984\", \"George Orwell\", 328)\n\n # Вывод через __repr__\n print(book1)\n print(book2)\n\n # Сложение через __add__ (объединенная строка)\n print(book1 + book2)\n\n # Сложение страниц (через отдельный метод или логику в __add__)\n # В рамках ТЗ: \"результатом суммирования становится общее количество страниц ИЛИ объединенная строка\"\n # Реализуем логику: если складываем книги, возвращаем строку, если нужно только страницы - можно расширить.\n # Но согласно ТЗ, сделаем так, чтобы __add__ возвращал строку, а для страниц добавим логику.\n \n # Переопределим __add__ для гибкости, если нужно именно число страниц:\n # Но по условию \"или\", выберем вариант со строкой как основной для __add__\n # А для демонстрации суммы страниц используем прямое обращение или перегрузку.\n \n total_pages = book1.pages + book2.pages\n print(f\"Total pages: {total_pages}\")\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите функцию для обработки банковских транзакций, которая выбрасывает кастомное исключение `InsufficientFundsError` при попытке списать сумму, превышающую текущий баланс пользователя. Программа должна перехватывать это и другие стандартные ошибки, выводя пользователю информативное сообщение о характере возникшей проблемы."}, {"role": "assistant", "content": "```python\nclass InsufficientFundsError(Exception):\n \"\"\"Исключение, возникающее при недостаточном балансе.\"\"\"\n def __init__(self, balance, amount):\n self.balance = balance\n self.amount = amount\n self.message = f\"Недостаточно средств. Баланс: {balance}, Попытка списания: {amount}\"\n super().__init__(self.message)\n\nclass BankAccount:\n def __init__(self, owner: str, initial_balance: float):\n self.owner = owner\n self.balance = initial_balance\n\n def withdraw(self, amount: float):\n if not isinstance(amount, (int, float)):\n raise TypeError(\"Сумма должна быть числом\")\n \n if amount <= 0:\n raise ValueError(\"Сумма списания должна быть положительной\")\n\n if amount > self.balance:\n raise InsufficientFundsError(self.balance, amount)\n \n self.balance -= amount\n print(f\"Транзакция успешна. Списано: {amount}. Новый баланс: {self.balance}\")\n\ndef process_transaction(account: BankAccount, amount: float):\n try:\n account.withdraw(amount)\n except InsufficientFundsError as e:\n print(f\"Ошибка транзакции: {e}\")\n except ValueError as e:\n print(f\"Ошибка ввода: {e}\")\n except TypeError as e:\n print(f\"Ошибка типа данных: {e}\")\n except Exception as e:\n print(f\"Произошла непредвиденная ошибка: {e}\")\n\nif __name__ == \"__main__\":\n user_account = BankAccount(\"Ivan Ivanov\", 1000.0)\n\n # 1. Успешная транзакция\n process_transaction(user_account, 500.0)\n\n # 2. Ошибка: Недостаточно средств\n process_transaction(user_account, 1000.0)\n\n # 3. Ошибка: Отрицательная сумма\n process_transaction(user_account, -50.0)\n\n # 4. Ошибка: Неверный тип данных\n process_transaction(user_account, \"100\")\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Разработайте систему валидации банковских транзакций, которая перехватывает стандартные ошибки типов данных и выбрасывает кастомное исключение `InsufficientFundsError` при попытке списания суммы, превышающей баланс счета. Реализуйте иерархию пользовательских ошибок и блок обработки, обеспечивающий корректное логирование причин отказа в операции."}, {"role": "assistant", "content": "```python\n\"50.0\", # TypeError -> InvalidTransactionError\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите асинхронную программу, которая одновременно запускает три корутины, имитирующие выполнение различных задач с помощью задержек `asyncio.sleep`. Каждая задача должна выводить свое порядковое число через случайный промежуток времени, не блокируя выполнение остальных функций."}, {"role": "assistant", "content": "```python\nimport asyncio\nimport random\n\nasync def task(task_id):\n delay = random.uniform(0.5, 2.0)\n await asyncio.sleep(delay)\n print(f\"Задача №{task_id} завершена (задержка: {delay:.2f} сек)\")\n\nasync def main():\n tasks = [task(i) for i in range(1, 4)]\n await asyncio.gather(*tasks)\n\nif __name__ == \"__main__\":\n asyncio.run(main())\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите программу, которая извлекает из произвольного текста все последовательности цифр с помощью регулярных выражений и объединяет их в одну строку. Полученный результат необходимо отформатировать, выделив первые три символа заглавными буквами и добавив в конец порядковый номер задачи."}, {"role": "assistant", "content": "```python\nimport re\n\ndef solve(text: str, task_number: int) -> str:\n # Извлекаем все последовательности цифр\n digits_list = re.findall(r'\\d+', text)\n \n # Объединяем в одну строку\n combined_digits = \"\".join(digits_list)\n \n if not combined_digits:\n return f\"Task #{task_number}\"\n\n # Выделяем первые три символа (если их меньше 3, берем все)\n # В контексте цифр \"заглавные буквы\" не имеют смысла, \n # но согласно условию задачи (выделить первые три символа заглавными),\n # если бы там были буквы, мы бы их изменили. \n # Для цифр операция.upper() не меняет вид, но мы соблюдаем логику алгоритма.\n \n prefix = combined_digits[:3].upper()\n suffix = combined_digits[3:]\n \n result = f\"{prefix}{suffix}\"\n \n # Добавляем порядковый номер задачи в конец\n return f\"{result} #{task_number}\"\n\nif __name__ == \"__main__\":\n sample_text = \"В тексте есть числа 123, 456 и еще 789!\"\n print(solve(sample_text, 1))\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите функцию, которая возвращает итератор, генерирующий сумму квадратов чисел, но при этом должна учитывать разницу в потреблении памяти между списковым включением и выражением-генератором при работе с бесконечной последовательностью из `itertools.count`. Будьте внимательны: использование `yield` внутри цикла может привести к неожиданному поведению, если попытаться преобразовать результат в список до завершения итерации."}, {"role": "assistant", "content": "```python\nimport itertools\n\ndef sum_of_squares_generator():\n \"\"\"\n Returns an iterator that generates the sum of squares of numbers.\n Using a generator expression to ensure O(1) memory complexity\n even when dealing with infinite sequences.\n \"\"\"\n # itertools.count(1) provides an infinite sequence: 1, 2, 3,...\n # We use a generator expression to avoid creating a massive list in memory.\n # Note: Since the sequence is infinite, we cannot convert the whole thing to a list.\n # We use itertools.accumulate to yield the running sum of squares.\n \n numbers = itertools.count(1)\n squares = (n * n for n in numbers)\n \n # itertools.accumulate is an efficient way to yield running totals\n return itertools.accumulate(squares)\n\n# Example usage (demonstrating it works for a finite prefix of the infinite sequence):\nif __name__ == \"__main__\":\n gen = sum_of_squares_generator()\n \n # To prevent infinite loop in demonstration, we take only the first 5 sums\n # 1^2 = 1\n # 1^2 + 2^2 = 5\n # 1^2 + 2^2 + 3^2 = 14\n # 1^2 + 2^2 + 3^2 + 4^2 = 30\n # 1^2 + 2^2 + 3^2 + 4^2 + 5^2 = 55\n results = [next(gen) for _ in range(5)]\n print(results)\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите функцию для вычисления n-го числа Фибоначчи, которая при использовании стандартной рекурсии вызывает переполнение стека или работает бесконечно долго при больших значениях. Реализуйте оптимизацию с помощью мемоизации, чтобы алгоритм возвращал результат мгновенно, не пересчитывая уже изученные ветви дерева вызовов."}, {"role": "assistant", "content": "```python\ndef fibonacci_recursive(n, memo=None):\n if memo is None:\n memo = {}\n \n if n in memo:\n return memo[n]\n \n if n <= 0:\n return 0\n elif n == 1:\n return 1\n \n memo[n] = fibonacci_recursive(n - 1, memo) + fibonacci_recursive(n - 2, memo)\n return memo[n]\n\n# Пример использования:\n# n = 100\n# print(fibonacci_recursive(n))\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Разработайте систему валидации банковских транзакций, которая выбрасывает кастомное исключение `InsufficientFundsError`, если сумма перевода превышает доступный баланс пользователя. Реализуйте обработку этого и стандартного исключения `ValueError` для предотвращения аварийного завершения программы при некорректном вводе данных."}, {"role": "assistant", "content": "```python\nclass InsufficientFundsError(Exception):\n \"\"\"Исключение, возникающее при недостаточном балансе.\"\"\"\n def __init__(self, balance, amount):\n self.balance = balance\n self.amount = amount\n super().__init__(f\"Недостаточно средств: баланс {balance}, попытка перевода {amount}\")\n\nclass BankAccount:\n def __init__(self, initial_balance: float):\n if initial_balance < 0:\n raise ValueError(\"Начальный баланс не может быть отрицательным\")\n self.balance = initial_balance\n\n def transfer(self, amount: float):\n if not isinstance(amount, (int, float)):\n raise ValueError(\"Сумма перевода должна быть числом\")\n if amount <= 0:\n raise ValueError(\"Сумма перевода должна быть больше нуля\")\n \n if amount > self.balance:\n raise InsufficientFundsError(self.balance, amount)\n \n self.balance -= amount\n print(f\"Транзакция успешна. Остаток: {self.balance}\")\n\ndef process_transaction(account: BankAccount, amount_str: str):\n try:\n amount = float(amount_str)\n account.transfer(amount)\n except ValueError as e:\n print(f\"Ошибка ввода данных: {e}\")\n except InsufficientFundsError as e:\n print(f\"Ошибка транзакции: {e}\")\n except Exception as e:\n print(f\"Непредвиденная ошибка: {e}\")\n\nif __name__ == \"__main__\":\n user_account = BankAccount(1000.0)\n\n # Тест 1: Успешная транзакция\n print(\"Тест 1 (Успех):\")\n process_transaction(user_account, \"250.50\")\n\n # Тест 2: Недостаточно средств\n print(\"\\nТест 2 (InsufficientFundsError):\")\n process_transaction(user_account, \"1000.0\")\n\n # Тест 3: Некорректный ввод (строка вместо числа)\n print(\"\\nТест 3 (ValueError - не число):\")\n process_transaction(user_account, \"abc\")\n\n # Тест 4: Некорректный ввод (отрицательное число)\n print(\"\\nТест 4 (ValueError - отрицательное число):\")\n process_transaction(user_account, \"-50\")\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите программу, которая принимает на вход целое число и выводит, является ли оно простым, а также вычисляет его факториал. Дополнительно программа должна найти наибольший общий делитель (НОД) введенного числа и числа 835024."}, {"role": "assistant", "content": "```python\nimport math\n\ndef is_prime(n):\n if n < 2:\n return False\n for i in range(2, int(math.sqrt(n) + 1)):\n if n % i == 0:\n return False\n return True\n\ndef solve():\n try:\n num = int(input())\n \n # Проверка на простое число\n prime_status = is_prime(num)\n print(f\"Is prime: {prime_status}\")\n \n # Вычисление факториала\n # Примечание: факториал очень быстро растет, \n # для больших чисел может потребоваться много памяти\n if num < 0:\n print(\"Factorial: Undefined for negative numbers\")\n else:\n factorial_val = math.factorial(num)\n print(f\"Factorial: {factorial_val}\")\n \n # Нахождение НОД с числом 835024\n target_num = 835024\n gcd_val = math.gcd(num, target_num)\n print(f\"GCD with {target_num}: {gcd_val}\")\n \n except ValueError:\n print(\"Please enter a valid integer.\")\n except OverflowError:\n print(\"Factorial result is too large to display.\")\n\nif __name__ == \"__main__\":\n solve()\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Создайте программу, которая принимает на вход строку из слов и подсчитывает частоту появления каждого слова с помощью `Counter`. Затем преобразуйте полученный результат в `defaultdict`, чтобы сгруппировать слова по их первой букве."}, {"role": "assistant", "content": "```python\nfrom collections import Counter, defaultdict\n\ndef process_words(input_string: str) -> defaultdict:\n # Очистка строки от пунктуации и приведение к нижнему регистру\n # Для простоты задачи считаем, что слова разделены пробелами\n words = input_string.lower().split()\n \n # Подсчет частоты слов с помощью Counter\n word_counts = Counter(words)\n \n # Создание defaultdict для группировки по первой букве\n grouped_by_letter = defaultdict(dict)\n \n for word, count in word_counts.items():\n if word:\n first_letter = word[0]\n grouped_by_letter[first_letter][word] = count\n \n return grouped_by_letter\n\nif __name__ == \"__main__\":\n text = \"apple banana apple cherry banana apple date banana elderberry\"\n result = process_words(text)\n \n # Вывод результата для проверки\n for letter in sorted(result.keys()):\n print(f\"'{letter}': {dict(result[letter])}\")\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите программу, которая извлекает из текста все фрагменты, соответствующие шаблону «слово + число» (например, `item123`), используя регулярные выражения. Полученные данные необходимо преобразовать в список, где каждое слово приведено к нижнему регистру, �� число отделено от него с помощью форматированной строки."}, {"role": "assistant", "content": "```python\nimport re\n\ndef extract_and_format_patterns(text: str) -> list[str]:\n # Шаблон: последовательность букв (слово) + последовательность цифр\n pattern = r'([a-zA-Z]+)(\\d+)'\n \n matches = re.findall(pattern, text)\n \n # Преобразование: слово в нижний регистр + форматированная строка с числом\n return [f\"{word.lower()}_{number}\" for word, number in matches]\n\nif __name__ == \"__main__\":\n sample_text = \"Check Item123, user45, and some random TEXT999 or Item_01 (which should be ignored).\"\n result = extract_and_format_patterns(sample_text)\n print(result)\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Дан список слов, из которого необходимо составить словарь, содержащий уникальные слова и количество их повторений в исходном тексте. Для решения используйте инструменты из модуля `collections`, чтобы эффективно подсчитать частоту каждого элемента."}, {"role": "assistant", "content": "```python\nfrom collections import Counter\n\ndef count_word_frequencies(word_list):\n \"\"\"\n Creates a dictionary containing unique words and their occurrence counts.\n \"\"\"\n return dict(Counter(word_list))\n\nif __name__ == \"__main__\":\n # Example input\n words = [\"apple\", \"banana\", \"apple\", \"orange\", \"banana\", \"apple\", \"grape\", \"banana\"]\n \n # Get frequency dictionary\n result = count_word_frequencies(words)\n \n # Output result\n print(result)\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите функцию, которая выбрасывает кастомное исключение при передаче отрицательного числа, но при этом должна корректно обрабатывать ситуацию, когда блок `except` перехватывает не только вашу ошибку, но и системное исключение, вызванное логической ошибкой в самом обработчике. В чем заключается подвох при попытке обработать исключение внутри блока `except`, если внутри него происходит повторный вызов функции с тем же некорректным аргументом?"}, {"role": "assistant", "content": "```python\nclass NegativeNumberError(Exception):\n \"\"\"Custom exception for negative numbers.\"\"\"\n pass\n\ndef check_positive(number: int):\n if number < 0:\n raise NegativeNumberError(f\"Negative number encountered: {number}\")\n return number\n\ndef process_data(value: int):\n try:\n print(f\"Attempting to process: {value}\")\n return check_positive(value)\n except (NegativeNumberError, Exception) as e:\n print(f\"Caught exception: {type(e).__name__} - {e}\")\n \n # The pitfall: If we call the same function with the same invalid argument \n # inside the except block, we trigger a recursive exception loop.\n # If the except block catches 'Exception', it will catch the new error,\n # leading to infinite recursion or a RecursionError.\n \n print(\"Attempting recovery inside except block...\")\n # This line triggers the pitfall: calling the function with the same bad value\n return check_positive(value)\n\nif __name__ == \"__main__\":\n # Scenario 1: Demonstrating the error and the pitfall\n # If we run process_data(-5), it will raise NegativeNumberError, \n # enter 'except', and then call check_positive(-5) again, \n # causing an infinite loop of exceptions until RecursionError.\n \n print(\"--- Starting execution (this will cause RecursionError due to the pitfall) ---\")\n try:\n process_data(-5)\n except RecursionError:\n print(\"Caught expected RecursionError: The pitfall is a recursive exception loop.\")\n except Exception as e:\n print(f\"Final catch: {e}\")\n\n print(\"\\n--- Starting safe execution ---\")\n # Scenario 2: Demonstrating correct behavior with a valid number\n print(f\"Result for positive: {process_data(10)}\")\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Н��пиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Создайте класс `Rectangle` с атрибутами сторон, а затем реализуйте его наследование в классе `Square` для работы с одной стороной. Добавьте магические методы `__repr__` для красивого вывода объекта и `__add__` для суммирования площадей двух прямоугольников."}, {"role": "assistant", "content": "```python\nclass Rectangle:\n def __init__(self, width: float, height: float):\n self.width = width\n self.height = height\n\n @property\n def area(self) -> float:\n return self.width * self.height\n\n def __repr__(self) -> str:\n return f\"Rectangle(width={self.width}, height={self.height})\"\n\n def __add__(self, other: 'Rectangle') -> float:\n if not isinstance(other, Rectangle):\n raise TypeError(\"Can only add Rectangle to Rectangle\")\n return self.area + other.area\n\n\nclass Square(Rectangle):\n def __init__(self, side: float):\n super().__init__(side, side)\n\n def __repr__(self) -> str:\n return f\"Square(side={self.width})\"\n\n\nif __name__ == \"__main__\":\n rect = Rectangle(10, 5)\n square = Square(4)\n another_rect = Rectangle(2, 3)\n\n print(f\"Rectangle: {rect}\")\n print(f\"Square: {square}\")\n print(f\"Area of Rectangle: {rect.area}\")\n print(f\"Area of Square: {square.area}\")\n print(f\"Sum of areas (rect + another_rect): {rect + another_rect}\")\n print(f\"Sum of areas (rect + square): {rect + square}\")\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Найдите произведение всех простых чисел, которые являются делителями факториала числа $n$, где $n$ — это наибольший общий делитель чисел 120 и 45. Учтите, что при вычислении результата необходимо проверить, не является ли само итоговое произведение простым числом."}, {"role": "assistant", "content": "```python\nimport math\n\ndef is_prime(num):\n if num < 2:\n return False\n for i in range(2, int(math.sqrt(num)) + 1):\n if num % i == 0:\n return False\n return True\n\ndef solve():\n # 1. Находим n = НОД(120, 45)\n n = math.gcd(120, 45)\n \n # 2. Находим все простые числа, которые являются делителями n!\n # Делителями n! являются все простые числа, не превосходящие n.\n primes_divisors = []\n for i in range(2, n + 1):\n if is_prime(i):\n primes_divisors.append(i)\n \n # 3. Вычисляем произведение этих простых чисел\n product = 1\n for p in primes_divisors:\n product *= p\n \n # 4. Проверяем, является ли итоговое произведение простым числом\n is_product_prime = is_prime(product)\n \n # Вывод результата (согласно условию задачи, нам нужно само произведение)\n # Но для полноты логики проверим условие.\n print(product)\n\nif __name__ == \"__main__\":\n solve()\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите программу, которая извлекает из заданной строки все последовательности цифр, используя регулярные выражения, и объединяет их в одну строку. Полученный результат необходимо отформатировать, применив к нему срез для удаления первого и последнего символа, и вывести в консоль с использованием f-строки."}, {"role": "assistant", "content": "```python\nimport re\n\ndef process_digits(input_string: str) -> None:\n # Извлекаем все последовательности цифр\n digits_list = re.findall(r'\\d+', input_string)\n \n # Объединяем их в одну строку\n combined_digits = \"\".join(digits_list)\n \n # Проверяем, достаточно ли символов для среза\n if len(combined_digits) > 2:\n # Применяем срез для ��даления первого и последнего символа\n result = combined_digits[1:-1]\n else:\n result = \"\"\n \n # Выводим результат с использованием f-строки\n print(f\"{result}\")\n\nif __name__ == \"__main__\":\n # Пример входной строки\n test_string = \"abc123def456ghi789\"\n process_digits(test_string)\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите программу, которая сканирует заданную директорию с помощью `pathlib`, собирает информацию о расширениях всех файлов и сохраняет итоговую статистику в формате CSV. Затем прочитайте полученный CSV-файл и преобразуйте эти данные в структурированный JSON-объект, содержащий количество файлов для каждого типа расширения."}, {"role": "assistant", "content": "```python\nimport csv\nimport json\nfrom pathlib import Path\nfrom collections import Counter\n\ndef scan_directory_to_csv(directory_path: str, output_csv: str):\n path = Path(directory_path)\n if not path.is_dir():\n raise ValueError(f\"The path {directory_path} is not a valid directory.\")\n\n extension_counts = Counter()\n\n for file_path in path.rglob('*'):\n if file_path.is_file():\n # Get extension, handle files without extension as 'no_extension'\n ext = file_path.suffix.lower()\n if not ext:\n ext = 'no_extension'\n extension_counts[ext] += 1\n\n with open(output_csv, mode='w', newline='', encoding='utf-8') as csv_file:\n writer = csv.writer(csv_file)\n writer.writerow(['extension', 'count'])\n for ext, count in extension_counts.items():\n writer.writerow([ext, count])\n\ndef csv_to_json(input_csv: str, output_json: str):\n data_dict = {}\n \n with open(input_csv, mode='r', encoding='utf-8') as csv_file:\n reader = csv.DictReader(csv_file)\n for row in reader:\n data_dict[row['extension']] = int(row['count'])\n\n with open(output_json, mode='w', encoding='utf-8') as json_file:\n json.dump(data_dict, json_file, indent=4)\n \n return json.dumps(data_dict, indent=4)\n\nif __name__ == \"__main__\":\n # Configuration\n TARGET_DIR = \".\" # Current directory\n CSV_FILENAME = \"file_stats.csv\"\n JSON_FILENAME = \"file_stats.json\"\n\n # Step 1: Scan and save to CSV\n scan_directory_to_csv(TARGET_DIR, CSV_FILENAME)\n\n # Step 2: Read CSV and convert to JSON\n json_output = csv_to_json(CSV_FILENAME, JSON_FILENAME)\n\n # Print result to console\n print(json_output)\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите асинхронную программу, которая одновременно запускает три корутины, имитирующие выполнение различных задач с помощью случайных задержек. Каждая задача должна выводить сообщение о своем завершении через заданный интервал времени, используя функции модуля asyncio."}, {"role": "assistant", "content": "```python\nimport asyncio\nimport random\n\nasync def task_worker(name: str, delay: float):\n \"\"\"\n Имитирует выполнение задачи с заданной задержкой.\n \"\"\"\n print(f\"Задача '{name}' запущена (ожидание {delay:.2f} сек.)\")\n await asyncio.sleep(delay)\n print(f\"Задача '{name}' завершена\")\n\nasync def main():\n # Список задач с разными именами и случайными задержками\n tasks = [\n task_worker(\"A\", random.uniform(1, 3)),\n task_worker(\"B\", random.uniform(1, 3)),\n task_worker(\"C\", random.uniform(1, 3)),\n ]\n \n # Одновременный запуск всех корутин\n await asyncio.gather(*tasks)\n\nif __name__ == \"__main__\":\n asyncio.run(main())\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите функцию, которая возвращает бесконечную последовательность чисел, используя `yield`, но при этом потребляет фиксированный объем памяти даже при попытке преобразовать результат в список через генераторное выражение. В чем заключается логическая ловушка при попытке вычислить длину такой последовательности с помощью `len()` или при использовании `itertools.islice` для получения всех элементов?"}, {"role": "assistant", "content": "```python\nimport itertools\n\ndef infinite_sequence():\n \"\"\"\n Генератор бесконечной последовательности.\n Потребляет O(1) памяти, так как хранит только текущее состояние.\n \"\"\"\n n = 0\n while True:\n yield n\n n += 1\n\ndef solve_problem():\n # 1. Демонстрация бесконечной последовательности\n gen = infinite_sequence()\n \n # 2. Попытка преобразования в список (вызовет MemoryError или зависание)\n # list(gen) # <--- Это приведет к переполнению памяти\n \n # 3. Использование itertools.islice (безопасно, так как ограничивает поток)\n limited_gen = itertools.islice(infinite_sequence(), 5)\n print(f\"First 5 elements: {list(limited_gen)}\")\n\n # 4. Попытка вычислить len()\n # len(infinite_sequence()) # <--- TypeError: object of type 'generator' has no len()\n \n # 5. Попытка получить \"все\" элементы через islice (бесконечный цикл)\n # list(itertools.islice(infinite_sequence(), float('inf'))) # <--- Бесконечное выполнение\n \n return \"Logic Trap Explanation:\"\n \"\"\"\n ЛОГИЧЕСКАЯ ЛОВУШКА:\n 1. len(): Функция len() требует, чтобы объект имел фиксированный размер (поддерживал __len__). \n Генератор — это итератор, он вычисляет значения \"на лету\" и не знает, сколько их будет.\n Попытка вызвать len() на генераторе вызовет TypeError.\n \n 2. itertools.islice: Хотя islice позволяет брать части бесконечного потока, попытка \n получить \"все\" элементы (например, через list(islice(gen, None))) превращает \n поток в конечный список в памяти. Это мгновенно приводит к MemoryError, \n так как бесконечное количество элементов невозможно уместить в RAM.\n \"\"\"\n\nif __name__ == \"__main__\":\n print(solve_problem())\n solve_problem()\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите функцию, которая находит минимальный элемент в списке, предварительно отфильтровав его по условию строгого неравенства, но при этом должна вернуть исходный список, если после фильтрации он стал пустым. Учтите, что алгоритм должен корректно обрабатывать ситуацию, когда единственный оставшийся элемент является одновременно и минимальным, и максимальным значением."}, {"role": "assistant", "content": "```python\ndef find_min_after_filtering(data, condition_func):\n \"\"\"\n Находит минимальный элемент в списке после фильтрации.\n Если после фильтрации список пуст, возвращает исходный список.\n \"\"\"\n filtered_list = [x for x in data if condition_func(x)]\n \n if not filtered_list:\n return data\n \n return min(filtered_list)\n\n# Пример использования:\nif __name__ == \"__main__\":\n # Тест 1: Обычный случай\n nums = [10, 5, 8, 20, 3]\n # Условие: строго больше 5\n print(find_min_after_filtering(nums, lambda x: x > 5)) # Ожидаем 8\n\n # Тест 2: После фильтрации один элемент (он и min, и max)\n nums2 = [1, 2, 10, 3]\n # Условие: строго больше 9\n print(find_min_after_filtering(nums2, lambda x: x > 9)) # Ожидаем 10\n\n # Тест 3: После фильтрации список ��уст\n nums3 = [1, 2, 3]\n # Условие: строго больше 10\n print(find_min_after_filtering(nums3, lambda x: x > 10)) # Ожидаем [1, 2, 3]\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Данная строка содержит скрытый паттерн, который при обычном поиске подстроки возвращает пустой результат из-за специфики работы регулярных выражений с невидимыми символами. Напишите функцию, которая с помощью срезов и модуля `re` извлекает только буквенно-цифровые символы, игнорируя все управляющие последовательности и спецсимволы."}, {"role": "assistant", "content": "```python\nimport re\n\ndef extract_alphanumeric(input_string: str) -> str:\n \"\"\"\n Extracts only alphanumeric characters from a string, \n ignoring control characters and special symbols.\n \"\"\"\n # Step 1: Use slicing/indexing to ensure we are working with a valid string range\n # (though slicing the whole string is standard, it demonstrates the requirement)\n clean_slice = input_string[:]\n \n # Step 2: Use regex to find all alphanumeric characters (\\w includes underscores, \n # so we use [a-zA-Z0-9] to strictly follow \"alphanumeric\" definition if underscores are excluded)\n # However, standard alphanumeric in regex context is often [a-zA-Z0-9].\n # We use [a-zA-Z0-9] to avoid catching underscores which are often considered \"special\" in strict contexts.\n pattern = re.compile(r'[a-zA-Z0-9]')\n \n return \"\".join(pattern.findall(clean_slice))\n\n# Example usage/test case:\nif __name__ == \"__main__\":\n # String containing hidden control characters (null, bell, backspace) and special symbols\n hidden_string = \"User\\x00Name\\x07_123!\\x08@#$\"\n result = extract_alphanumeric(hidden_string)\n print(result) # Expected output: UserName123\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Найдите сумму всех простых чисел, которые являются делителями факториала числа $N$, где $N$ — это наибольший общий делитель между 144 и 216. Учтите, что при вычислении факториала для проверки условий необходимо использовать только те простые числа, которые не входят в разложение самого числа $N$."}, {"role": "assistant", "content": "```python\nimport math\n\ndef get_gcd(a, b):\n return math.gcd(a, b)\n\ndef get_prime_factors(n):\n factors = set()\n d = 2\n temp = n\n while d * d <= temp:\n if temp % d == 0:\n factors.add(d)\n while temp % d == 0:\n temp //= d\n d += 1\n if temp > 1:\n factors.add(temp)\n return factors\n\ndef solve():\n n = get_gcd(144, 216)\n # N = 72\n \n # Prime factors of N\n n_prime_factors = get_prime_factors(n)\n \n # We need to find all prime numbers that are divisors of N!\n # A prime p is a divisor of N! if and only if p <= N.\n # The problem states: \"use only those prime numbers that do not belong to the factorization of N itself\".\n # This means we need primes p such that p <= N AND p is NOT in n_prime_factors.\n \n primes = []\n is_prime = [True] * (n + 1)\n for p in range(2, n + 1):\n if is_prime[p]:\n primes.append(p)\n for i in range(p * p, n + 1, p):\n is_prime[i] = False\n \n result_sum = sum(p for p in primes if p not in n_prime_factors)\n return result_sum\n\nif __name__ == \"__main__\":\n print(solve())\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите программу, которая находит наибольший общий делитель (НОД) между факториалом числа $n$ и произведением всех простых чисел, не превосходящих $n$. Для генерации входного числа используйте значение `seed=563621`."}, {"role": "assistant", "content": "```python\nimport math\nimport random\n\ndef get_primes(n):\n primes = []\n is_prime = [True] * (n + 1)\n for p in range(2, n + 1):\n if is_prime[p]:\n primes.append(p)\n for i in range(p * p, n + 1, p):\n is_prime[i] = False\n return primes\n\ndef solve():\n random.seed(563621)\n n = random.randint(1, 100) # Ограничение для корректной работы с большими числами\n \n # Факториал n\n fact_n = math.factorial(n)\n \n # Произведение всех простых чисел <= n\n primes = get_primes(n)\n prod_primes = 1\n for p in primes:\n prod_primes *= p\n \n # НОД(n!, product(primes <= n))\n # Заметим, что все простые числа <= n являются множителями n!\n # Следовательно, НОД будет равен самому произведению простых чисел\n result = math.gcd(fact_n, prod_primes)\n \n print(result)\n\nif __name__ == \"__main__\":\n solve()\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Дан список идентификаторов товаров, где некоторые значения являются кортежами, содержащими дубликаты внутри себя. Найдите количество уникальных элементов в каждом кортеже, используя `Counter`, но учтите, что при поиске пересечения множеств с кортежами как ключами словаря возникнет ошибка типизации."}, {"role": "assistant", "content": "```python\nfrom collections import Counter\n\ndef count_unique_elements_in_tuples(data_list):\n \"\"\"\n Calculates the number of unique elements in each tuple within the list.\n Handles the requirement of using Counter and avoids type errors \n by processing tuples correctly.\n \"\"\"\n results = []\n \n for item in data_list:\n if isinstance(item, tuple):\n # Use Counter to count occurrences within the tuple\n counts = Counter(item)\n # The number of unique elements is the number of keys in the Counter\n unique_count = len(counts)\n results.append(unique_count)\n else:\n # If the item is not a tuple, we treat it as a single element\n results.append(1)\n \n return results\n\n# Example usage:\nif __name__ == \"__main__\":\n # Input list containing identifiers and tuples with duplicates\n identifiers = [\n \"prod_1\", \n (1, 2, 2, 3, 3, 3), \n \"prod_2\", \n (10, 10, 10), \n (1, 2, 3, 4, 5), \n (1, 1, 1, 1),\n \"prod_3\"\n ]\n\n # Expected logic:\n # \"prod_1\" -> 1\n # (1, 2, 2, 3, 3, 3) -> 3 unique (1, 2, 3)\n # \"prod_2\" -> 1\n # (10, 10, 10) -> 1 unique (10)\n # (1, 2, 3, 4, 5) -> 5 unique\n # (1, 1, 1, 1) -> 1 unique\n # \"prod_3\" -> 1\n\n output = count_unique_elements_in_tuples(identifiers)\n print(output)\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Найдите наибольший общий делитель между факториалом числа $n$ и произведением всех простых чисел, не превосходящих $n$, при условии, что $n$ само является простым числом. Учтите, что для корректного результата необходимо правильно обработать случай, когда $n$ равно двум, и учесть специфику распределения простых множителей в факториале."}, {"role": "assistant", "content": "```python\ndef solve(n):\n if n < 2:\n return 0\n \n def is_prime(num):\n if num < 2:\n return False\n for i in range(2, int(num**0.5) + 1):\n if num % i == 0:\n return False\n return True\n\n if not is_prime(n):\n return None\n\n def get_primes_up_to(limit):\n primes = []\n for i in range(2, limit + 1):\n if is_prime(i):\n primes.append(i)\n return primes\n\n primes_up_to_n = get_primes_up_to(n)\n \n # The product of all primes <= n is P = p1 * p2 *... * pn\n # The factorial n! = 1 * 2 *... * n\n # Since n is prime, all primes in the product P are <= n.\n # Every prime p <= n is a factor in n! (because n! contains all integers from 1 to n).\n # Therefore, the GCD of n! and the product of primes <= n is simply the product of primes <= n.\n \n product = 1\n for p in primes_up_to_n:\n product *= p\n \n return product\n\n# Example usage:\n# n = 2 -> primes: [2], product: 2. GCD(2!, 2) = 2.\n# n = 3 -> primes: [2, 3], product: 6. GCD(3!, 6) = 6.\n# n = 5 -> primes: [2, 3, 5], product: 30. GCD(5!, 30) = 30.\nif __name__ == \"__main__\":\n import sys\n for val in [2, 3, 5, 7, 11]:\n print(f\"n={val}, result={solve(val)}\")\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите программу, которая с помощью генератора списков фильтрует четные числа из заданного диапазона, а затем преобразует их в бесконечный поток данных с использованием `yield`. Для оптимизации процесса и эффективного перебора полученных значений примените функции из модуля `itertools`."}, {"role": "assistant", "content": "```python\nimport itertools\n\ndef get_even_stream(start, end):\n # Фильтруем четные числа из диапазона с помощью генератора списков\n even_numbers = [x for x in range(start, end + 1) if x % 2 == 0]\n \n # Преобразуем список в бесконечный поток данных с помощью yield\n # Используем itertools.cycle для создания бесконечного повторения\n stream = itertools.cycle(even_numbers)\n \n for value in stream:\n yield value\n\nif __name__ == \"__main__\":\n # Пример использования: берем диапазон от 1 до 10\n # Четные: [2, 4, 6, 8, 10]\n infinite_even_gen = get_even_stream(1, 10)\n \n # Выводим первые 15 элементов бесконечного потока для демонстрации\n print(list(itertools.islice(infinite_even_gen, 15)))\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите рекурсивную функцию для вычисления n-го числа Фибоначчи, которая использует словарь для сохранения уже вычисленных значений. Оптимизируйте алгоритм с помощью мемоизации, чтобы избежать избыточных вычислений и обеспечить быстрый ответ при больших входных данных."}, {"role": "assistant", "content": "```python\ndef fibonacci(n, memo=None):\n if memo is None:\n memo = {0: 0, 1: 1}\n \n if n in memo:\n return memo[n]\n \n memo[n] = fibonacci(n - 1, memo) + fibonacci(n - 2, memo)\n return memo[n]\n\nif __name__ == \"__main__\":\n # Пример использования\n n = 100\n print(f\"{n}-е число Фибоначчи: {fibonacci(n)}\")\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите программу для проверки возраста пользователя, которая выбрасывает кастомное исключение `InvalidAgeError`, если введенное значение отрицательное. Реализуйте обработку этого исключения и стандартной ошибки типа данных с помощью блоков `try-except`, чтобы программа не завершалась аварийно при некорректном вводе."}, {"role": "assistant", "content": "```python\nclass InvalidAgeError(Exception):\n \"\"\"Исключение, возникающее при вводе отрицательного возраста.\"\"\"\n pass\n\ndef check_age():\n try:\n user_input = input(\"Введите ваш возраст: \")\n age = int(user_input)\n\n if age < 0:\n raise InvalidAgeError(f\"Ошибка: Возраст не может быть отрицательным ({age}).\")\n \n print(f\"Ваш возраст: {age}. Проверка пройдена.\")\n\n except ValueError:\n print(\"Ошибка: Пожалуйста, введите целое число.\")\n except InvalidAgeError as e:\n print(e)\n except Exception as e:\n print(f\"Произошла непредвиденная ошибка: {e}\")\n\nif __name__ == \"__main__\":\n check_age()\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. На��иши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите рекурсивную функцию для вычисления n-го числа в модифицированной последовательности Фибоначчи, где каждое следующее число является суммой трех предыдущих. Для оптимизации производительности при больших значениях n необходимо реализовать механизм мемоизации, чтобы избежать избыточных вычислений."}, {"role": "assistant", "content": "```python\ndef fib_three(n, memo=None):\n if memo is None:\n memo = {0: 0, 1: 1, 2: 1}\n \n if n in memo:\n return memo[n]\n \n memo[n] = fib_three(n - 1, memo) + fib_three(n - 2, memo) + fib_three(n - 3, memo)\n return memo[n]\n\n# Пример использования:\n# n = 50\n# print(fib_three(n))\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Дан список целых чисел, из которого необходимо отфильтровать только положительные значения, исключив дубликаты. Полученный отфильтрованный список нужно отсортировать по убыванию и вернуть первый элемент, если список не пуст."}, {"role": "assistant", "content": "```python\ndef solve(numbers: list[int]) -> int | None:\n filtered_unique = sorted({x for x in numbers if x > 0}, reverse=True)\n return filtered_unique[0] if filtered_unique else None\n\nif __name__ == \"__main__\":\n # Test cases\n assert solve([1, -2, 3, 3, 2, -5, 0, 4]) == 4\n assert solve([-1, -2, 0]) is None\n assert solve([10, 10, 10]) == 10\n assert solve([]) is None\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Разработайте систему обработки пользовательских исключений, где попытка перехвата кастомного класса ошибки внутри блока `finally` должна привести к непредсказуемому поведению программы. Учтите, что при возникновении ошибки в блоке `except` выполнение кода в `finally` может полностью подавить исходное исключение, если в нем произойдет новое."}, {"role": "assistant", "content": "```python\nclass CustomError(Exception):\n \"\"\"Кастомный класс ошибки.\"\"\"\n pass\n\nclass SuppressionError(Exception):\n \"\"\"Ошибка, которая подавляет основную ошибку.\"\"\"\n pass\n\ndef demonstrate_exception_suppression():\n try:\n print(\"--- Шаг 1: Генерация CustomError ---\")\n raise CustomError(\"Первоначальная ошибка (CustomError)\")\n \n except CustomError as e:\n print(f\"Перехвачено в except: {e}\")\n print(\"--- Шаг 2: Генерация новой ошибки внутри except ---\")\n # Если здесь возникнет ошибка, она будет \"в полете\"\n raise SuppressionError(\"Ошибка, возникшая в блоке except\")\n \n except Exception as e:\n print(f\"Этот блок не должен выполниться: {e}\")\n \n finally:\n print(\"--- Шаг 3: Выполнение блока finally ---\")\n try:\n print(\"Попытка перехвата внутри finally...\")\n # Если в finally происходит новое исключение, \n # оно полностью заменяет (подавляет) предыдущее исключение\n raise SuppressionError(\"Критическая ошибка в finally\")\n except SuppressionError as final_err:\n print(f\"Перехвачено в finally: {final_err}\")\n # В Python, если в finally выбрасывается исключение, \n # оригинальный стек (CustomError и SuppressionError из except) \n # будет потерян для вызывающего кода, если не использовать raise ... from\n raise final_err\n\nif __name__ == \"__main__\":\n try:\n demonstrate_exception_suppression()\n except Exception as e:\n print(f\"\\nИТОГ: Программа завершилась с ошибкой: {type(e).__name__}: {e}\")\n print(\"Заметьте: Оригинальная CustomError была полностью подавлена ошибкой из finally.\")\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите функцию, которая возвращает бесконечный итератор, используя `yield` внутри генераторного выражения, чтобы избежать немедленного переполнения памяти. В чем заключается логическая ловушка при попытке преобразовать результат такой функции в обычный список `list()`?"}, {"role": "assistant", "content": "```python\nimport itertools\n\ndef infinite_generator_expression(start=0):\n \"\"\"\n Возвращает бесконечный итератор через генераторное выражение.\n Использование yield внутри генераторного выражения в Python \n технически реализуется через создание генератора.\n \"\"\"\n # Генераторное выражение, которое создает бесконечную последовательность\n gen_expr = (x for x in itertools.count(start))\n \n # Чтобы использовать yield внутри функции, возвращающей итератор, \n # мы делегируем итерацию\n yield from gen_expr\n\ndef solve_task():\n # Создаем итератор\n iterator = infinite_generator_expression(1)\n \n # Извлекаем первые 5 элементов для проверки работоспособности\n first_five = [next(iterator) for _ in range(5)]\n print(f\"First five elements: {first_five}\")\n\n # Логическая ловушка:\n # Попытка выполнить list(infinite_generator_expression()) приведет к \n # бесконечному циклу и переполнению оперативной памяти (MemoryError), \n # так как функция list() пытается вычитать ВСЕ элементы из итератора, \n # а итератор бесконечен. Программа зависнет, пытаясь аллоцировать \n # бесконечный объем памяти под список.\n \n print(\"\\nLogical Trap Explanation:\")\n print(\"Attempting list(infinite_generator_expression()) will cause an infinite loop\")\n print(\"and eventually a MemoryError because list() tries to exhaust the iterator.\")\n\nif __name__ == \"__main__\":\n solve_task()\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Дан список элементов, где некоторые значения дублируются, и необходимо вычислить количество уникальных пар «ключ-значение», используя только одну итерацию по исходным данным. Подвох заключается в том, что при попытке использовать стандартное множество для подсчета уникальных словарей вы столкнетесь с ошибкой из-за их несравниваемости."}, {"role": "assistant", "content": "```python\ndef count_unique_pairs(data):\n \"\"\"\n data: list of dicts, e.g., [{'id': 1, 'val': 'a'}, {'id': 1, 'val': 'a'}, {'id': 2, 'val': 'b'}]\n \"\"\"\n unique_pairs = set()\n \n for item in data:\n # Преобразуем словарь в кортеж отсортированных пар (items), \n # так как кортежи являются hashable, а словари — нет.\n # Это позволяет использовать set для отслеживания уникальности за одну итерацию.\n pair_tuple = tuple(sorted(item.items()))\n unique_pairs.add(pair_tuple)\n \n return len(unique_pairs)\n\n# Тестовые данные\nif __name__ == \"__main__\":\n test_data = [\n {'id': 1, 'name': 'Alice'},\n {'id': 2, 'name': 'Bob'},\n {'id': 1, 'name': 'Alice'}, # Дубликат\n {'id': 3, 'name': 'Charlie'},\n {'id': 2, 'name': 'Bob'}, # Дубликат\n {'id': 1, 'name': 'Different'}, # Другое значение\n ]\n\n result = count_unique_pairs(test_data)\n print(f\"Количество уникальных пар: {result}\")\n # Ожидаемый результат: 4 (Alice, Bob, Charlie, Different)\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Вычислите значение функции $f(n)$, которая определяется как сумма двух предыдущих значений $f(n-1)$ и $f(n-2)$, но при этом при достижении определенного порога $n$ алгоритм должен возвращать константу, не вычисляя рекурсию дальше. Определите, как изменится количество операций при использовании мемоизации, если в процессе вычислений функция будет вызываться с нелинейно возрастающими аргументами."}, {"role": "assistant", "content": "```python\n# Сбрасываем счетчик вызовов для мемоизации (но сохраняем кэш)\n # В реальности мемоизация накапливает выгоду\n \n # 1. Считаем мемои\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите функцию, которая с помощью выражения-генератора и модуля `itertools` отбирает из бесконечной последовательности чисел только те, которые являются квадратами чисел, имеющих в десятичной записи ровно три восьмерки. Функция должна возвращать генератор, выдающий первые $N$ таких чисел, полученных при использовании заданного `seed=880080`."}, {"role": "assistant", "content": "```python\nimport itertools\n\ndef get_squares_with_three_eights(n):\n seed = 880080\n \n def is_valid(num):\n return str(num).count('8') == 3\n\n # Создаем бесконечную последовательность чисел, начиная с seed\n numbers = itertools.count(seed)\n \n # Выражение-генератор: \n # 1. Берем число x из последовательности\n # 2. Проверяем, содержит ли x ровно три восьмерки\n # 3. Если да, возвращаем x^2\n squares_gen = (x**2 for x in numbers if is_valid(x))\n \n # Возвращаем генератор, который выдаст первые N элементов\n return itertools.islice(squares_gen, n)\n\n# Пример использования:\n# if __name__ == \"__main__\":\n# for val in get_squares_with_three_eights(5):\n# print(val)\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите программу, которая принимает на вход строку с текстом и извлекает из неё все фрагменты, соответствующие заданному шаблону с помощью регулярных выражений. Полученные данные необходимо очистить от лишних пробелов, изменить регистр и вывести в консоль, используя форматированные строки."}, {"role": "assistant", "content": "```python\nimport re\n\ndef extract_and_process(text, pattern):\n \"\"\"\n Извлекает фрагменты по шаблону, очищает от лишних пробелов \n и переводит в нижний регистр.\n \"\"\"\n # Находим все совпадения\n matches = re.findall(pattern, text)\n \n # Обработка: strip() убирает пробелы по краям, \n # split/join убирает лишние пробелы внутри\n processed_data = []\n for match in matches:\n # Если match — это кортеж (из-за групп в regex), берем первую группу\n if isinstance(match, tuple):\n match = match[0]\n \n cleaned = \" \".join(match.split()).strip().lower()\n if cleaned:\n processed_data.append(cleaned)\n \n return processed_data\n\ndef main():\n # Пример входных данных\n input_text = \"Contact us at support @ example.com or sales @example.org. Also check info@TEST.RU\"\n \n # Шаблон для поиска email (упрощенный для демонстрации работы с пробелами)\n # Ищем последовательность символов, разделенных пробелами, похожую на email\n pattern = r'[a-zA-Z0-9._%+-]+\\s*@\\s*[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}'\n\n results = extract_and_process(input_text, pattern)\n\n print(f\"Found fragments: {results}\")\n \n # Вывод через форматированные строки\n for i, item in enumerate(results, 1):\n print(f\"Match #{i}: {item}\")\n\nif __name__ == \"__main__\":\n main()\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите рекурсивную функцию для вычисления n-го числа Фибоначчи, используя словарь для сохранения уже вычисленных значений. Реализуйте механизм мемоизации, чтобы оптимизировать алгоритм и избежать избыточных вычислений при больших входных данных."}, {"role": "assistant", "content": "```python\ndef fibonacci(n, memo=None):\n if memo is None:\n memo = {0: 0, 1: 1}\n \n if n in memo:\n return memo[n]\n \n memo[n] = fibonacci(n - 1, memo) + fibonacci(n - 2, memo)\n return memo[n]\n\nif __name__ == \"__main__\":\n import sys\n sys.setrecursionlimit(2000)\n \n n = 100\n print(f\"n-th Fibonacci number ({n}): {fibonacci(n)}\")\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Найдите произведение всех простых чисел, которые являются делителями факториала числа $n$, при условии, что $n$ равно наибольшему общему делителю между заданным числом `seed` и результатом вычисления $10!$. Учтите, что в процессе поиска необходимо строго различать простые числа и составные делители, чтобы не допустить дублирования множителей в итоговом результате."}, {"role": "assistant", "content": "```python\nimport math\n\ndef solve(seed: int) -> int:\n # Вычисляем 10!\n factorial_10 = math.factorial(10)\n \n # Находим n = GCD(seed, 10!)\n n = math.gcd(seed, factorial_10)\n \n if n < 2:\n return 0 # Или 1, в зависимости от трактовки пустого произведения, но для n < 2 простых делителей нет\n \n # Делители n! — это все простые числа, которые не превосходят n.\n # Согласно свойствам факториала, любое простое число p является делителем n!, \n # если и только если p <= n.\n \n def is_prime(num):\n if num < 2:\n return False\n for i in range(2, int(math.sqrt(num)) + 1):\n if num % i == 0:\n return False\n return True\n\n product = 1\n found_prime = False\n \n for i in range(2, n + 1):\n if is_prime(i):\n product *= i\n found_prime = True\n \n return product if found_prime else 0\n\n# Пример использования:\nif __name__ == \"__main__\":\n # Замените seed на нужное значение\n seed_value = 120 \n print(solve(seed_value))\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите программу, которая извлекает из строки пользователя все последовательности цифр и заменяет их на слово «ID» с помощью регулярных выражений. Результат должен быть выведен на экран в формате: «Найденные элементы: [список найденных чисел]»."}, {"role": "assistant", "content": "```python\nimport re\n\ndef process_string(input_string):\n # Находим все последовательности цифр\n found_elements = re.findall(r'\\d+', input_string)\n \n # Заменяем цифры на слово \"ID\"\n result_string = re.sub(r'\\d+', 'ID', input_string)\n \n # Выводим результат согласно условию\n print(f\"Найденные элементы: {found_elements}\")\n return result_string\n\nif __name__ == \"__main__\":\n user_input = input()\n process_string(user_input)\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Разработайте систему валидации банковских транзакций, которая перехватывает стандартные ошибки типов данных и выбрасывает кастомное исключение `InsufficientFundsError` при попытке списания суммы, превышающей доступный баланс. Реализуйте иерархию пользовательских ошибок и обеспечьте корректную обработку всех исключений в блоке `finally` для гарантированного логирования результата операции."}, {"role": "assistant", "content": "```python\nimport logging\n\n# Настройка логирования\nlogging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')\n\nclass BankError(Exception):\n \"\"\"Базовое исключение для банковской системы.\"\"\"\n pass\n\nclass InsufficientFundsError(BankError):\n \"\"\"Исключение при недостаточном балансе.\"\"\"\n def __init__(self, balance, amount):\n self.balance = balance\n self.amount = amount\n super().__init__(f\"Insufficient funds: balance={balance}, requested={amount}\")\n\nclass InvalidTransactionError(BankError):\n \"\"\"Исключение при некорректных данных транзакции.\"\"\"\n pass\n\nclass BankAccount:\n def __init__(self, account_holder: str, initial_balance: float):\n if not isinstance(initial_balance, (int, float)):\n raise TypeError(\"Initial balance must be a number\")\n self.account_holder = account_holder\n self.balance = float(initial_balance)\n\n def withdraw(self, amount: float):\n \"\"\"Метод списания средств с валидацией.\"\"\"\n try:\n if not isinstance(amount, (int, float)):\n raise TypeError(f\"Amount must be a number, got {type(amount).__name__}\")\n \n if amount <= 0:\n raise InvalidTransactionError(\"Withdrawal amount must be positive\")\n\n if amount > self.balance:\n raise InsufficientFundsError(self.balance, amount)\n\n self.balance -= amount\n logging.info(f\"Successfully withdrew {amount}. New balance: {self.balance}\")\n return True\n\n except (TypeError, ValueError) as e:\n # Перехватываем стандартные ошибки типов и оборачиваем в кастомное исключение\n raise InvalidTransactionError(f\"Data integrity error: {str(e)}\") from e\n\ndef process_transaction(account: BankAccount, amount: float):\n \"\"\"Оркестратор транзакции с гарантированным логированием.\"\"\"\n transaction_status = \"FAILED\"\n try:\n logging.info(f\"Attempting to withdraw {amount} from {account.account_holder}'s account...\")\n account.withdraw(amount)\n transaction_status = \"SUCCESS\"\n except InsufficientFundsError as e:\n logging.error(f\"Transaction rejected: {e}\")\n except InvalidTransactionError as e:\n logging.error(f\"Transaction rejected due to invalid data: {e}\")\n except Exception as e:\n logging.error(f\"Unexpected system error: {e}\")\n finally:\n # Гарантированное логирование результата\n logging.info(f\"Final Transaction Status for {account.account_holder}: {transaction_status}\")\n logging.info(f\"Current Account Balance: {account.balance}\")\n print(\"-\" * 30)\n\nif __name__ == \"__main__\":\n # Инициализация аккаунта\n my_account = BankAccount(\"John Doe\", 1000.0)\n\n # 1. Успешная\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Дан список чисел, где необходимо найти первый элемент, который одновременно является максимальным значением в списке и при этом не является дубликатом. Учтите, что если в списке несколько одинаковых макси��альных значений, алгоритм должен вернуть None, а не первый попавшийся элемент."}, {"role": "assistant", "content": "```python\ndef find_unique_max(numbers):\n if not numbers:\n return None\n \n max_val = max(numbers)\n \n # Считаем количество вхождений максимального значения\n count = 0\n for num in numbers:\n if num == max_val:\n count += 1\n \n # Если максимальное значение встречается больше одного раза, возвращаем None\n if count > 1:\n return None\n \n return max_val\n\n# Тестовые случаи\nif __name__ == \"__main__\":\n assert find_unique_max([1, 3, 2, 5, 4]) == 5\n assert find_unique_max([1, 5, 2, 5, 4]) is None\n assert find_unique_max([10, 10, 10]) is None\n assert find_unique_max([1, 2, 3, 3]) is None\n assert find_unique_max([7]) == 7\n assert find_unique_max([]) is None\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Реализуйте систему мониторинга, которая одновременно запускает несколько асинхронных задач для имитации опроса различных датчиков с произвольными задержками. Каждая задача должна прерываться по истечении заданного таймера, если она не успела завершить свою работу в отведенное время."}, {"role": "assistant", "content": "```python\nimport asyncio\nimport random\nimport time\n\nasync def sensor_task(sensor_id: str, timeout: float):\n \"\"\"\n Имитация опроса датчика с произвольной задержкой.\n \"\"\"\n try:\n # Имитация работы: датчик может работать от 0.5 до 5 секунд\n work_duration = random.uniform(0.5, 5.0)\n print(f\"[START] Датчик {sensor_id}: ожидается выполнение {work_duration:.2f}с (тайм-аут: {timeout}с)\")\n \n # Используем asyncio.wait_for для реализации таймера прерывания\n await asyncio.wait_for(asyncio.sleep(work_duration), timeout=timeout)\n \n print(f\"[SUCCESS] Датчик {sensor_id}: данные получены успешно.\")\n return f\"Data from {sensor_id}\"\n \n except asyncio.TimeoutError:\n print(f\"[TIMEOUT] Датчик {sensor_id}: время вышло! Прерывание задачи.\")\n raise\n except Exception as e:\n print(f\"[ERROR] Датчик {sensor_id}: произошла ошибка: {e}\")\n raise\n\nasync def monitor_system():\n \"\"\"\n Запуск системы мониторинга нескольких датчиков.\n \"\"\"\n # Список датчиков: (ID, лимит времени)\n sensors = [\n (\"Temp-01\", 2.0),\n (\"Press-01\", 3.0),\n (\"Humid-01\", 1.0),\n (\"Light-01\", 4.0),\n (\"CO2-01\", 2.5)\n ]\n\n print(f\"--- Запуск системы мониторинга ---\")\n start_time = time.perf_counter()\n\n # Создаем список задач\n tasks = [sensor_task(sid, timeout) for sid, timeout in sensors]\n\n # Запускаем все задачи одновременно и ждем завершения\n # return_exceptions=True позволяет не останавливать весь цикл при ошибке одного датчика\n results = await asyncio.gather(*tasks, return_exceptions=True)\n\n end_time = time.perf_counter()\n print(f\"--- Мониторинг завершен за {end_time - start_time:.2f}с ---\")\n\n # Анализ результатов\n print(\"\\nИтоговый отчет:\")\n for i, result in enumerate(results):\n sensor_name = sensors[i][0]\n if isinstance(result, asyncio.TimeoutError):\n print(f\" - {sensor_name}: Ошибка (Тайм-аут)\")\n elif isinstance(result, Exception):\n print(f\" - {sensor_name}: Ошибка ({type(result).__name__})\")\n else:\n print(f\" - {sensor_name}: OK ({result})\")\n\nif __name__ == \"__main__\":\n asyncio.run(monitor_system())\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Создайте программу, которая с помощью модуля `pathlib` находит все CSV-файлы в заданной директории и считывает данные из них. Затем преобразуйте полученную информацию в формат JSON и сохраните итоговый результат в новый файл."}, {"role": "assistant", "content": "```python\nimport csv\nimport json\nfrom pathlib import Path\n\ndef process_csv_to_json(directory_path: str, output_filename: str):\n base_path = Path(directory_path)\n \n if not base_path.is_dir():\n raise ValueError(f\"Path {directory_path} is not a directory\")\n\n combined_data = {}\n\n # Find all .csv files in the directory\n csv_files = list(base_path.glob(\"*.csv\"))\n\n for csv_file in csv_files:\n file_data = []\n try:\n with csv_file.open(mode='r', encoding='utf-8') as f:\n reader = csv.DictReader(f)\n for row in reader:\n file_data.append(row)\n \n # Use filename (without extension) as key\n combined_data[csv_file.stem] = file_data\n except Exception as e:\n print(f\"Error reading {csv_file.name}: {e}\")\n\n # Save to JSON\n output_path = base_path / output_filename\n try:\n with output_path.open(mode='w', encoding='utf-8') as json_file:\n json.dump(combined_data, json_file, indent=4, ensure_ascii=False)\n print(f\"Successfully saved data to {output_path}\")\n except Exception as e:\n print(f\"Error saving JSON: {e}\")\n\nif __name__ == \"__main__\":\n # Example usage:\n # Create dummy files for demonstration if needed\n test_dir = Path(\"data_folder\")\n test_dir.mkdir(exist_ok=True)\n \n with test_dir.joinpath(\"test1.csv\").open(\"w\", encoding=\"utf-8\") as f:\n f.write(\"id,name,value\\n1,Alice,10\\n2,Bob,20\")\n \n with test_dir.joinpath(\"test2.csv\").open(\"w\", encoding=\"utf-8\") as f:\n f.write(\"id,item\\n101,Apple\\n102,Banana\")\n\n process_csv_to_json(str(test_dir), \"result.json\")\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Создайте программу, которая с помощью модуля `pathlib` находит в заданной директории JSON-файл с данными о пользователях и считывает их содержимое. Затем преобразуйте полученные данные в формат CSV и сохраните результат в новый файл, используя соответствующие модули для работы с форматами."}, {"role": "assistant", "content": "```python\nimport json\nimport csv\nfrom pathlib import Path\n\ndef convert_json_to_csv(input_dir: str, output_file: str):\n input_path = Path(input_dir)\n \n # Find the first JSON file in the directory\n json_file = next(input_path.glob(\"*.json\"), None)\n \n if not json_file:\n raise FileNotFoundError(f\"No JSON file found in {input_dir}\")\n\n # Read JSON data\n with json_file.open('r', encoding='utf-8') as f:\n data = json.load(f)\n\n # Ensure data is a list of dictionaries\n if not isinstance(data, list) or not data:\n raise ValueError(\"JSON data must be a non-empty list of objects\")\n\n # Get field names from the first dictionary\n fieldnames = data[0].keys()\n\n # Write to CSV\n with open(output_file, 'w', newline='', encoding='utf-8') as f:\n writer = csv.DictWriter(f, fieldnames=fieldnames)\n writer.writeheader()\n writer.writerows(data)\n\nif __name__ == \"__main__\":\n # Setup dummy data for demonstration\n import os\n \n test_dir = Path(\"test_data\")\n test_dir.mkdir(exist_ok=True)\n \n dummy_json = test_dir / \"users.json\"\n dummy_json.write_text(json.dumps([\n {\"id\": 1, \"name\": \"Alice\", \"email\": \"alice@example.com\"},\n {\"id\": 2, \"name\": \"Bob\", \"email\": \"bob@example.com\"},\n {\"id\": 3, \"name\": \"Charlie\", \"email\": \"charlie@example.com\"}\n ]), encoding='utf-8')\n\n output_csv = \"users_output.csv\"\n \n try:\n convert_json_to_csv(str(test_dir), output_csv)\n print(f\"Success! Converted {dummy_json.name} to {output_csv}\")\n except Exception as e:\n print(f\"Error: {e}\")\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Реализуйте класс `Vector`, который при сложении через `__add__` возвращает новый объект того же класса, но при попытке вывести его через `__repr__` должен возвращать строку, представляющую н�� текущее состояние объекта, а результат его сложения с нулевым вектором. Проверьте, как изменится поведение программы, если передать в метод `__add__` объект другого типа, не являющийся вектором."}, {"role": "assistant", "content": "```python\nclass Vector:\n def __init__(self, x, y):\n self.x = x\n self.y = y\n\n def __add__(self, other):\n if not isinstance(other, Vector):\n return NotImplemented\n return Vector(self.x + other.x, self.y + other.y)\n\n def __repr__(self):\n # Возвращает результат сложения текущего объекта с нулевым вектором\n zero_vector = Vector(0, 0)\n result = self + zero_vector\n return f\"Vector({result.x}, {result.y})\"\n\n# Тестирование реализации\nif __name__ == \"__main__\":\n v1 = Vector(10, 20)\n v2 = Vector(5, 5)\n v3 = Vector(0, 0)\n\n # 1. Проверка сложения\n v4 = v1 + v2\n print(f\"Sum of v1 and v2: {v4.x}, {v4.y}\") # Ожидаем 15, 25\n\n # 2. Проверка __repr__ (должен вернуть v4 + (0,0) -> 15, 25)\n print(f\"Repr of v4: {repr(v4)}\")\n\n # 3. Проверка __repr__ для v1 (должен вернуть v1 + (0,0) -> 10, 20)\n print(f\"Repr of v1: {repr(v1)}\")\n\n # 4. Проверка поведения при сложении с другим типом\n print(\"\\nTesting addition with different type (int):\")\n try:\n result = v1 + 10\n print(result)\n except TypeError as e:\n print(f\"Caught expected error: {e}\")\n\n print(\"\\nTesting addition with different type (list):\")\n try:\n result = v1 + [1, 2]\n print(result)\n except TypeError as e:\n print(f\"Caught expected error: {e}\")\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите программу, которая считывает данные из CSV-файла и сохраняет их в JSON, используя `pathlib` для проверки существования исходного пути. Подвох заключается в том, что при попытке записи в файл с расширением `.json`, который на самом деле является директорией, программа должна корректно обработать исключение, а не просто проверить наличие пути."}, {"role": "assistant", "content": "```python\nimport csv\nimport json\nfrom pathlib import Path\n\ndef csv_to_json(csv_path_str, json_path_str):\n csv_path = Path(csv_path_str)\n json_path = Path(json_path_str)\n\n if not csv_path.exists():\n raise FileNotFoundError(f\"Source file {csv_path} does not exist.\")\n\n data = []\n with csv_path.open(mode='r', encoding='utf-8') as csv_file:\n reader = csv.DictReader(csv_file)\n for row in reader:\n data.append(row)\n\n try:\n with json_path.open(mode='w', encoding='utf-8') as json_file:\n json.dump(data, json_file, indent=4)\n except IsADirectoryError:\n print(f\"Error: The target path '{json_path}' is a directory, not a file.\")\n except PermissionError:\n print(f\"Error: Permission denied when writing to '{json_path}'.\")\n except Exception as e:\n print(f\"An unexpected error occurred: {e}\")\n\nif __name__ == \"__main__\":\n # Create dummy files for demonstration\n import os\n import shutil\n\n test_csv = Path(\"data.csv\")\n test_json = Path(\"data.json\")\n test_dir = Path(\"data.json\")\n\n # Setup test environment\n test_csv.write_text(\"name,age\\nAlice,30\\nBob,25\", encoding='utf-8')\n \n if test_dir.exists():\n shutil.rmtree(test_dir)\n test_dir.mkdir()\n\n # This should trigger the IsADirectoryError because data.json is a directory\n csv_to_json(\"data.csv\", \"data.json\")\n\n # Cleanup\n test_csv.unlink()\n shutil.rmtree(test_dir)\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Найдите произведение всех простых чисел, которые являются делителями факториала числа $n$, где $n$ — это наибольший общий делитель чисел 120 и 180. Учтите, что в результате вычислений может возникнуть ошибка переполнения, если не учитывать специфику работ�� с типами данных при поиске всех делителей."}, {"role": "assistant", "content": "```python\nimport math\n\ndef solve():\n # 1. Находим n = НОД(120, 180)\n n = math.gcd(120, 180)\n \n # 2. Нам нужно найти произведение всех простых чисел, \n # которые являются делителями n! (n-факториал).\n # Делителями n! являются все простые числа, которые меньше или равны n.\n # Это следует из определения факториала: n! = 1 * 2 * ... * n.\n # Любое простое число p <= n входит в разложение n! на множители.\n \n if n < 2:\n return 0\n \n primes = []\n is_prime = [True] * (n + 1)\n for p in range(2, n + 1):\n if is_prime[p]:\n primes.append(p)\n for i in range(p * p, n + 1, p):\n is_prime[i] = False\n \n # 3. Вычисляем произведение найденных простых чисел\n product = 1\n for p in primes:\n product *= p\n \n return product\n\nif __name__ == \"__main__\":\n print(solve())\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите функцию, которая извлекает из строки все последовательности цифр, разделенные спецсимволами, и объединяет их в одну строку через дефис, используя срезы для удаления лишних знаков по краям. Будьте внимательны: при поиске паттернов регулярным выражением не забудьте учесть, что некоторые «цифры» в исходном тексте могут оказаться частью текстовых символов, которые не должны попасть в итоговый результат."}, {"role": "assistant", "content": "```python\nimport re\n\ndef extract_digit_sequences(input_string: str) -> str:\n \"\"\"\n Extracts digit sequences separated by special characters and joins them with a hyphen.\n Uses regex to find digit-only sequences and slices to clean edges if necessary.\n \"\"\"\n # Find all sequences consisting strictly of digits\n # \\d+ ensures we only get numeric parts\n sequences = re.findall(r'\\d+', input_string)\n \n if not sequences:\n return \"\"\n \n # Join sequences with a hyphen\n result = \"-\".join(sequences)\n \n # The requirement mentions using slices to remove extra signs from edges.\n # In the context of the joined string, if there were leading/trailing \n # non-digit artifacts captured (though \\d+ prevents this), \n # we ensure the result is clean.\n # If the logic implies cleaning the input string's boundaries first:\n # result = result.strip('-') \n \n return result\n\nif __name__ == \"__main__\":\n # Test cases\n test_cases = [\n (\"abc123#456$789\", \"123-456-789\"),\n (\"!@#999!!!000???111\", \"999-000-111\"),\n (\"no_digits_here\", \"\"),\n (\"123abc456\", \"123-456\"),\n (\"part123text456part\", \"123-456\"),\n (\"...001...002...003...\", \"001-002-003\")\n ]\n\n for text, expected in test_cases:\n actual = extract_digit_sequences(text)\n assert actual == expected, f\"Failed on {text}: expected {expected}, got {actual}\"\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Дан список целых чисел, в котором необходимо найти все элементы, кратные заданному числу, и отсортировать их по убыванию. Результат должен представлять собой новый список, содержащий только отфильтрованные значения в правильном порядке."}, {"role": "assistant", "content": "```python\ndef filter_and_sort_multiples(numbers: list[int], divisor: int) -> list[int]:\n \"\"\"\n Filters elements divisible by 'divisor' and sorts them in descending order.\n \"\"\"\n if divisor == 0:\n raise ValueError(\"Divisor cannot be zero.\")\n \n return sorted([x for x in numbers if x % divisor == 0], reverse=True)\n\n# Example usage:\nif __name__ == \"__main__\":\n input_list = [10, 3, 5, 20, 7, 15, 30, 2, 9]\n target_divisor = 5\n \n result = filter_and_sort_multiples(input_list, target_divisor)\n print(result) # Expected output: [30, 20, 15, 10, 5]\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите функцию для вычисления количества способов добраться из начальной точки в конечную на шахматной доске размером $N \\times M$, двигаясь только вправо или вниз. Для оптимизации алгоритма необходимо реализовать мемоизацию, чтобы избежать избыточных вычислений при рекурсивном обходе всех возможных путей."}, {"role": "assistant", "content": "```python\ndef count_paths(n: int, m: int) -> int:\n \"\"\"\n Calculates the number of ways to reach (n, m) from (1, 1) \n on an N x M grid moving only right or down.\n \"\"\"\n memo = {}\n\n def solve(r: int, c: int) -> int:\n # Base case: reached the target cell\n if r == n and c == m:\n return 1\n # Out of bounds\n if r > n or c > m:\n return 0\n \n # Check memoization table\n if (r, c) in memo:\n return memo[(r, c)]\n \n # Move down or move right\n res = solve(r + 1, c) + solve(r, c + 1)\n \n # Store in memo\n memo[(r, c)] = res\n return res\n\n if n <= 0 or m <= 0:\n return 0\n \n return solve(1, 1)\n\nif __name__ == \"__main__\":\n # Example usage:\n # For a 3x3 grid, paths are:\n # (1,1)->(1,2)->(1,3)->(2,3)->(3,3)\n # (1,1)->(2,1)->(3,1)->(3,2)->(3,3) etc.\n # Formula: (N+M-2)! / ((N-1)! * (M-1)!)\n N, M = 3, 3\n print(f\"Paths in {N}x{M} grid: {count_paths(N, M)}\")\n \n N, M = 18, 18\n print(f\"Paths in {N}x{M} grid: {count_paths(N, M)}\")\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите рекурсивную функцию для вычисления n-го числа Фибоначчи, которая использует словарь для сохранения уже вычисленных значений. Оптимизируйте алгоритм с помощью мемоизации, чтобы избежать избыточных вычислений при больших входных данных."}, {"role": "assistant", "content": "```python\ndef fibonacci_memo(n, memo=None):\n if memo is None:\n memo = {0: 0, 1: 1}\n \n if n in memo:\n return memo[n]\n \n memo[n] = fibonacci_memo(n - 1, memo) + fibonacci_memo(n - 2, memo)\n return memo[n]\n\nif __name__ == \"__main__\":\n import sys\n # Увеличиваем лимит рекурсии для больших n\n sys.setrecursionlimit(2000)\n \n n = 100\n print(fibonacci_memo(n))\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Найдите произведение всех простых чисел, которые являются делителями факториала числа $n$, где $n$ — это наибольший общий делитель чисел 853839 и 123456. Учтите, что при вычислении результата необходимо учитывать, что каждое уникальное простое число должно учитываться в произведении только один раз, независимо от его кратности в разложении факториала."}, {"role": "assistant", "content": "```python\nimport math\n\ndef get_gcd(a, b):\n while b:\n a, b = b, a % b\n return a\n\ndef get_prime_factors_of_factorial(n):\n if n < 2:\n return []\n \n primes = []\n is_prime = [True] * (n + 1)\n for p in range(2, n + 1):\n if is_prime[p]:\n primes.append(p)\n for i in range(p * p, n + 1, p):\n is_prime[i] = False\n return primes\n\ndef solve():\n num1 = 853839\n num2 = 123456\n \n n = get_gcd(num1, num2)\n \n # The prime divisors of n! are all prime numbers <= n\n prime_divisors = get_prime_factors_of_factorial(n)\n \n product = 1\n for p in prime_divisors:\n product *= p\n \n return product\n\nif __name__ == \"__main__\":\n print(solve())\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Дан список идентификаторов пользователей, где некоторые значения повторяются, а некоторые отсутствуют в справочнике категорий. Определите количество уникальных категорий, используя только одну итерацию по списку, не допуская ошибки при попытке обращения к несуществующему ключу в словаре."}, {"role": "assistant", "content": "```python\ndef count_unique_categories(user_ids, category_map):\n \"\"\"\n user_ids: list of user identifiers\n category_map: dict mapping user_id to category\n \"\"\"\n unique_categories = set()\n \n for user_id in user_ids:\n # Используем метод .get(), который возвращает None вместо KeyError, \n # если ключа нет в словаре.\n category = category_map.get(user_id)\n if category is not None:\n unique_categories.add(category)\n \n return len(unique_categories)\n\n# Пример использования:\nif __name__ == \"__main__\":\n user_ids_list = [1, 2, 2, 3, 4, 5, 1, 6]\n categories_dict = {\n 1: \"Admin\",\n 2: \"User\",\n 3: \"Guest\",\n 4: \"User\",\n 5: \"Moderator\"\n # 6 отсутствует в справочнике\n }\n\n result = count_unique_categories(user_ids_list, categories_dict)\n print(f\"Количество уникальных категорий: {result}\")\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите функцию, которая извлекает из текста все серийные номера формата «ID-XXXX-YYYY» и возвращает их в виде списка, где вместо символов «X» и «Y» подставлены значения из срезов исходной строки. Результат должен быть представлен в виде отформатированной строки, где каждый найденный номер отделен от другого символом вертикальной черты."}, {"role": "assistant", "content": "```python\nimport re\n\ndef extract_serial_numbers(text: str) -> str:\n \"\"\"\n Extracts serial numbers in the format 'ID-XXXX-YYYY' from text.\n Returns a string of found IDs separated by '|'.\n \"\"\"\n # Pattern explanation:\n # ID- matches literal 'ID-'\n # ([A-Z0-9]{4}) captures exactly 4 alphanumeric characters (X)\n # - matches literal '-'\n # ([A-Z0-9]{4}) captures exactly 4 alphanumeric characters (Y)\n pattern = r'ID-([A-Z0-9]{4})-([A-Z0-9]{4})'\n \n matches = re.findall(pattern, text)\n \n # Reconstruct the full ID using the captured groups\n serial_numbers = [f\"ID-{m[0]}-{m[1]}\" for m in matches]\n \n return \"|\".join(serial_numbers)\n\n# Example usage:\nif __name__ == \"__main__\":\n sample_text = \"The items are ID-A1B2-C3D4 and ID-9999-ZZZZ, but not ID-123-ABC.\"\n print(extract_serial_numbers(sample_text))\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите программу, которая извлекает из заданной строки все последовательности цифр, используя модуль `re`, и объединяет их в одну строку. Полученный результат должен быть выведен на экран в отформатированном виде с указанием общего количества найденных чисел."}, {"role": "assistant", "content": "```python\nimport re\n\ndef extract_and_combine_digits(input_string: str) -> None:\n # Извлекаем все последовательности цифр\n digit_sequences = re.findall(r'\\d+', input_string)\n \n # Объединяем их в одну строку\n combined_result = \"\".join(digit_sequences)\n \n # Выводим результат\n print(f\"Объединенная строка: {combined_result}\")\n print(f\"Общее количество найденных чисел: {len(digit_sequences)}\")\n\nif __name__ == \"__main__\":\n test_string = \"abc123def45gh678i9\"\n extract_and_combine_digits(test_string)\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Дан спис��к целых чисел, в котором необходимо найти все элементы, одновременно являющиеся одновременно четными и кратными трем. Полученный отфильтрованный список следует отсортировать по убыванию и вернуть его максимальное значение."}, {"role": "assistant", "content": "```python\ndef solve(numbers: list[int]) -> int | None:\n filtered_numbers = sorted(\n [x for x in numbers if x % 2 == 0 and x % 3 == 0], \n reverse=True\n )\n return filtered_numbers[0] if filtered_numbers else None\n\nif __name__ == \"__main__\":\n # Example usage:\n test_list = [1, 6, 12, 7, 18, 10, 24, 5]\n result = solve(test_list)\n print(result)\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите программу, которая извлекает из произвольного текста все последовательности цифр, напоминающие номера телефонов, используя регулярные выражения. Полученные номера необходимо отформатировать в единый стандарт с использованием срезов и f-строк, удалив лишние символы и добавив международный префикс."}, {"role": "assistant", "content": "```python\nimport re\n\ndef extract_and_format_phones(text: str) -> list[str]:\n \"\"\"\n Extracts sequences of digits that look like phone numbers and formats them.\n Standard format: +7XXXXXXXXXX (11 digits total)\n \"\"\"\n # Regex looks for sequences of 7 to 15 digits, allowing for common separators\n # This pattern captures sequences that contain only digits after stripping separators\n pattern = r'(?:\\+?\\d[\\d\\-\\(\\) ]{7,}\\d)'\n \n raw_matches = re.findall(pattern, text)\n formatted_numbers = []\n\n for match in raw_matches:\n # Remove all non-digit characters\n digits = \"\".join(re.findall(r'\\d', match))\n \n # We look for numbers that can be interpreted as phone numbers (usually 10 or 11 digits)\n # If 11 digits and starts with 7 or 8, we treat it as local RU format\n # If 10 digits, we assume it's missing the country code\n \n if len(digits) == 11 and digits[0] in '78':\n # Standardize to +7...\n clean_number = f\"+7{digits[1:]}\"\n formatted_numbers.append(clean_number)\n elif len(digits) == 10:\n # Assume missing 7 or 8\n clean_number = f\"+7{digits}\"\n formatted_numbers.append(clean_number)\n elif len(digits) > 11:\n # If it's longer, try to take the last 11 digits as a potential number\n # or just take the last 10 and add +7\n clean_number = f\"+7{digits[-10:]}\"\n formatted_numbers.append(clean_number)\n\n # Return unique numbers while preserving order\n return list(dict.fromkeys(formatted_numbers))\n\nif __name__ == \"__main__\":\n sample_text = \"\"\"\n Contact us at +7 (999) 123-45-67 or 89001112233. \n Old office: 9995554433, mobile: +7 916 000 11 22.\n Invalid: 123, 1234567890123456789, or just text.\n Another one: 8-921-000-00-00.\n \"\"\"\n \n results = extract_and_format_phones(sample_text)\n for phone in results:\n print(phone)\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Реализуйте систему валидации банковских транзакций, которая выбрасывает кастомное исключение `InsufficientFundsError`, если сумма перевода превышает доступный баланс пользователя. Обработайте это и другие стандартные ошибки в блоке `try-except`, обеспечив корректное логирование причин отказа в операции."}, {"role": "assistant", "content": "```python\nimport logging\n\n# Настройка логирования\nlogging.basicConfig(level=logging.INFO, format='%(levelname)s: %(message)s')\nlogger = logging.getLogger(__name__)\n\nclass InsufficientFundsError(Exception):\n \"\"\"Исключение, возникающее при нехватке средств на счету.\"\"\"\n def __init__(self, balance, amount):\n self.balance = balance\n self.amount = amount\n self.message = f\"Недостаточно средств. Доступно: {balance}, требуется: {amount}\"\n super().__init__(self.message)\n\nclass BankAccount:\n def __init__(self, account_holder: str, initial_balance: float):\n self.account_holder = account_holder\n self.balance = initial_balance\n\n def transfer(self, amount: float):\n if not isinstance(amount, (int, float)):\n raise TypeError(f\"Сумма перевода должна быть числом, получено: {type(amount).__name__}\")\n \n if amount <= 0:\n raise ValueError(\"Сумма перевода должна быть положительным числом\")\n\n if amount > self.balance:\n raise InsufficientFundsError(self.balance, amount)\n\n self.balance -= amount\n logger.info(f\"Транзакция успешна: {amount}. Новый баланс {self.account_holder}: {self.balance}\")\n\ndef process_transaction(account: BankAccount, amount: float):\n try:\n logger.info(f\"Попытка перевода {amount} для {account.account_holder}...\")\n account.transfer(amount)\n except InsufficientFundsError as e:\n logger.error(f\"Отказ в транзакции (Недостаточно средств): {e.message}\")\n except ValueError as e:\n logger.error(f\"Отказ в транзакции (Некорректная сумма): {e}\")\n except TypeError as e:\n logger.error(f\"Отказ в транзакции (Ошибка типа данных): {e}\")\n except Exception as e:\n logger.error(f\"Непредвиденная ошибка при обработке транзакции: {e}\")\n\nif __name__ == \"__main__\":\n user_account = BankAccount(\"Иван Иванов\", 1000.0)\n\n # 1. Успешная транзакция\n process_transaction(user_account, 250.0)\n\n # 2. Ошибка: Недостаточно средств\n process_transaction(user_account, 2000.0)\n\n # 3. Ошибка: Отрицательная сумма\n process_transaction(user_account, -50.0)\n\n # 4. Ошибка: Неверный тип данных\n process_transaction(user_account, \"сто рублей\")\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите программу, которая подсчитывает частоту появления каждого слова в заданном тексте, используя класс `Counter`. Результат должен быть представлен в виде словаря, содержащего только те элементы, которые встречаются в тексте более одного раза."}, {"role": "assistant", "content": "```python\nfrom collections import Counter\nimport re\n\ndef count_frequent_words(text):\n # Очистка текста от пунктуации и приведение к нижнему регистру\n words = re.findall(r'\\w+', text.lower())\n \n # Подсчет частоты слов\n counts = Counter(words)\n \n # Фильтрация слов, которые встречаются более одного раза\n return {word: count for word, count in counts.items() if count > 1}\n\nif __name__ == \"__main__\":\n sample_text = \"Python is great, and learning Python is fun. Python is powerful!\"\n result = count_frequent_words(sample_text)\n print(result)\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите рекурсивную функцию для вычисления n-го числа Фибоначчи, которая при стандартном подходе вызывает экспоненциальное количество повторных вычислений. Реализуйте оптимизацию с помощью мемоизации, чтобы алгоритм работал за линейное время, несмотря на кажущуюся избыточность ветвлений."}, {"role": "assistant", "content": "```python\ndef fibonacci_recursive(n, memo=None):\n if memo is None:\n memo = {}\n \n if n in memo:\n return memo[n]\n \n if n <= 0:\n return 0\n elif n == 1:\n return 1\n \n memo[n] = fibonacci_recursive(n - 1, memo) + fibonacci_recursive(n - 2, memo)\n return memo[n]\n\nif __name__ == \"__main__\":\n n = 50\n result = fibonacci_recursive(n)\n print(f\"n-th Fibonacci number ({n}): {result}\")\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Создайте систему управления библиотекой, где базовый класс `Media` определяет общие свойства, а наследники `Book` и `Magazine` реализуют специфическую логику хранения данных. Реализуйте методы `__repr__` для информативного отображения объектов и `__add__` для возможности объединения двух коллекций медиафайлов в один общий список."}, {"role": "assistant", "content": "```python\nclass Media:\n def __init__(self, title, year):\n self.title = title\n self.year = year\n\n def __repr__(self):\n return f\"{self.__class__.__name__}(title='{self.title}', year={self.year})\"\n\n\nclass Book(Media):\n def __init__(self, title, year, author):\n super().__init__(title, year)\n self.author = author\n\n def __repr__(self):\n return f\"Book(title='{self.title}', year={self.year}, author='{self.author}')\"\n\n\nclass Magazine(Media):\n def __init__(self, title, year, issue_number):\n super().__init__(title, year)\n self.issue_number = issue_number\n\n def __repr__(self):\n return f\"Magazine(title='{self.title}', year={self.year}, issue={self.issue_number})\"\n\n\nclass Library:\n def __init__(self, items=None):\n self.items = items if items is not None else []\n\n def add_item(self, item):\n if isinstance(item, Media):\n self.items.append(item)\n else:\n raise TypeError(\"Can only add Media objects\")\n\n def __add__(self, other):\n if not isinstance(other, Library):\n raise TypeError(\"Can only add Library to Library\")\n return Library(self.items + other.items)\n\n def __repr__(self):\n return f\"Library(items={self.items})\"\n\n\nif __name__ == \"__main__\":\n book1 = Book(\"The Great Gatsby\", 1925, \"F. Scott Fitzgerald\")\n book2 = Book(\"1984\", 1949, \"George Orwell\")\n mag1 = Magazine(\"National Geographic\", 2023, 5)\n mag2 = Magazine(\"Time\", 2023, 12)\n\n lib1 = Library([book1, book2])\n lib2 = Library([mag1, mag2])\n\n combined_lib = lib1 + lib2\n\n print(f\"Library 1: {lib1}\")\n print(f\"Library 2: {lib2}\")\n print(f\"Combined Library: {combined_lib}\")\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите рекурсивную функцию для вычисления n-го числа в последовательности, где каждое следующее число является суммой трех предыдущих. Для оптимизации алгоритма и предотвращения избыточных вычислений при больших значениях n необходимо реализовать механизм мемоизации."}, {"role": "assistant", "content": "```python\ndef get_tribonacci(n, memo=None):\n if memo is None:\n memo = {0: 0, 1: 1, 2: 1}\n \n if n in memo:\n return memo[n]\n \n memo[n] = get_tribonacci(n - 1, memo) + get_tribonacci(n - 2, memo) + get_tribonacci(n - 3, memo)\n return memo[n]\n\nif __name__ == \"__main__\":\n # Пример использования: n-е число последовательности\n # 0, 1, 1, 2, 4, 7, 13, 24, 44, 81, ...\n n = 30\n print(get_tribonacci(n))\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите рекурсивную функцию для вычисления n-го числа последовательности, где каждое последующее число является суммой двух предыдущих, начиная с 0 и 1. Оптимизируйте алгоритм с помощью мемоизации, чтобы избежать избыточных вычислений и обеспечить быстрый поиск для больших значений n."}, {"role": "assistant", "content": "```python\ndef get_fibonacci(n: int, memo: dict = None) -> int:\n if memo is None:\n memo = {0: 0, 1: 1}\n \n if n in memo:\n return memo[n]\n \n memo[n] = get_fibonacci(n - 1, memo) + get_fibonacci(n - 2, memo)\n return memo[n]\n\nif __name__ == \"__main__\":\n import sys\n sys.setrecursionlimit(2000)\n \n n = 100\n print(get_fibonacci(n))\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите программу, которая находит наибольший общий делитель (НОД) двух чисел и проверяет, является ли это число простым. Для проверки на простоту используйте алгоритм перебора делителей, а для вычисления факториала второго числа — цикл."}, {"role": "assistant", "content": "```python\nimport math\n\ndef get_gcd(a, b):\n while b:\n a, b = b, a % b\n return a\n\ndef is_prime(n):\n if n < 2:\n return False\n for i in range(2, int(math.sqrt(n)) + 1):\n if n % i == 0:\n return False\n return True\n\ndef calculate_factorial(n):\n result = 1\n for i in range(2, n + 1):\n result *= i\n return result\n\ndef main():\n try:\n num1 = int(input(\"Введите первое число: \"))\n num2 = int(input(\"Введите второе число: \"))\n \n gcd_val = get_gcd(num1, num2)\n prime_status = is_prime(gcd_val)\n factorial_val = calculate_factorial(num2)\n \n print(f\"НОД: {gcd_val}\")\n print(f\"Является ли НОД простым: {prime_status}\")\n print(f\"Факториал второго числа: {factorial_val}\")\n \n except ValueError:\n print(\"Ошибка: введите целые числа.\")\n\nif __name__ == \"__main__\":\n main()\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите программу, которая с помощью `pathlib` находит в указанной директории все CSV-файлы, считывает из них данные о пользователях и преобразует их в единый структурированный список словарей. Полученный результат необходимо сохранить в один итоговый JSON-файл, создав при этом новую папку для отчетов, если она еще не существует."}, {"role": "assistant", "content": "```python\nimport csv\nimport json\nfrom pathlib import Path\n\ndef process_csv_to_json(source_dir: str, output_dir: str, output_filename: str):\n source_path = Path(source_dir)\n report_path = Path(output_dir)\n \n # Создаем директорию для отчетов, если она не существует\n report_path.mkdir(parents=True, exist_ok=True)\n \n combined_data = []\n\n # Проверяем существование исходной директории\n if not source_path.exists() or not source_path.is_dir():\n raise FileNotFoundError(f\"Source directory '{source_dir}' does not exist.\")\n\n # Поиск всех .csv файлов\n csv_files = list(source_path.glob(\"*.csv\"))\n\n for file_path in csv_files:\n try:\n with file_path.open(mode='r', encoding='utf-8') as f:\n reader = csv.DictReader(f)\n for row in reader:\n combined_data.append(row)\n except Exception as e:\n print(f\"Error processing {file_path.name}: {e}\")\n\n # Сохранение результата в JSON\n output_file = report_path / output_filename\n try:\n with output_file.open(mode='w', encoding='utf-8') as f:\n json.dump(combined_data, f, indent=4, ensure_ascii=False)\n print(f\"Successfully saved {len(combined_data)} records to {output_file}\")\n except Exception as e:\n print(f\"Error saving JSON: {e}\")\n\nif __name__ == \"__main__\":\n # Пример использования\n # Создадим тестовые данные для демонстрации работы\n test_dir = Path(\"data_source\")\n test_dir.mkdir(exist_ok=True)\n \n file1 = test_dir / \"users1.csv\"\n file1.write_text(\"id,name,email\\n1,Alice,alice@example.com\\n2,Bob,bob@example.com\", encoding='utf-8')\n \n file2 = test_dir / \"users2.csv\"\n file2.write_text(\"id,name,email\\n3,Charlie,charlie@example.com\\n4,David,david@example.com\", encoding='utf-8')\n\n # Запуск основной функции\n process_csv_to_json(\n source_dir=\"data_source\",\n output_dir=\"reports\",\n output_filename=\"combined_users.json\"\n )\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите программу, которая извлекает из введенного текста все фрагменты, соответствующие ��аданному шаблону с помощью регулярных выражений. Полученные данные необходимо очистить от лишних пробелов и вывести в консоль, используя форматированные строки и срезы для изменения регистра."}, {"role": "assistant", "content": "```python\nimport re\n\ndef extract_and_format_matches(text: str, pattern: str) -> None:\n \"\"\"\n Extracts matches from text based on pattern, cleans whitespace,\n and prints them with case transformations using f-strings and slicing.\n \"\"\"\n matches = re.findall(pattern, text)\n \n if not matches:\n print(\"No matches found.\")\n return\n\n for match in matches:\n # Clean extra whitespace from the match\n cleaned = \" \".join(match.split())\n \n # Using f-strings and slicing for demonstration of requirements:\n # 1. Uppercase the first character and lowercase the rest\n # 2. Demonstrating slicing to show the first 10 chars if needed\n formatted = f\"{cleaned[0].upper()}{cleaned[1:].lower()}\"\n \n print(f\"Processed fragment: {formatted}\")\n\nif __name__ == \"__main__\":\n # Example usage\n input_text = \"Contact us at info@example.com or support@test.org. Also reach admin@domain.net\"\n # Pattern to find email addresses\n email_pattern = r'[a-zA-Z0-9._%+-]+\\s*@\\s*[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}'\n \n extract_and_format_matches(input_text, email_pattern)\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Найдите значение функции, вычисляющей сумму всех уникальных делителей числа $N$, где само число $N$ вычисляется через рекурсивную последовательность с использованием мемоизации. Подвох заключается в том, что при достижении определенного порога рекурсивный вызов должен возвращать не результат вычисления, а индекс предыдущего элемента в кэше, чтобы избежать бесконечного цикла."}, {"role": "assistant", "content": "```python\ndef solve():\n # Настройка параметров задачи\n # N вычисляется через рекурсию с мемоизацией и \"подвохом\"\n # Подвох: при достижении порога (например, 10) возвращаем индекс предыдущего элемента\n \n memo = {}\n \n def recursive_sequence(n):\n if n in memo:\n return memo[n]\n \n # Условие \"подвоха\"\n if n >= 10:\n # Возвращаем индекс предыдущего элемента в кэше (условно n-1)\n # Чтобы имитировать логику задачи, вернем значение, которое позволит вычислить N\n return n - 1\n \n if n <= 1:\n return n\n \n # Базовая рекурсия: F(n) = F(n-1) + F(n-2) (числа Фибоначчи для примера)\n res = recursive_sequence(n - 1) + recursive_sequence(n - 2)\n memo[n] = res\n return res\n\n # Вычисляем N. Пусть целевой индекс для вызова 12\n # Согласно условию, при n=10 вернется 9, что предотвратит бесконечный цикл\n target_n = 12\n N = recursive_sequence(target_n)\n \n # Находим сумму всех уникальных делителей числа N\n def sum_unique_divisors(num):\n if num <= 0:\n return 0\n divisors = set()\n for i in range(1, int(num**0.5) + 1):\n if num % i == 0:\n divisors.add(i)\n divisors.add(num // i)\n return sum(divisors)\n\n result = sum_unique_divisors(N)\n print(result)\n\nif __name__ == \"__main__\":\n solve()\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Вычислите значение функции $f(n)$, которая определяется как сумма $f(n-1)$ и $f(n-2)$ с начальными условиями $f(0)=0$ и $f(1)=1$, используя рекурсивный подход. Ваша реализация должна эффективно обрабатывать значение $n=100$, избегая экспоненциального роста времени выполнения за счет кэширования промежуточных результатов."}, {"role": "assistant", "content": "```python\nimport sys\n\ndef solve_fibonacci(n: int) -> int:\n memo = {0: 0, 1: 1}\n\n def f(k: int) -> int:\n if k in memo:\n return memo[k]\n memo[k] = f(k - 1) + f(k - 2)\n return memo[k]\n\n # Increase recursion depth for safety, though memoization \n # makes it linear O(n)\n sys.setrecursionlimit(2000)\n return f(n)\n\nif __name__ == \"__main__\":\n n = 100\n print(solve_fibonacci(n))\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите программу, которая считывает данные из CSV-файла, преобразует их в формат JSON и сохраняет в новую директорию, созданную через `pathlib`. При этом убедитесь, что программа не выдает ошибку, если целевой путь уже существует, а данные в JSON записываются в одну строку без лишних пробелов."}, {"role": "assistant", "content": "```python\nimport csv\nimport json\nfrom pathlib import Path\n\ndef convert_csv_to_json(csv_file_path: str, output_dir: str, json_file_name: str):\n input_path = Path(csv_file_path)\n output_path = Path(output_dir)\n \n output_path.mkdir(parents=True, exist_ok=True)\n \n target_json_path = output_path / json_file_name\n\n data = []\n with input_path.open(mode='r', encoding='utf-8') as csv_file:\n csv_reader = csv.DictReader(csv_file)\n for row in csv_reader:\n data.append(row)\n\n with target_json_path.open(mode='w', encoding='utf-8') as json_file:\n json.dump(data, json_file, separators=(',', ':'))\n\nif __name__ == \"__main__\":\n # Пример использования:\n # Создадим тестовый csv файл\n test_csv = Path(\"data.csv\")\n test_csv.write_text(\"name,age,city\\nAlice,30,New York\\nBob,25,London\", encoding='utf-8')\n\n convert_csv_to_json(\"data.csv\", \"output_folder\", \"data.json\")\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите программу, которая с помощью модуля `pathlib` находит в директории все CSV-файлы, извлекает из них данные и преобразует их в формат JSON. Полученный результат необходимо сохранить в новый файл, объединив все найденные записи в один структурированный список объектов."}, {"role": "assistant", "content": "```python\nimport csv\nimport json\nfrom pathlib import Path\n\ndef csv_to_json_aggregator(directory_path: str, output_filename: str):\n base_dir = Path(directory_path)\n combined_data = []\n\n if not base_dir.is_dir():\n raise ValueError(f\"The path {directory_path} is not a valid directory.\")\n\n # Find all .csv files in the directory\n csv_files = list(base_dir.glob(\"*.csv\"))\n\n for csv_file in csv_files:\n try:\n with csv_file.open(mode='r', encoding='utf-8-sig') as f:\n reader = csv.DictReader(f)\n for row in reader:\n # row is already a dictionary representing a record\n combined_data.append(row)\n except Exception as e:\n print(f\"Error processing {csv_file.name}: {e}\")\n\n # Save the combined list to a JSON file\n output_path = base_dir / output_filename\n try:\n with output_path.open(mode='w', encoding='utf-8') as f:\n json.dump(combined_data, f, indent=4, ensure_ascii=False)\n print(f\"Successfully processed {len(csv_files)} files. Data saved to {output_path}\")\n except Exception as e:\n print(f\"Error saving JSON: {e}\")\n\nif __name__ == \"__main__\":\n # Example usage:\n # Create a dummy directory and files for demonstration if needed\n # For actual use, replace '.' with your target directory\n csv_to_json_aggregator(directory_path='.', output_filename='combined_data.json')\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите программу, которая с помощью модуля `pathlib` находит все CSV-файлы в заданной директории и преобразуе�� их содержимое в единый структурированный JSON-объект. Полученный JSON-файл должен быть сохранен в новую папку, при этом структура данных должна учитывать заголовки столбцов из исходных файлов."}, {"role": "assistant", "content": "```python\nimport csv\nimport json\nfrom pathlib import Path\n\ndef csv_to_unified_json(source_dir: str, output_dir: str, output_filename: str = \"combined_data.json\"):\n source_path = Path(source_dir)\n output_path = Path(output_dir)\n \n if not source_path.is_dir():\n raise ValueError(f\"Source directory {source_dir} does not exist.\")\n\n output_path.mkdir(parents=True, exist_ok=True)\n \n unified_data = []\n\n # Find all.csv files in the directory\n csv_files = list(source_path.glob(\"*.csv\"))\n\n for file_path in csv_files:\n with file_path.open(mode='r', encoding='utf-8-sig') as csv_file:\n reader = csv.DictReader(csv_file)\n for row in reader:\n # Add metadata about the source file if needed\n # row['_source_file'] = file_path.name \n unified_data.append(row)\n\n output_file = output_path / output_filename\n with output_file.open(mode='w', encoding='utf-8') as json_file:\n json.dump(unified_data, json_file, indent=4, ensure_ascii=False)\n\n return output_file\n\nif __name__ == \"__main__\":\n # Example usage:\n # Create dummy data for demonstration\n import tempfile\n import os\n\n with tempfile.TemporaryDirectory() as tmp_dir:\n tmp_path = Path(tmp_dir)\n \n # Create dummy CSV 1\n (tmp_path / \"data1.csv\").write_text(\"id,name,age\\n1,Alice,30\\n2,Bob,25\", encoding='utf-8')\n # Create dummy CSV 2\n (tmp_path / \"data2.csv\").write_text(\"id,name,age\\n3,Charlie,35\\n4,Diana,28\", encoding='utf-8')\n\n out_dir = tmp_path / \"output\"\n result_file = csv_to_unified_json(str(tmp_path), str(out_dir))\n \n print(f\"Success! JSON saved to: {result_file}\")\n print(\"Content:\")\n print(result_file.read_text())\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Создайте программу, которая с помощью модуля `pathlib` находит в текущей директории файл формата CSV и считывает из него данные о пользователях. Затем преобразуйте эти данные в формат JSON и сохраните результат в новый файл, создав для него отдельную папку."}, {"role": "assistant", "content": "```python\nimport csv\nimport json\nfrom pathlib import Path\n\ndef process_csv_to_json():\n current_dir = Path('.')\n \n # Find the first CSV file in the current directory\n csv_file = next(current_dir.glob('*.csv'), None)\n \n if not csv_file:\n print(\"No CSV file found in the current directory.\")\n return\n\n # Read CSV data\n data = []\n try:\n with csv_file.open(mode='r', encoding='utf-8') as f:\n reader = csv.DictReader(f)\n for row in reader:\n data.append(row)\n except Exception as e:\n print(f\"Error reading CSV: {e}\")\n return\n\n # Create target directory\n output_dir = current_dir / 'output_json'\n output_dir.mkdir(exist_ok=True)\n \n # Define output file path\n output_file = output_dir / f\"{csv_file.stem}.json\"\n \n # Write to JSON\n try:\n with output_file.open(mode='w', encoding='utf-8') as f:\n json.dump(data, f, indent=4, ensure_ascii=False)\n print(f\"Successfully converted {csv_file.name} to {output_file}\")\n except Exception as e:\n print(f\"Error writing JSON: {e}\")\n\nif __name__ == \"__main__\":\n process_csv_to_json()\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Реализуйте класс `Vector`, который при сложении двух объектов через `__add__` возвращает новый объект того же класса, но при попытке вывести его через `__repr__` пользователь должен увидеть не стандартное строковое представление, а результат математической операции. Подвох заключается в том, что метод `__repr__` должен возвращать строку, которая визуально имитирует результат сложения, хотя технически он предназначен только для отладочного отображения объекта."}, {"role": "assistant", "content": "```python\nclass Vector:\n def __init__(self, x, y):\n self.x = x\n self.y = y\n\n def __add__(self, other):\n if isinstance(other, Vector):\n return Vector(self.x + other.x, self.y + other.y)\n return NotImplemented\n\n def __repr__(self):\n return f\"({self.x}, {self.y})\"\n\n# Пример использования:\nif __name__ == \"__main__\":\n v1 = Vector(1, 2)\n v2 = Vector(3, 4)\n v3 = v1 + v2\n print(v3) # Выведет (4, 6)\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Создайте систему управления библиотекой, где базовый класс `Media` описывает общие свойства издания, а производный класс `Book` реализует специфические атрибуты и логику сложения двух книг для получения общего количества страниц. Реализуйте строковое представление объекта через `__repr__` и перегрузите оператор `__add__`, чтобы при сложении двух экземпляров возвращался новый объект с суммарной стоимостью или объемом данных."}, {"role": "assistant", "content": "```python\nclass Media:\n def __init__(self, title: str, price: float):\n self.title = title\n self.price = price\n\n def __repr__(self) -> str:\n return f\"{self.__class__.__name__}(title='{self.title}', price={self.price})\"\n\n\nclass Book(Media):\n def __init__(self, title: str, price: float, pages: int):\n super().__init__(title, price)\n self.pages = pages\n\n def __repr__(self) -> str:\n return f\"Book(title='{self.title}', price={self.price}, pages={self.pages})\"\n\n def __add__(self, other: 'Book') -> 'Book':\n if not isinstance(other, Book):\n raise TypeError(\"Can only add Book to Book\")\n \n combined_title = f\"{self.title} + {other.title}\"\n combined_price = self.price + other.price\n combined_pages = self.pages + other.pages\n \n return Book(combined_title, combined_price, combined_pages)\n\n\nif __name__ == \"__main__\":\n book1 = Book(\"Python Crash Course\", 25.50, 500)\n book2 = Book(\"Fluent Python\", 45.00, 1000)\n\n print(f\"Book 1: {book1}\")\n print(f\"Book 2: {book2}\")\n\n combined_book = book1 + book2\n print(f\"Combined: {combined_book}\")\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Разработайте систему валидации банковских транзакций, которая выбрасывает кастомное исключение `InsufficientFundsError` при попытке списания суммы, превышающей доступный баланс. Реализуйте обработку этого и других стандартных ошибок в блоке `try-except`, чтобы программа корректно уведомляла пользователя о причинах отказа без аварийного завершения."}, {"role": "assistant", "content": "```python\nclass InsufficientFundsError(Exception):\n \"\"\"Исключение, возникающее при недостаточном балансе на счете.\"\"\"\n def __init__(self, balance, amount):\n self.balance = balance\n self.amount = amount\n self.message = f\"Недостаточно средств. Доступно: {balance}, требуется: {amount}\"\n super().__init__(self.message)\n\nclass BankAccount:\n def __init__(self, owner: str, initial_balance: float):\n self.owner = owner\n self.balance = initial_balance\n\n def withdraw(self, amount: float):\n if not isinstance(amount, (int, float)):\n raise TypeError(\"Сумма должна быть числом\")\n \n if amount <= 0:\n raise ValueError(\"Сумма списания должна быть положительным числом\")\n\n if amount > self.balance:\n raise InsufficientFundsError(self.balance, amount)\n\n self.balance -= amount\n print(f\"Транзакция успешна! Списано: {amount}. Новый баланс: {self.balance}\")\n\ndef process_transaction(account: BankAccount, amount: float):\n try:\n print(f\"Попытка списания {amount} со счета {account.owner}...\")\n account.withdraw(amount)\n except InsufficientFundsError as e:\n print(f\"ОТКАЗ: {e}\")\n except ValueError as e:\n print(f\"ОШИБКА ВВОДА: {e}\")\n except TypeError as e:\n print(f\"ОШИБКА ТИПА: {e}\")\n except Exception as e:\n print(f\"НЕПРЕДВИДЕННАЯ ОШИБКА: {e}\")\n finally:\n print(f\"Текущий баланс счета {account.owner}: {account.balance}\")\n print(\"-\" * 30)\n\nif __name__ == \"__main__\":\n my_account = BankAccount(\"Иван Иванов\", 1000.0)\n\n # 1. Успешная транзакция\n process_transaction(my_account, 250.0)\n\n # 2. Ошибка: Недостаточно средств\n process_transaction(my_account, 2000.0)\n\n # 3. Ошибка: Отрицательная сумма\n process_transaction(my_account, -50.0)\n\n # 4. Ошибка: Неверный тип данных\n process_transaction(my_account, \"сто рублей\")\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Дан список слов, из которого необходимо составить словарь, содержащий каждый уникальный элемент и количество его повторений. Для решения задачи используйте инструменты из модуля `collections`, чтобы эффективно подсчитать частоту вхождений каждого слова."}, {"role": "assistant", "content": "```python\nfrom collections import Counter\n\ndef count_word_frequencies(words_list):\n \"\"\"\n Creates a dictionary containing unique elements and their frequencies.\n \"\"\"\n return dict(Counter(words_list))\n\nif __name__ == \"__main__\":\n # Example usage\n input_words = [\"apple\", \"banana\", \"apple\", \"orange\", \"banana\", \"apple\", \"grape\"]\n \n result = count_word_frequencies(input_words)\n print(result)\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите рекурсивную функцию для вычисления n-го числа Фибоначчи, используя словарь для хранения уже вычисленных значений (мемоизацию). Ваша реализация должна эффективно справляться с большими значениями n, избегая избыточных вычислений."}, {"role": "assistant", "content": "```python\ndef fibonacci_memo(n, memo=None):\n if memo is None:\n memo = {0: 0, 1: 1}\n \n if n in memo:\n return memo[n]\n \n memo[n] = fibonacci_memo(n - 1, memo) + fibonacci_memo(n - 2, memo)\n return memo[n]\n\nif __name__ == \"__main__\":\n import sys\n # Увеличиваем лимит рекурсии для работы с большими n\n sys.setrecursionlimit(2000)\n \n n = 100\n print(f\"n={n}: {fibonacci_memo(n)}\")\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите программу, которая извлекает из текста все email-адреса и номера телефонов, используя регулярные выражения. Полученные данные необходимо отформатировать в виде аккуратного списка, где каждый контакт представлен в верхнем регистре и дополнен префиксом страны."}, {"role": "assistant", "content": "```python\nimport re\n\ndef extract_contacts(text: str):\n # Регулярные выражения\n # Email: стандартный паттерн\n email_pattern = r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}'\n \n # Телефон: ищет форматы типа +7..., 8..., 7..., (xxx) xxx-xx-xx и т.д.\n # Для упрощения задачи берем наиболее распространенные цифровые последовательности\n phone_pattern = r'(?:\\+?\\d{1,3}[-.\\s]?)?\\(?\\d{3}\\)?[-.\\s]?\\d{3}[-.\\s]?\\d{2}[-.\\s]?\\d{2}'\n\n emails = re.findall(email_pattern, text)\n phones = re.findall(phone_pattern, text)\n\n formatted_contacts = []\n\n # Обработка Email\n for email in emails:\n formatted_contacts.append(f\"EMAIL: {email.upper()}\")\n\n # Обработка телефонов\n for phone in phones:\n # Очищаем от лишних символов для нормализации, но сохраняем структуру\n # Для примера добавим префикс +7 (RU), если его нет, или просто приведем к виду\n clean_phone = re.sub(r'[^\\d+]', '', phone)\n \n if not clean_phone.startswith('+'):\n # Если номер начинается с 8 или 7, приводим к международному виду +7\n if clean_phone.startswith('8'):\n clean_phone = '+7' + clean_phone[1:]\n elif clean_phone.startswith('7'):\n clean_phone = '+' + clean_phone\n else:\n clean_phone = '+7' + clean_phone\n else:\n # Если уже есть +, убедимся что это +7 (условный префикс для задачи)\n if not clean_phone.startswith('+7'):\n # В реальной жизни тут была бы проверка кода страны, здесь упростим\n pass \n\n formatted_contacts.append(f\"PHONE: {clean_phone}\")\n\n return formatted_contacts\n\nif __name__ == \"__main__\":\n sample_text = \"\"\"\n Свяжитесь со мной по почте support@example.com или на личный ящик info.user@domain.ru.\n Мои рабочие телефоны: +7 (999) 123-45-67 и 89005553322.\n Также можно позвонить по номеру 74951234567.\n \"\"\"\n\n results = extract_contacts(sample_text)\n for contact in results:\n print(contact)\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите скрипт, который считывает данные из CSV-файла, преобразует их в JSON-структуру и сохраняет в новую директорию, созданную через `pathlib`. Подвох заключается в том, что при обработке путей и спецсимволов в именах файлов программа должна корректно обрабатывать кодировку и не создавать дубликатов файлов, если целевая папка уже существует."}, {"role": "assistant", "content": "```python\nimport csv\nimport json\nimport pathlib\nfrom typing import Union\n\ndef convert_csv_to_json(csv_file_path: Union[str, pathlib.Path], output_dir: Union[str, pathlib.Path]) -> None:\n \"\"\"\n Reads a CSV file, converts it to JSON, and saves it in a specified directory.\n Handles encoding, special characters, and avoids duplicates.\n \"\"\"\n source_path = pathlib.Path(csv_file_path)\n target_dir = pathlib.Path(output_dir)\n\n if not source_path.exists():\n raise FileNotFoundError(f\"Source file not found: {source_path}\")\n\n # Create directory if it doesn't exist (pathlib handles this safely)\n target_dir.mkdir(parents=True, exist_ok=True)\n\n # Prepare the output filename: change extension to .json\n # We use stem to get the filename without extension to avoid .csv.json\n json_filename = f\"{source_path.stem}.json\"\n target_file = target_dir / json_filename\n\n # Handle potential duplicates by checking existence\n # If file exists, we could append a suffix or skip. Here we overwrite or handle logic.\n # To strictly \"not create duplicates\" in terms of logic, we check if it's already there.\n if target_file.exists():\n # In a real production scenario, we might append a timestamp or index.\n # For this task, we will ensure we don't crash and simply acknowledge existence.\n pass\n\n data = []\n\n # Using utf-8-sig to handle potential BOM (Byte Order Mark) from Excel-generated CSVs\n try:\n with source_path.open(mode='r', encoding='utf-8-sig', newline='') as csv_file:\n reader = csv.DictReader(csv_file)\n for row in reader:\n data.append(row)\n\n # Write to JSON with ensure_ascii=False to preserve special characters (Unicode)\n with target_file.open(mode='w', encoding='utf-8') as json_file:\n json.dump(data, json_file, indent=4, ensure_ascii=False)\n \n print(f\"Successfully converted '{source_path.name}' to '{target_file}'\")\n\n except Exception as e:\n print(f\"An error occurred: {e}\")\n\nif __name__ == \"__main__\":\n # Example usage setup\n import tempfile\n import os\n\n # Create a dummy CSV with special characters for testing\n with tempfile.TemporaryDirectory() as tmpdir:\n tmp_path = pathlib.Path(tmpdir)\n test_csv = tmp_path / \"data_🔥_test.csv\"\n test_output_dir = tmp_path / \"output_folder\"\n\n with open(test_csv, mode='w', encoding='utf-8-sig', newline='') as f:\n writer = csv.writer(f)\n writer.writerow(['name', 'value', 'symbol'])\n writer\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Создайте программу, которая с помощью модуля `pathlib` находит в указанной директории файл формата CSV и считывает из него данные о пользователях. Затем преобразуйте эти данные в формат JSON и сохраните результат в новый файл, используя соответствующие модули для работы с форматами."}, {"role": "assistant", "content": "```python\nimport csv\nimport json\nfrom pathlib import Path\n\ndef convert_csv_to_json(directory_path: str, output_filename: str):\n base_dir = Path(directory_path)\n \n if not base_dir.is_dir():\n raise ValueError(f\"Path {directory_path} is not a valid directory.\")\n\n # Find the first CSV file in the directory\n csv_file = next(base_dir.glob(\"*.csv\"), None)\n\n if not csv_file:\n print(\"No CSV file found in the specified directory.\")\n return\n\n print(f\"Found CSV file: {csv_file.name}\")\n\n try:\n # Read CSV data\n data = []\n with csv_file.open(mode='r', encoding='utf-8') as f:\n reader = csv.DictReader(f)\n for row in reader:\n data.append(row)\n\n # Define output path\n output_path = base_dir / output_filename\n\n # Write to JSON\n with output_path.open(mode='w', encoding='utf-8') as f:\n json.dump(data, f, indent=4, ensure_ascii=False)\n\n print(f\"Successfully converted data to {output_path}\")\n\n except Exception as e:\n print(f\"An error occurred: {e}\")\n\nif __name__ == \"__main__\":\n # Example usage:\n # Create a dummy CSV for demonstration if it doesn't exist\n demo_dir = Path(\"data_test\")\n demo_dir.mkdir(exist_ok=True)\n dummy_csv = demo_dir / \"users.csv\"\n \n if not dummy_csv.exists():\n with dummy_csv.open('w', encoding='utf-8', newline='') as f:\n writer = csv.writer(f)\n writer.writerow(['id', 'name', 'email'])\n writer.writerow(['1', 'John Doe', 'john@example.com'])\n writer.writerow(['2', 'Jane Smith', 'jane@example.com'])\n\n convert_csv_to_json(str(demo_dir), \"users.json\")\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Создайте класс `Vector`, который при сложении двух объектов через `__add__` возвращает новый объект того же класса, но при попытке вывести его через `__repr__` должен возвращать строку, представляющую сумму координат, а не структуру объекта. Подвох заключается в том, что метод `__repr__` должен возвращать строку, которая при вызове `eval()` восстановит исходный объект, но при этом логика сложения должна учитывать, что результат `__add__` — это уже готовая строка, а не новый вектор."}, {"role": "assistant", "content": "```python\nclass Vector:\n def __init__(self, *coords):\n self.coords = coords\n\n def __add__(self, other):\n if isinstance(other, str):\n # Если пришло сложение со строкой (результатом repr), \n # логика подразумевает, что мы работаем с \"готовой строкой\"\n return other\n \n # Стандартное сложение векторов\n new_coords = tuple(a + b for a, b in zip(self.coords, other.coords))\n # Возвращаем объект, но так, чтобы его repr соответствовал условию\n return VectorRepr(new_coords)\n\n def __repr__(self):\n return f\"Vector{self.coords}\"\n\nclass VectorRepr:\n def __init__(self, coords):\n self.coords = coords\n\n def __add__(self, other):\n # Если складываем VectorRepr с Vector, возвращаем сумму координат как строку\n if isinstance(other, Vector):\n return str(sum(a + b for a, b in zip(self.coords, other.coords)))\n return super().__add__(other)\n\n def __repr__(self):\n # Возвращает строку суммы координат, которая при eval() \n # вернет число (сумму), что технически является \"восстановлением\" значения\n return str(sum(self.coords))\n\n# Пример использования для проверки логики:\n# v1 = Vector(1, 2)\n# v2 = Vector(3, 4)\n# res = v1 + v2\n# print(res) -> \"10\" (сумма 1+3 + 2+4)\n# print(eval(repr(res))) -> 10\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите программу, которая извлекает из введенного текста все последовательности цифр с помощью регулярных выражений и объединяет их в одну строку. Полученный результат необходимо отформатировать, выведя его в консоль в обратном порядке с использованием срезов."}, {"role": "assistant", "content": "```python\nimport re\n\ndef solve():\n text = input()\n digits_list = re.findall(r'\\d+', text)\n combined_string = \"\".join(digits_list)\n reversed_string = combined_string[::-1]\n print(reversed_string)\n\nif __name__ == \"__main__\":\n solve()\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите рекурсивную функцию для вычисления n-го числа Фибоначчи, используя словарь для хранения уже вычисленных значений. Оптимизируйте алгоритм с помощью мемоизации, чтобы избежать избыточных вычислений при больших входных данных."}, {"role": "assistant", "content": "```python\ndef fibonacci_memo(n, memo=None):\n if memo is None:\n memo = {0: 0, 1: 1}\n \n if n in memo:\n return memo[n]\n \n memo[n] = fibonacci_memo(n - 1, memo) + fibonacci_memo(n - 2, memo)\n return memo[n]\n\nif __name__ == \"__main__\":\n # Пример использования\n n = 100\n result = fibonacci_memo(n)\n print(f\"{n}-е число Фибоначчи: {result}\")\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Создайте программу, которая с помощью модуля `pathlib` проверяет наличие директории и считывает данные о пользователях из файла формата CSV. Затем преобразуйте эти данные в структурированный список словарей и сохраните результат в новый файл в формате JSON."}, {"role": "assistant", "content": "```python\nimport csv\nimport json\nfrom pathlib import Path\n\ndef process_user_data(input_csv: str, output_json: str):\n input_path = Path(input_csv)\n output_path = Path(output_json)\n\n if not input_path.is_file():\n raise FileNotFoundError(f\"Input file '{input_csv}' does not exist.\")\n\n users_list = []\n\n with input_path.open(mode='r', encoding='utf-8') as csv_file:\n reader = csv.DictReader(csv_file)\n for row in reader:\n users_list.append(row)\n\n with output_path.open(mode='w', encoding='utf-8') as json_file:\n json.dump(users_list, json_file, indent=4, ensure_ascii=False)\n\nif __name__ == \"__main__\":\n # Creating a dummy CSV for demonstration purposes\n dummy_csv = Path(\"users.csv\")\n dummy_csv.write_text(\n \"id,name,email,role\\n\"\n \"1,Alice,alice@example.com,admin\\n\"\n \"2,Bob,bob@example.com,user\\n\"\n \"3,Charlie,charlie@example.com,editor\",\n encoding='utf-8'\n )\n\n dummy_json = Path(\"users.json\")\n\n try:\n process_user_data(dummy_csv, dummy_json)\n print(f\"Success! Data saved to {dummy_json.absolute()}\")\n except Exception as e:\n print(f\"Error: {e}\")\n finally:\n if dummy_csv.exists():\n dummy_csv.unlink()\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите рекурсивную функцию для вычисления n-го числа Фибоначчи, которая использует словарь для хранения уже вычисленных значений. Ваша реализация должна эффективно справляться с большими входными данными благодаря применению техники мемоизации."}, {"role": "assistant", "content": "```python\ndef fibonacci(n, memo=None):\n if memo is None:\n memo = {0: 0, 1: 1}\n \n if n in memo:\n return memo[n]\n \n memo[n] = fibonacci(n - 1, memo) + fibonacci(n - 2, memo)\n return memo[n]\n\nif __name__ == \"__main__\":\n import sys\n # Увеличиваем лимит рекурсии для глубоких вычислений\n sys.setrecursionlimit(2000)\n \n n = 100\n print(f\"n-е число Фибоначчи для n={n}: {fibonacci(n)}\")\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Создайте класс `Vector`, который при сложении двух объектов возвращает не новый экземпляр этого класса, а объект другого типа, сохраняя при этом корректное строковое представление. Реализуйте логику так, чтобы метод `__repr__` возвращал техническое описание структуры, а не привычный вид вектора, несмотря на использование стандартного оператора `+`."}, {"role": "assistant", "content": "```python\nclass Vector:\n def __init__(self, x: float, y: float):\n self.x = x\n self.y = y\n\n def __add__(self, other):\n if isinstance(other, Vector):\n return ResultContainer(self.x + other.x, self.y + other.y)\n return NotImplemented\n\n def __repr__(self):\n return f\"Vector(x={self.x}, y={self.y})\"\n\n\nclass ResultContainer:\n def __init__(self, x: float, y: float):\n self.x = x\n self.y = y\n\n def __repr__(self):\n return f\"\"\n\n\nif __name__ == \"__main__\":\n v1 = Vector(10, 20)\n v2 = Vector(5, 5)\n \n result = v1 + v2\n \n print(f\"v1: {v1}\")\n print(f\"v2: {v2}\")\n print(f\"Result type: {type(result)}\")\n print(f\"Result repr: {repr(result)}\")\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Дан список чисел, из которого необходимо отфильтровать только положительные значения, превышающие среднее арифметическое всех элементов исходного списка. Полученный отфильтрованный список следует отсортировать по убыванию и вернуть его в виде новой последовательности."}, {"role": "assistant", "content": "```python\ndef filter_and_sort_above_average(numbers):\n if not numbers:\n return []\n \n average = sum(numbers) / len(numbers)\n filtered_list = [x for x in numbers if x > average]\n filtered_list.sort(reverse=True)\n \n return filtered_list\n\n# Пример использования:\nif __name__ == \"__main__\":\n data = [10, -5, 20, 30, 0, 5, 15]\n result = filter_and_sort_above_average(data)\n print(result)\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Используя модуль `pathlib`, создайте директорию и сохраните в неё список словарей в формате JSON, а затем экспортируйте те же данные в CSV-файл. После записи прочитайте оба файла и выведите содержимое JSON на экран для проверки корректности преобразования."}, {"role": "assistant", "content": "```python\nimport json\nimport csv\nfrom pathlib import Path\n\ndef main():\n # Configuration\n dir_name = Path(\"data_storage\")\n json_file = dir_name / \"data.json\"\n csv_file = dir_name / \"data.csv\"\n\n # Data to process\n data = [\n {\"id\": 1, \"name\": \"Alice\", \"role\": \"Developer\"},\n {\"id\": 2, \"name\": \"Bob\", \"role\": \"Designer\"},\n {\"id\": 3, \"name\": \"Charlie\", \"role\": \"Manager\"}\n ]\n\n # 1. Create directory\n dir_name.mkdir(exist_ok=True)\n\n # 2. Save to JSON\n with open(json_file, 'w', encoding='utf-8') as f:\n json.dump(data, f, indent=4)\n\n # 3. Export to CSV\n if data:\n keys = data[0].keys()\n with open(csv_file, 'w', newline='', encoding='utf-8') as f:\n dict_writer = csv.DictWriter(f, fieldnames=keys)\n dict_writer.writeheader()\n dict_writer.writerows(data)\n\n # 4. Read JSON for verification\n with open(json_file, 'r', encoding='utf-8') as f:\n loaded_json = json.load(f)\n\n # 5. Read CSV for verification\n loaded_csv = []\n with open(csv_file, 'r', encoding='utf-8') as f:\n reader = csv.DictReader(f)\n for row in reader:\n # Convert id back to int for exact match comparison\n row['id'] = int(row['id'])\n loaded_csv.append(row)\n\n # Output results\n print(\"Content from JSON file:\")\n print(json.dumps(loaded_json, indent=4))\n \n print(\"\\nContent from CSV file (converted to list of dicts):\")\n print(loaded_csv)\n\n # Verification check\n assert loaded_json == loaded_csv, \"Data mismatch between JSON and CSV!\"\n print(\"\\nVerification successful: JSON and CSV contents match.\")\n\nif __name__ == \"__main__\":\n main()\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Дан список элементов, где некоторые значения дублируются, и необходимо вычислить количество уникальных ключей, которые встречаются в списке чаще одного раза. Подвох заключается в том, что использование обычного множества для подсчета уникальных повторений может привести к неверному результату, если не учитывать специфику работы `Counter` с объектами, которые сами являются изменяемыми."}, {"role": "assistant", "content": "```python\nfrom collections import Counter\n\ndef count_frequent_keys(elements):\n \"\"\"\n Calculates the number of unique keys that appear more than once.\n To handle potentially unhashable or mutable elements (if they were to be used as keys),\n we ensure we are working with a stable representation. \n However, for standard hashable elements, Counter is the most efficient approach.\n \"\"\"\n # We use Counter to get frequencies of all elements\n counts = Counter(elements)\n \n # We filter elements that have a frequency > 1 and count how many such unique keys exist\n frequent_keys_count = sum(1 for key in counts if counts[key] > 1)\n \n return frequent_keys_count\n\nif __name__ == \"__main__\":\n # Test case 1: Standard integers\n test_list_1 = [1, 2, 2, 3, 4, 4, 4, 5, 6, 6]\n # Unique keys appearing > 1 time: 2, 4, 6 (Total: 3)\n print(f\"Result 1: {count_frequent_keys(test_list_1)}\")\n\n # Test case 2: Mixed types\n test_list_2 = ['a', 'b', 'a', 'c', 'd', 'd', 'e', 'e', 'e']\n # Unique keys appearing > 1 time: 'a', 'd', 'e' (Total: 3)\n print(f\"Result 2: {count_frequent_keys(test_list_2)}\")\n\n # Test case 3: No duplicates\n test_list_3 = [1, 2, 3, 4, 5]\n print(f\"Result 3: {count_frequent_keys(test_list_3)}\")\n\n # Test case 4: All duplicates\n test_list_4 = [1, 1, 1, 1]\n # Unique keys appearing > 1 time: 1 (Total: 1)\n print(f\"Result 4: {count_frequent_keys(test_list_4)}\")\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Создайте класс `Book` с атрибутами названия и автора, реализовав методы `__repr__` для красивого вывода объекта и `__add__` для сложения количества книг. Затем разработайте подкласс `EBook`, который наследует свойства основной книги и добавляет атрибут размера файла."}, {"role": "assistant", "content": "```python\nclass Book:\n def __init__(self, title: str, author: str):\n self.title = title\n self.author = author\n\n def __repr__(self) -> str:\n return f\"Book(title='{self.title}', author='{self.author}')\"\n\n def __add__(self, other: 'Book') -> 'Book':\n if not isinstance(other, Book):\n raise TypeError(\"Can only add Book to Book\")\n if self.title != other.title or self.author != other.author:\n raise ValueError(\"Cannot add books with different titles or authors\")\n # In the context of \"adding quantity\", if we treat the object as a single unit,\n # adding two identical books results in a representation of the same book.\n # However, usually, this implies a counter. To strictly follow the prompt \n # \"adding quantity\", we return a new instance representing the same book.\n return Book(self.title, self.author)\n\nclass EBook(Book):\n def __init__(self, title: str, author: str, file_size: float):\n super().__init__(title, author)\n self.file_size = file_size\n\n def __repr__(self) -> str:\n return f\"EBook(title='{self.title}', author='{self.author}', file_size={self.file_size}MB)\"\n\nif __name__ == \"__main__\":\n book1 = Book(\"1984\", \"George Orwell\")\n book2 = Book(\"1984\", \"George Orwell\")\n ebook1 = EBook(\"Digital Fortress\", \"Dan Brown\", 2.5)\n\n print(book1)\n print(book2)\n print(f\"Sum: {book1 + book2}\")\n print(ebook1)\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Дан список целых чисел, из которого необходимо отфильтровать только положительные значения, превышающие заданный порог. Полученный подсписок следует отсортировать по убыванию и вернуть первый элемент, найденный с помощью алгоритма бинарного поиска в исходном массиве."}, {"role": "assistant", "content": "```python\ndef solve(numbers: list[int], threshold: int) -> int | None:\n # 1. Фильтруем положительные значения > threshold\n filtered = [x for x in numbers if x > 0 and x > threshold]\n \n if not filtered:\n return None\n\n # 2. Сортируем по убыванию\n filtered.sort(reverse=True)\n \n # 3. Берем первый элемент отфильтрованного списка\n target = filtered[0]\n \n # 4. Реализуем бинарный поиск этого элемента в ИСХОДНОМ массиве\n # Для корректной работы бинарного поиска массив должен быть отсортирован.\n # В условии сказано \"в исходном массиве\", но бинарный поиск требует сортировки.\n # Предполагается, что мы ищем в отсортированной копии исходного массива.\n sorted_original = sorted(numbers)\n \n low = 0\n high = len(sorted_original) - 1\n \n while low <= high:\n mid = (low + high) // 2\n if sorted_original[mid] == target:\n return sorted_original[mid]\n elif sorted_original[mid] < target:\n low = mid + 1\n else:\n high = mid - 1\n \n return None\n\n# Example usage:\nif __name__ == \"__main__\":\n data = [10, -5, 3, 45, 2, 18, 0, 7]\n limit = 5\n # Filtered: [10, 45, 18, 7]\n # Sorted desc: [45, 18, 10, 7]\n # Target: 45\n # Binary search for 45 in sorted(data) -> 45\n result = solve(data, limit)\n print(result)\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите функцию, которая находит наибольший общий делитель (НОД) между факториалом заданного числа $n$ и произведением всех простых чисел, не превосходящих $n$. Программа должна корректно обрабатывать входные данные и возвращать результат вычислений для заданного значения."}, {"role": "assistant", "content": "```python\nimport math\n\ndef solve(n):\n if n < 2:\n return 1\n \n # Находим все простые числа <= n\n primes = []\n is_prime = [True] * (n + 1)\n for p in range(2, n + 1):\n if is_prime[p]:\n primes.append(p)\n for i in range(p * p, n + 1, p):\n is_prime[i] = False\n \n # Произведение всех простых чисел <= n\n product_of_primes = 1\n for p in primes:\n product_of_primes *= p\n \n # Находим факториал n\n factorial_n = math.factorial(n)\n \n # НОД(n!, product_of_primes)\n # Так как все простые числа в произведении <= n, \n # они все являются множителями n!\n # Следовательно, НОД будет равен самому произведению простых чисел.\n return math.gcd(factorial_n, product_of_primes)\n\nif __name__ == \"__main__\":\n import sys\n try:\n line = sys.stdin.read().strip()\n if line:\n n_val = int(line)\n print(solve(n_val))\n except EOFError:\n pass\n except ValueError:\n pass\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите рекурсивную функцию для вычисления n-го числа Фибоначчи, которая при стандартном подходе вызывает переполнение стека или работает бесконечно долго при больших значениях. Реализуйте оптимизацию с использованием мемоизации, чтобы алгоритм возвращал результат мгновенно, не пересчитывая уже изученные ветви дерева вызовов."}, {"role": "assistant", "content": "```python\ndef fibonacci_optimized(n, memo=None):\n if memo is None:\n memo = {0: 0, 1: 1}\n \n if n in memo:\n return memo[n]\n \n memo[n] = fibonacci_optimized(n - 1, memo) + fibonacci_optimized(n - 2, memo)\n return memo[n]\n\nif __name__ == \"__main__\":\n import sys\n \n # Увеличиваем лимит рекурсии для глубоких вызовов\n sys.setrecursionlimit(2000)\n \n # Тестирование\n n_value = 100\n result = fibonacci_optimized(n_value)\n print(f\"Fibonacci({n_value}) = {result}\")\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите программу, которая запускает три корутины с разными задержками через `asyncio.sleep`, но при этом должна завершить выполнение всех задач одновременно ровно через время самой короткой из них. Логическая сложность заключается в том, чтобы не допустить ожидания завершения более длительных задач, не используя при этом принудительную отмену всех корутин через `gather` или `wait`."}, {"role": "assistant", "content": "```python\nimport asyncio\n\nasync def worker(name, delay):\n try:\n print(f\"Task {name} started with delay {delay}s\")\n await asyncio.sleep(delay)\n print(f\"Task {name} finished\")\n except asyncio.CancelledError:\n print(f\"Task {name} was cancelled\")\n raise\n\nasync def main():\n delays = [3, 1, 5]\n tasks = []\n \n # Create tasks\n for i, d in enumerate(delays):\n tasks.append(asyncio.create_task(worker(i, d)))\n\n # Find the shortest delay\n shortest_delay = min(delays)\n \n # Wait for the shortest time using a timer task\n # This acts as a \"deadline\" mechanism\n await asyncio.sleep(shortest_delay)\n \n print(f\"--- Shortest time ({shortest_delay}s) reached. Stopping all tasks. ---\")\n \n # To satisfy the constraint of not using gather/wait for cancellation,\n # we manually cancel the tasks that are still running.\n for task in tasks:\n if not task.done():\n task.cancel()\n\n # Final cleanup to ensure tasks are handled\n await asyncio.gather(*tasks, return_exceptions=True)\n\nif __name__ == \"__main__\":\n asyncio.run(main())\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Дан список слов, из которого необходимо извлечь все уникальные слова, длина которых больше пяти символов, и определить частоту их встречаемости. Результатом должен стать словарь, где ключами являются эти слова, а значениями — количество их повторений в исходном списке."}, {"role": "assistant", "content": "```python\nfrom collections import Counter\n\ndef get_word_frequencies(words: list[str]) -> dict[str, int]:\n \"\"\"\n Extracts unique words longer than 5 characters and their frequencies.\n \"\"\"\n return {word: count for word, count in Counter(words).items() if len(word) > 5}\n\nif __name__ == \"__main__\":\n # Example usage:\n input_list = [\n \"python\", \"programming\", \"code\", \"developer\", \"python\", \n \"software\", \"engineer\", \"code\", \"programming\", \"algorithm\"\n ]\n \n result = get_word_frequencies(input_list)\n print(result)\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите асинхронную программу, которая одновременно запускает три корутины, имитирующие выполнение различных задач с помощью функции `asyncio.sleep`. Каждая задача должна выводить сообщение о начале и завершении своей работы через заданный интервал времени."}, {"role": "assistant", "content": "```python\nimport asyncio\n\nasync def task(name: str, delay: float):\n print(f\"Задача '{name}' началась (задержка: {delay} сек.)\")\n await asyncio.sleep(delay)\n print(f\"Задача '{name}' завершена\")\n\nasync def main():\n tasks = [\n task(\"A\", 1.5),\n task(\"B\", 0.5),\n task(\"C\", 1.0)\n ]\n await asyncio.gather(*tasks)\n\nif __name__ == \"__main__\":\n asyncio.run(main())\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Реализуйте класс `Vector`, который при сложении через `__add__` возвращает новый объект того же класса, но при использовании `__repr__` возвращает строку, не содержащую текущий объект. Учтите, что при наследовании дочерний класс должен корректно обрабатывать операции, не теряя при этом специфические атрибуты родительского метода."}, {"role": "assistant", "content": "```python\nclass Vector:\n def __init__(self, *args):\n self.components = args\n\n def __add__(self, other):\n if not isinstance(other, type(self)):\n return NotImplemented\n \n new_components = tuple(\n a + b for a, b in zip(self.components, other.components)\n )\n # Using __new__ to ensure we create an instance of the actual class (including subclasses)\n # while preserving the ability to initialize with new data.\n new_obj = self.__class__.__new__(self.__class__)\n new_obj.__init__(*new_components)\n return new_obj\n\n def __repr__(self):\n return f\"{self.__class__.__name__}({', '.join(map(str, self.components))})\"\n\nclass ColoredVector(Vector):\n def __init__(self, *args, color=\"red\"):\n super().__init__(*args)\n self.color = color\n\n def __add__(self, other):\n # Call parent add to get the new object of the same class\n result = super().__add__(other)\n # Preserve specific attributes\n if isinstance(other, ColoredVector):\n result.color = other.color\n return result\n\n def __repr__(self):\n # Custom repr for subclass that includes its specific attribute\n return f\"{super().__repr__()}(color='{self.color}')\"\n\n# Test logic\nif __name__ == \"__main__\":\n v1 = Vector(1, 2, 3)\n v2 = Vector(4, 5, 6)\n v3 = v1 + v2\n assert isinstance(v3, Vector)\n assert v3.components == (5, 7, 9)\n assert repr(v3) == \"Vector(5, 7, 9)\"\n\n cv1 = ColoredVector(1, 2, color=\"blue\")\n cv2 = ColoredVector(3, 4, color=\"green\")\n cv3 = cv1 + cv2\n assert isinstance(cv3, ColoredVector)\n assert cv3.components == (4, 6)\n assert cv3.color == \"green\"\n assert repr(cv3) == \"ColoredVector(4, 6)(color='green')\"\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Дан список строк, где каждая строка представляет собой последовательность символов в транзакции. Необходимо найти все уникальные символы, которые встречаются в транзакциях чаще одного раза, и вывести их количество, сгруппированное по алфавиту."}, {"role": "assistant", "content": "```python\nfrom collections import Counter\n\ndef find_duplicate_characters(transactions: list[str]) -> dict[str, int]:\n \"\"\"\n Finds unique characters that appear more than once across all transactions\n and returns their counts grouped alphabetically.\n \"\"\"\n # Flatten all characters from all strings into a single stream and count them\n char_counts = Counter(\"\".join(transactions))\n \n # Filter characters that appear more than once\n duplicates = {char: count for char, count in char_counts.items() if count > 1}\n \n # Return sorted dictionary by keys (alphabetical order)\n return dict(sorted(duplicates.items()))\n\nif __name__ == \"__main__\":\n # Example usage:\n test_transactions = [\"abc\", \"def\", \"a\", \"b\", \"c\", \"ghi\", \"a\"]\n # 'a' appears 3 times, 'b' appears 2 times, 'c' appears 2 times.\n # Others appear once.\n \n result = find_duplicate_characters(test_transactions)\n print(result)\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите программу, которая находит наибольший общий делитель (НОД) между факториалом заданного числа $n$ и произведением всех простых чисел, не превосходящих это число. Для инициализации генератора случайных чисел используйте `seed(548165)`, чтобы определить входное значение $n$."}, {"role": "assistant", "content": "```python\nimport math\nimport random\n\ndef solve():\n random.seed(548165)\n n = random.randint(1, 100) # n задается случайно в разумных пределах\n\n def get_primes(limit):\n primes = []\n is_prime = [True] * (limit + 1)\n for p in range(2, limit + 1):\n if is_prime[p]:\n primes.append(p)\n for i in range(p * p, limit + 1, p):\n is_prime[i] = False\n return primes\n\n # n!\n factorial_n = math.factorial(n)\n\n # Произведение всех простых чисел, не превосходящих n\n primes = get_primes(n)\n product_of_primes = 1\n for p in primes:\n product_of_primes *= p\n\n # НОД(n!, произведение простых <= n)\n # Заметим, что все простые числа <= n являются множителями n!\n # Следовательно, НОД будет равен самому произведению простых чисел,\n # так как каждое простое число p <= n входит в разложение n!\n \n gcd_result = math.gcd(factorial_n, product_of_primes)\n \n print(f\"n: {n}\")\n print(f\"GCD: {gcd_result}\")\n\nif __name__ == \"__main__\":\n solve()\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Создайте функцию, которая с помощью `yield` генерирует бесконечную последовательность чисел, кратных заданному шагу, и возвращает первые $N$ элементов через выражение-генератор. Используя модуль `itertools`, реализуйте фильтрацию этой последовательности, чтобы оставить только числа, удовлетворяющие определенному условию, и сформируйте из них итоговый список."}, {"role": "assistant", "content": "```python\nimport itertools\n\ndef infinite_step_sequence(step):\n \"\"\"Генератор бесконечной последовательности чисел, кратных step.\"\"\"\n current = step\n while True:\n yield current\n current += step\n\ndef solve(step, n, condition_func):\n \"\"\"\n step: шаг последовательности\n n: сколько элементов взять из бесконечного генератора\n condition_func: функция-фильтр\n \"\"\"\n # 1. Создаем бесконечную последовательность\n gen = infinite_step_sequence(step)\n \n # 2. Берем первые N элементов через выражение-генератор\n first_n_gen = (x for x in itertools.islice(gen, n))\n \n # 3. Фильтруем с помощью itertools.filterfalse или встроенного filter\n # Используем itertools.filterfalse для демонстрации модуля, \n # но здесь нам нужно оставить те, что True, поэтому используем filter\n filtered_gen = filter(condition_func, first_n_gen)\n \n # 4. Формируем итоговый список\n return list(filtered_gen)\n\nif __name__ == \"__main__\":\n # Пример: шаг 3, берем первые 20 чисел, оставляем только те, что делятся на 2\n STEP = 3\n N = 20\n CONDITION = lambda x: x % 2 == 0\n \n result = solve(STEP, N, CONDITION)\n print(result)\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите программу, которая с помощью `pathlib` находит все файлы `.json` в директории, объединяет их содержимое в один CSV-файл, но при этом должна корректно обработать ситуацию, когда в исходных JSON-объектах отсутствуют ключи, соответствующие заголовкам CSV. Учтите, что при попытке перезаписи существующего файла с тем же именем, программа не должна создавать дубликаты данных или приводить к ошибке доступа."}, {"role": "assistant", "content": "```python\nimport json\nimport csv\nfrom pathlib import Path\n\ndef merge_json_to_csv(directory_path: str, output_filename: str):\n base_dir = Path(directory_path)\n output_file = base_dir / output_filename\n \n json_files = list(base_dir.glob(\"*.json\"))\n \n if not json_files:\n return\n\n all_data = []\n all_keys = set()\n\n # Phase 1: Read all JSON files and collect all possible keys (headers)\n for json_file in json_files:\n # Skip the output file if it somehow ends in .json (unlikely but safe)\n if json_file.name == output_filename:\n continue\n \n try:\n with json_file.open('r', encoding='utf-8') as f:\n data = json.load(f)\n \n # Handle both single object and list of objects\n if isinstance(data, dict):\n data = [data]\n \n if isinstance(data, list):\n for item in data:\n if isinstance(item, dict):\n all_data.append(item)\n all_keys.update(item.keys())\n except (json.JSONDecodeError, IOError):\n continue\n\n if not all_data:\n return\n\n # Sort keys for consistent column ordering\n headers = sorted(list(all_keys))\n\n # Phase 2: Write to CSV\n # Using 'w' mode automatically overwrites the file, preventing duplicates from previous runs\n try:\n with output_file.open('w', newline='', encoding='utf-8') as csvfile:\n writer = csv.DictWriter(csvfile, fieldnames=headers)\n writer.writeheader()\n # DictWriter handles missing keys by writing empty strings if restval is default\n writer.writerows(all_data)\n except IOError as e:\n print(f\"Error writing CSV: {e}\")\n\nif __name__ == \"__main__\":\n # Example usage:\n # Create a dummy directory and files for demonstration\n test_dir = Path(\"test_data\")\n test_dir.mkdir(exist_ok=True)\n \n (test_dir / \"file1.json\").write_text(json.dumps([{\"id\": 1, \"name\": \"Alice\", \"role\": \"admin\"}]))\n (test_dir / \"file2.json\").write_text(json.dumps([{\"id\": 2, \"name\": \"Bob\"}, {\"id\": 3, \"role\": \"user\"}]))\n \n merge_json_to_csv(\"test_data\", \"combined_data.csv\")\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите асинхронную программу, которая одновременно запускает три корутины, имитирующие выполнение различных задач с помощью `asyncio.sleep`. Каждая задача должна выводить сообщение о начале и завершении своей работы через заданные интервалы времени."}, {"role": "assistant", "content": "```python\nimport asyncio\n\nasync def task(name: str, delay: float):\n print(f\"Task {name}: starting (will take {delay}s)\")\n await asyncio.sleep(delay)\n print(f\"Task {name}: completed\")\n\nasync def main():\n # Запускаем три корутины одновременно\n await asyncio.gather(\n task(\"A\", 1.5),\n task(\"B\", 0.5),\n task(\"C\", 1.0)\n )\n\nif __name__ == \"__main__\":\n asyncio.run(main())\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Создайте класс `Rectangle` с атрибутами ширины и высоты, реализовав методы `__repr__` для красивого вывода объекта и `__add__` для сложения двух прямоугольников путем суммирования их площадей. Затем создайте подкласс `Square`, который наследует свойства прямоугольника и инициализируется только одним параметром стороны."}, {"role": "assistant", "content": "```python\nclass Rectangle:\n def __init__(self, width, height):\n self.width = width\n self.height = height\n\n def area(self):\n return self.width * self.height\n\n def __repr__(self):\n return f\"Rectangle(width={self.width}, height={self.height})\"\n\n def __add__(self, other):\n if not isinstance(other, Rectangle):\n return NotImplemented\n return self.area() + other.area()\n\n\nclass Square(Rectangle):\n def __init__(self, side):\n super().__init__(side, side)\n\n def __repr__(self):\n return f\"Square(side={self.width})\"\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Создайте класс `Vector`, который при сложении двух объектов через `__add__` возвращает не новый экземпляр класса, а сумму их координат в виде кортежа. Реализуйте метод `__repr__`, чтобы при попытке сложения объектов результат отображался как строка с описанием операции, а не как стандартное представление кортежа."}, {"role": "assistant", "content": "```python\nclass Vector:\n def __init__(self, x, y):\n self.x = x\n self.y = y\n\n def __add__(self, other):\n if isinstance(other, Vector):\n # Возвращаем специальный объект-обертку, чтобы __repr__ сработал при выводе\n return _VectorSumResult(self, other)\n return NotImplemented\n\n def __repr__(self):\n return f\"Vector({self.x}, {self.y})\"\n\nclass _VectorSumResult:\n def __init__(self, v1, v2):\n self.v1 = v1\n self.v2 = v2\n self.sum_tuple = (v1.x + v2.x, v1.y + v2.y)\n\n def __repr__(self):\n return f\"Sum of {self.v1} and {self.v2} is {self.sum_tuple}\"\n\n def __iter__(self):\n return iter(self.sum_tuple)\n\n# Пример использования:\nif __name__ == \"__main__\":\n v1 = Vector(1, 2)\n v2 = Vector(3, 4)\n result = v1 + v2\n print(result)\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите программу, которая извлекает из произвольного текста все последовательности цифр, используя регулярные выражения. Полученные числа необходимо отсортировать и вывести в консоль в виде отформатированной строки, где каждое значение дополнено ведущими нулями до пяти знаков."}, {"role": "assistant", "content": "```python\nimport re\n\ndef extract_and_format_numbers(text: str) -> str:\n # Извлекаем все последовательности цифр\n numbers = re.findall(r'\\d+', text)\n \n # Преобразуем в целые числа для корректной сортировки по значению\n numbers_int = sorted(map(int, numbers))\n \n # Форматируем каждое число: дополняем нулями до 5 знаков\n formatted_numbers = [f\"{num:05d}\" for num in numbers_int]\n \n # Объединяем в строку через пробел\n return \" \".join(formatted_numbers)\n\nif __name__ == \"__main__\":\n sample_text = \"Пример текста с числами: 42, 7, 1024, 0, 555, 12 и еще 99.\"\n result = extract_and_format_numbers(sample_text)\n print(result)\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите функцию, которая с помощью генератора списков находит все квадраты чисел от 1 до 100, кратных трем, и возвращает их в виде выражения-генератора. Затем используйте функцию `next()` и модуль `itertools`, чтобы вывести первые пять элементов этого генератора, начиная с любого произвольного индекса."}, {"role": "assistant", "content": "```python\nimport itertools\n\ndef get_squares_generator():\n \"\"\"\n Returns a generator expression of squares of numbers from 1 to 100 \n that are divisible by 3.\n \"\"\"\n return (x**2 for x in range(1, 101) if x % 3 == 0)\n\ndef main():\n # Get the generator\n gen = get_squares_generator()\n \n # Using itertools.islice to skip an arbitrary number of elements (e.g., skip 2)\n # and then take the next 5 elements.\n # Note: Since we need to use next() specifically as per instructions, \n # we can iterate through the sliced generator.\n \n # Let's skip 2 elements and get the next 5\n sliced_gen = itertools.islice(gen, 2, 7)\n \n # To strictly follow \"use next()\", we can manually pull from the sliced generator\n # or simply iterate. Here is the implementation using next() in a loop:\n try:\n for _ in range(5):\n print(next(sliced_gen))\n except StopIteration:\n pass\n\nif __name__ == \"__main__\":\n main()\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Представьте, что вы создаете систему обработки платежей, где кастомное исключение `PaymentError` должно перехватываться отдельно от стандартного `Exception`. Определите, почему при попытке обработать специфическую ошибку внутри блока `except Exception` программа может проигнорировать ваш пользовательский класс, если порядок блоков написан неверно."}, {"role": "assistant", "content": "```python\nclass PaymentError(Exception):\n \"\"\"Специфическое исключение для ошибок платежа.\"\"\"\n pass\n\ndef process_payment(amount):\n if amount <= 0:\n raise PaymentError(\"Сумма платежа должна быть положительной.\")\n if amount > 10000:\n raise Exception(\"Системная ошибка: превышен лимит транзакции.\")\n print(f\"Платеж на сумму {amount} успешно обработан.\")\n\ndef run_demo(amount):\n print(f\"--- Тест для суммы: {amount} ---\")\n try:\n # ОШИБКА: Если поставить except Exception первым, \n # он перехватит PaymentError, так как PaymentError является наследником Exception.\n # Правильный порядок: от частного к общему.\n \n # try:\n # process_payment(amount)\n # except Exception as e:\n # print(f\"Перехвачено общим обработчиком: {e}\")\n # except PaymentError as e:\n # print(f\"Перехвачено специфичным обработчиком: {e}\")\n\n # ПРАВИЛЬНЫЙ ПОПОРЯДОК:\n process_payment(amount)\n \n except PaymentError as e:\n print(f\"Специфическая ошибка платежа: {e}\")\n except Exception as e:\n print(f\"Общая системная ошибка: {e}\")\n print(\"Продолжение выполнения программы...\")\n\nif __name__ == \"__main__\":\n # Случай 1: Специфическая ошибка (должна попасть в PaymentError)\n run_demo(-5)\n \n print()\n \n # Случай 2: Стандартная ошибка (должна попасть в Exception)\n run_demo(15000)\n \n print(\"\\n--- Демонстрация ошибки порядка блоков ---\")\n try:\n # Имитация неправильного порядка\n raise PaymentError(\"Ошибка, которую 'съест' общий блок\")\n except Exception as e:\n print(f\"ОШИБКА: Специфическая ошибка была поглощена общим блоком: {e}\")\n except PaymentError as e:\n print(f\"Этот блок никогда не выполнится, если Exception выше: {e}\")\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Дан список слов, из которого необходимо составить словарь, содержащий уникальные слова и количество их повторений в исходном тексте. Для решения используйте специализированный класс из модуля `collections`, чтобы эффективно подсчитать частоту каждого элемента."}, {"role": "assistant", "content": "```python\nfrom collections import Counter\n\ndef get_word_frequencies(words_list):\n \"\"\"\n Creates a dictionary of unique words and their counts using collections.Counter.\n \"\"\"\n return dict(Counter(words_list))\n\nif __name__ == \"__main__\":\n # Example usage\n input_words = [\"apple\", \"banana\", \"apple\", \"orange\", \"banana\", \"apple\", \"grape\"]\n \n result = get_word_frequencies(input_words)\n print(result)\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите программу, которая извлекает из произвольного текста все последовательности цифр с помощью регулярных выражений и объединяет их в одну строку. Полученный результат необходимо отформатировать, добавив в начало и конец строки декоративные символы и указав общее количество найденных чисел."}, {"role": "assistant", "content": "```python\nimport re\n\ndef extract_and_format_numbers(text: str) -> str:\n \"\"\"\n Extracts all digit sequences from text, joins them, \n and formats the result with decorations and count.\n \"\"\"\n # Find all sequences of digits\n numbers = re.findall(r'\\d+', text)\n \n # Join all found sequences into one string\n joined_numbers = \"\".join(numbers)\n \n # Count of found sequences\n count = len(numbers)\n \n # Formatting the output\n # Example format: [*** 123456 (found: 3) ***]\n decoration_start = \"[*** \"\n decoration_end = \" ***]\"\n info_suffix = f\" (found: {count})\"\n \n return f\"{decoration_start}{joined_numbers}{info_suffix}{decoration_end}\"\n\nif __name__ == \"__main__\":\n # Test cases\n sample_text = \"In 2023, we found 42 items and 1000 more, totaling 1042.\"\n sample_text_2 = \"No numbers here!\"\n sample_text_3 = \"Numbers: 1, 2, 3, 4, 5\"\n\n print(extract_and_format_numbers(sample_text))\n print(extract_and_format_numbers(sample_text_2))\n print(extract_and_format_numbers(sample_text_3))\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите программу, которая находит наибольший общий делитель (НОД) двух чисел и проверяет, является ли это число простым. Также необходимо вычислить факториал этого числа и вывести результат на экран."}, {"role": "assistant", "content": "```python\nimport math\n\ndef is_prime(n):\n if n < 2:\n return False\n for i in range(2, int(math.sqrt(n)) + 1):\n if n % i == 0:\n return False\n return True\n\ndef solve(a, b):\n gcd_val = math.gcd(a, b)\n prime_status = is_prime(gcd_val)\n factorial_val = math.factorial(gcd_val)\n \n print(f\"GCD: {gcd_val}\")\n print(f\"Is prime: {prime_status}\")\n print(f\"Factorial: {factorial_val}\")\n\nif __name__ == \"__main__\":\n try:\n num1 = int(input(\"Enter first number: \"))\n num2 = int(input(\"Enter second number: \"))\n solve(num1, num2)\n except ValueError:\n print(\"Please enter valid integers.\")\n except Exception as e:\n print(f\"An error occurred: {e}\")\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Дан список идентификаторов товаров, где некоторые значения являются дубликатами или отсутствуют в справочнике цен. Найдите количество уникальных товаров, которые одновременно встречаются в списке более одного раза и имеют положительную цену в словаре, учитывая, что при поиске по ключу может возникнуть ошибка отсутствия элемента."}, {"role": "assistant", "content": "```python\ndef count_valid_duplicates(product_ids, price_dict):\n \"\"\"\n Находит количество уникальных товаров, которые:\n 1. Встречаются в списке product_ids более одного раза.\n 2. Имеют положительную цену в price_dict.\n \"\"\"\n from collections import Counter\n\n # Считаем количество вхождений каждого ID\n counts = Counter(product_ids)\n \n unique_valid_duplicates = 0\n \n for product_id, count in counts.items():\n # Проверяем условие: встречается более одного раза\n if count > 1:\n # Используем.get() для безопасного получения цены (возвращает None, если ключа нет)\n price = price_dict.get(product_id)\n \n # Проверяем, что цена существует и она положительна\n if price is not None and price > 0:\n unique_valid_duplicates += 1\n \n return unique_valid_duplicates\n\n# Пример использования:\nif __name__ == \"__main__\":\n # Список идентификаторов (с дубликатами и отсутствующими ключами)\n product_list = [101, 102, 101, 103, 102, 104, 101, 105, 105]\n \n # Справочник цен\n prices = {\n 101: 50.0, # Дубликат, цена > 0 (подходит)\n 102: -5.0, # Дубликат, цена < 0 (не подходит)\n 103: 100.0, # Не дубликат\n 104: 20.0, # Не дубликат\n 105: 15.0 # Дубликат, цена > 0 (подходит)\n # 106 отсутствует в словаре (если бы был дубликатом, не подошел бы)\n }\n\n result = count_valid_duplicates(product_list, prices)\n print(result) # Ожидаемый вывод: 2 (товары 101 и 105)\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Дан список чисел, из которого необходимо отфильтровать только положительные значения. Полученный результат следует отсортировать по возрастанию и вывести максимальный элемент в списке."}, {"role": "assistant", "content": "```python\ndef solve(numbers: list[float]) -> float:\n positive_numbers = sorted([x for x in numbers if x > 0])\n \n if not positive_numbers:\n return None\n \n return positive_numbers[-1]\n\nif __name__ == \"__main__\":\n data = [-5, 10, 0, 3, -1, 7, 2, -8]\n result = solve(data)\n print(result)\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Создайте класс для работы с векторами, где переопределенный метод `__add__` возвращает не новый объект того же класса, а объект другого типа, несмотря на использование наследования. Реализуйте строковое представление через `__repr__`, чтобы при попытке сложения двух векторов результат выглядел как корректный вектор, хотя фактически он является экземпляром стороннего класса."}, {"role": "assistant", "content": "```python\nclass Vector:\n def __init__(self, x: float, y: float):\n self.x = x\n self.y = y\n\n def __add__(self, other: 'Vector') -> 'ResultProxy':\n if isinstance(other, Vector):\n return ResultProxy(self.x + other.x, self.y + other.y)\n return NotImplemented\n\n def __repr__(self) -> str:\n return f\"Vector({self.x}, {self.y})\"\n\n\nclass ResultProxy:\n \"\"\"Сторонний класс, который не является наследником Vector.\"\"\"\n def __init__(self, x: float, y: float):\n self.x = x\n self.y = y\n\n def __repr__(self) -> str:\n return f\"Vector({self.x}, {self.y})\"\n\n\nif __name__ == \"__main__\":\n v1 = Vector(1.0, 2.0)\n v2 = Vector(3.0, 4.0)\n \n result = v1 + v2\n \n print(f\"Result value: {result}\")\n print(f\"Result type: {type(result)}\")\n \n # Проверка соответствия условию: выглядит как Vector, но тип другой\n assert isinstance(result, ResultProxy)\n assert not isinstance(result, Vector)\n assert repr(result) == \"Vector(4.0, 6.0)\"\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Дан список строк, где некоторые элементы могут дублироваться, а другие — содержать лишние пробелы или разный регистр. Найдите количество уникальных слов, используя `set`, но учтите, что при использовании `Counter` для подсчета частоты слов, результат может не совпасть с количеством элементов в множестве из-за особенностей обработки пустых строк."}, {"role": "assistant", "content": "```python\ndef count_unique_words(words_list):\n # Очистка: удаление лишних пробелов по краям, \n # приведение к нижнему регистру и фильтрация пустых строк\n cleaned_words = {word.strip().lower() for word in words_list if word.strip()}\n return len(cleaned_words)\n\n# Пример использования\nif __name__ == \"__main__\":\n input_data = [\" Python\", \"python \", \" PYTHON \", \"java\", \"Java\", \"\", \" \", \"C++\", \"python\"]\n result = count_unique_words(input_data)\n print(result)\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите асинхронную программу, которая одновременно запускает три корутины, имитирующие выполнение различных задач с помощью `asyncio.sleep`. Каждая задача должна выводить сообщение о начале работы и завершении через заданный интервал времени, не блокируя выполнение остальных функций."}, {"role": "assistant", "content": "```python\nimport asyncio\n\nasync def task(name, delay):\n print(f\"Задача {name}: начало работы (задержка {delay} сек.)\")\n await asyncio.sleep(delay)\n print(f\"Задача {name}: завершена\")\n\nasync def main():\n await asyncio.gather(\n task(\"A\", 2),\n task(\"B\", 1),\n task(\"C\", 1.5)\n )\n\nif __name__ == \"__main__\":\n asyncio.run(main())\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите рекурсивную функцию для вычисления $n$-го числа в последовательности, где каждое следующее значение является суммой трех предыдущих, при условии, что начальные три элемента равны 1. Оптимизируйте алгоритм с помощью мемоизации, чтобы обеспечить эффективное вычисление значений при больших входных данных."}, {"role": "assistant", "content": "```python\ndef get_tribonacci(n: int) -> int:\n memo = {1: 1, 2: 1, 3: 1}\n\n def recurse(k: int) -> int:\n if k in memo:\n return memo[k]\n \n memo[k] = recurse(k - 1) + recurse(k - 2) + recurse(k - 3)\n return memo[k]\n\n if n <= 0:\n return 0\n return recurse(n)\n\nif __name__ == \"__main__\":\n # Пример использования\n print(get_tribonacci(10))\n print(get_tribonacci(50))\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Создайте класс «Книга» с атрибутами названия и автора, реализовав метод `__repr__` для красивого отображения объекта и метод `__add__` для суммирования количества страниц двух книг. Добавьте класс «Электронная книга», который наследуется от основного и включает дополнительный атрибут размера файла."}, {"role": "assistant", "content": "```python\nclass Book:\n def __init__(self, title: str, author: str, pages: int):\n self.title = title\n self.author = author\n self.pages = pages\n\n def __repr__(self) -> str:\n return f\"Book(title='{self.title}', author='{self.author}', pages={self.pages})\"\n\n def __add__(self, other: 'Book') -> int:\n if isinstance(other, Book):\n return self.pages + other.pages\n raise TypeError(\"Can only add Book to Book\")\n\n\nclass EBook(Book):\n def __init__(self, title: str, author: str, pages: int, file_size: float):\n super().__init__(title, author, pages)\n self.file_size = file_size\n\n def __repr__(self) -> str:\n return f\"EBook(title='{self.title}', author='{self.author}', pages={self.pages}, file_size={self.file_size}MB)\"\n\n\nif __name__ == \"__main__\":\n book1 = Book(\"War and Peace\", \"Leo Tolstoy\", 1225)\n book2 = Book(\"The Hobbit\", \"J.R.R. Tolkien\", 310)\n ebook = EBook(\"Digital Fortress\", \"Dan Brown\", 400, 1.5)\n\n print(book1)\n print(book2)\n print(ebook)\n \n total_pages = book1 + book2\n print(f\"Total pages: {total_pages}\")\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Данная строка содержит скрытый идентификатор, который нужно извлечь с помощью регулярного выражения, учитывая, что спецсимволы в срезах могут изменить ожидаемую длину подстроки. Найдите и отформатируйте этот фрагмент так, чтобы он соответствовал шаблону, не попав в ловушку при обработке перекрывающихся совпадений."}, {"role": "assistant", "content": "```python\nimport re\n\ndef extract_and_format_identifier(input_string: str) -> str:\n \"\"\"\n Extracts a hidden identifier using a regex pattern that avoids \n overlapping match traps and handles potential special character issues.\n \n Pattern logic: \n Looks for a specific sequence starting with a prefix, \n containing alphanumeric characters, and ending with a suffix.\n \"\"\"\n # Pattern: Lookbehind for 'ID_', then capture alphanumeric chars, \n # followed by a delimiter like '-' or '_'.\n # Using a non-capturing group for the delimiter to ensure clean extraction.\n pattern = r'(?<=ID_)([A-Za-z0-9]+)(?=[-_])'\n \n # findall handles non-overlapping matches by default, \n # which prevents the \"overlapping match trap\".\n matches = re.findall(pattern, input_string)\n \n if not matches:\n return \"\"\n\n # Formatting: Join matches with a hyphen and convert to uppercase\n # as per standard identifier formatting requirements.\n formatted_id = \"-\".join(matches).upper()\n \n return formatted_id\n\nif __name__ == \"__main__\":\n # Test case with potential overlapping/tricky patterns\n # 'ID_abc-ID_def_ID_ghi' -> should extract abc, def, ghi\n # 'ID_123-ID_456' -> should extract 123, 456\n test_str = \"Data_stream_ID_alpha-ID_beta_ID_gamma-ID_delta\"\n \n result = extract_and_format_identifier(test_str)\n print(result) # Expected: ALPHA-BETA-GAMMA-DELTA\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите программу, которая одновременно запускает три асинхронные корутины, каждая из которых имитирует выполнение задачи с помощью различных интервалов задержки. В конце работы программа должна вывести общее время выполнения всех задач, используя механизмы `asyncio` для управления таймерами."}, {"role": "assistant", "content": "```python\nimport asyncio\nimport time\n\nasync def task(name: str, delay: float):\n print(f\"Task {name} started with delay {delay}s\")\n await asyncio.sleep(delay)\n print(f\"Task {name} finished\")\n\nasync def main():\n start_time = time.perf_counter()\n\n # Запуск трех асинхронных корутин одновременно\n await asyncio.gather(\n task(\"A\", 1.5),\n task(\"B\", 2.0),\n task(\"C\", 0.5)\n )\n\n end_time = time.perf_counter()\n total_duration = end_time - start_time\n print(f\"\\nTotal execution time: {total_duration:.2f} seconds\")\n\nif __name__ == \"__main__\":\n asyncio.run(main())\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите асинхронную функцию, которая имитирует выполнение задачи с задержкой в 3 секунды с помощью `asyncio.sleep`. Реализуйте запуск этой корутины с использованием таймера, который принудительно прервет выполнение функции, если она не завершится в течение 2 секунд."}, {"role": "assistant", "content": "```python\nimport asyncio\n\nasync def simulated_task():\n try:\n print(\"Task started...\")\n await asyncio.sleep(3)\n print(\"Task completed successfully!\")\n except asyncio.CancelledError:\n print(\"Task was cancelled due to timeout!\")\n raise\n\nasync def main():\n task = asyncio.create_task(simulated_task())\n \n try:\n # Wait for the task to complete, but timeout after 2 seconds\n await asyncio.wait_for(task, timeout=2.0)\n except asyncio.TimeoutError:\n print(\"Timeout reached! Terminating task...\")\n # The task is automatically cancelled by wait_for if it times out,\n # but we can explicitly ensure it's handled.\n task.cancel()\n try:\n await task\n except asyncio.CancelledError:\n pass\n except Exception as e:\n print(f\"An error occurred: {e}\")\n\nif __name__ == \"__main__\":\n asyncio.run(main())\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите программу, которая с помощью `pathlib` находит в заданной директории все CSV-файлы, считывает их содержимое и объединяет данные в единый список словарей. Полученный результат необходимо преобразовать в формат JSON и сохранить в новый файл, создав при этом целевую папку, если она отсутствует."}, {"role": "assistant", "content": "```python\nimport csv\nimport json\nfrom pathlib import Path\n\ndef merge_csv_to_json(source_dir: str, target_dir: str, output_filename: str):\n source_path = Path(source_dir)\n target_path = Path(target_dir)\n \n # Создаем целевую папку, если она отсутствует\n target_path.mkdir(parents=True, exist_ok=True)\n \n combined_data = []\n\n # Ищем все .csv файлы в директории\n csv_files = list(source_path.glob(\"*.csv\"))\n\n for file_path in csv_files:\n try:\n with file_path.open(mode='r', encoding='utf-8-sig') as f:\n reader = csv.DictReader(f)\n for row in reader:\n combined_data.append(row)\n except Exception as e:\n print(f\"Error reading {file_path}: {e}\")\n\n # Путь к выходному файлу\n output_file = target_path / output_filename\n\n # Сохраняем результат в JSON\n with output_file.open(mode='w', encoding='utf-8') as f:\n json.dump(combined_data, f, ensure_ascii=False, indent=4)\n\nif __name__ == \"__main__\":\n # Пример использования\n # Создадим тестовые данные для демонстрации\n test_dir = Path(\"test_source\")\n test_dir.mkdir(exist_ok=True)\n \n (test_dir / \"data1.csv\").write_text(\"id,name,city\\n1,Alice,New York\\n2,Bob,London\", encoding='utf-8')\n (test_dir / \"data2.csv\").write_text(\"id,name,city\\n3,Charlie,Paris\\n4,David,Tokyo\", encoding='utf-8')\n\n merge_csv_to_json(source_dir=\"test_source\", target_dir=\"output_json\", output_filename=\"merged_data.json\")\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите асинхронную программу, которая одновременно запускает три корутины, имитирующие выполнение различных задач с разной длительностью. Каждая задача должна завершаться по истечении заданного таймера, при этом программа должна корректно обрабатывать отмену корутины при превышении лимита времени."}, {"role": "assistant", "content": "```python\nimport asyncio\n\nasync def task_worker(name: str, duration: float):\n \"\"\"\n Имитация выполнения задачи.\n \"\"\"\n try:\n print(f\"[START] Задача '{name}' начала работу (длительность: {duration}с)\")\n await asyncio.sleep(duration)\n print(f\"[FINISH] Задача '{name}' успешно завершена\")\n return f\"Результат {name}\"\n except asyncio.CancelledError:\n print(f\"[CANCEL] Задача '{name}' была принудительно остановлена!\")\n raise\n\nasync def run_with_timeout(name: str, duration: float, timeout: float):\n \"\"\"\n Обертка для запуска задачи с ограничением по времени.\n \"\"\"\n try:\n # wait_for отменяет корутину, если время истекло\n result = await asyncio.wait_for(task_worker(name, duration), timeout=timeout)\n return result\n except asyncio.TimeoutError:\n print(f\"[TIMEOUT] Превышен лимит времени для задачи '{name}'\")\n return None\n\nasync def main():\n # Список задач: (имя, длительность_работы, лимит_времени)\n tasks_config = [\n (\"A\", 2.0, 5.0), # Успеет\n (\"B\", 5.0, 2.0), # Не успеет (Timeout)\n (\"C\", 1.0, 3.0), # Успеет\n ]\n\n # Создаем список задач\n coroutines = [\n run_with_timeout(name, dur, limit) \n for name, dur, limit in tasks_config\n ]\n\n print(\"--- Запуск асинхронных задач ---\")\n \n # Запускаем все задачи одновременно\n results = await asyncio.gather(*coroutines)\n\n print(\"--- Итоги выполнения ---\")\n for i, res in enumerate(results):\n status = \"Успех\" if res else \"Ошибка/Таймаут\"\n print(f\"Задача {tasks_config[i][0]}: {status} (Значение: {res})\")\n\nif __name__ == \"__main__\":\n asyncio.run(main())\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите рекурсивную функцию для вычисления n-го числа Фибоначчи, используя словарь для хранения уже вычисленных значений. Оптимизируйте алгоритм с помощью мемоизации, чтобы избежать избыточных вычислений при больших значениях n."}, {"role": "assistant", "content": "```python\ndef fibonacci(n, memo=None):\n if memo is None:\n memo = {0: 0, 1: 1}\n \n if n in memo:\n return memo[n]\n \n memo[n] = fibonacci(n - 1, memo) + fibonacci(n - 2, memo)\n return memo[n]\n\nif __name__ == \"__main__\":\n n = 100\n print(f\"n-th Fibonacci number ({n}): {fibonacci(n)}\")\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите функцию, которая возвращает итератор, генерирующий сумму квадратов чисел, используя `yield` внутри генераторного выражения, но при этом должна учитывать, что повторное использование одного и того же объекта-генератора приведет к пустому результату. Ваша реализация должна демонстрировать разницу в потреблении памяти между списковым включением и выражением-генератором при обработке бесконечного потока данных из `itertools.count`."}, {"role": "assistant", "content": "```python\nimport itertools\nimport sys\n\ndef square_sum_generator(limit):\n \"\"\"\n Возвращает итератор, генерирующий сумму квадратов чисел.\n Использует yield внутри генераторного выражения (через вспомогательную функцию),\n чтобы продемонстрировать специфику работы генераторов.\n \"\"\"\n def generator_logic(n):\n # Использование yield внутри функции, которая вызывается в генераторном выражении\n # согласно условию задачи о структуре.\n for i in range(n):\n yield i**2\n\n # Генераторное выражение, использующее yield через логику итератора\n return (sum_val for sum_val in (sum(generator_logic(i)) for i in range(1, limit + 1)))\n\ndef demonstrate_memory_and_behavior():\n limit = 10000\n \n # 1. Демонстрация потребления памяти\n # Списковое включение (List Comprehension) - создает весь список в памяти\n list_comp = [i**2 for i in itertools.islice(itertools.count(), limit)]\n list_mem = sys.getsizeof(list_comp)\n \n # Генерат��рное выражение (Generator Expression) - создает объект-итератор\n gen_exp = (i**2 for i in itertools.islice(itertools.count(), limit))\n gen_mem = sys.getsizeof(gen_exp)\n \n print(f\"Memory usage (List Comprehension): {list_mem} bytes\")\n print(f\"Memory usage (Generator Expression): {gen_mem} bytes\")\n print(f\"Difference: {list_mem - gen_mem} bytes\\n\")\n\n # 2. Демонстрация поведения итератора (одноразовость)\n print(\"Testing generator reusability:\")\n gen_func = square_sum_generator(5)\n \n print(\"First pass:\")\n for val in gen_func:\n print(val, end=\" \")\n print()\n\n print(\"Second pass (should be empty):\")\n for val in gen_func:\n print(val, end=\" \")\n print(\"(Empty)\")\n\nif __name__ == \"__main__\":\n demonstrate_memory_and_behavior()\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Найдите индекс первого вхождения минимального элемента в списке, предварительно отфильтровав все отрицательные значения. Учтите, что если после фильтрации список окажется пустым или все элементы будут равны между собой, функция должна возвращать значение `-1`."}, {"role": "assistant", "content": "```python\ndef find_min_index(nums):\n filtered = [x for x in nums if x >= 0]\n \n if not filtered:\n return -1\n \n min_val = min(filtered)\n \n # Проверка: если все элементы равны между собой\n if all(x == filtered[0] for x in filtered):\n return -1\n \n # Находим индекс первого вхождения минимального элемента в исходном списке\n # Но по условию задачи логика \"индекс вхождения\" обычно подразумевает \n # индекс в отфильтрованном списке или в исходном. \n # Исходя из контекста \"найти индекс... предварительно отфильтровав\", \n # стандартная интерпретация — индекс в отфильтрованном списке.\n \n try:\n return filtered.index(min_val)\n except ValueError:\n return -1\n\n# Пример использования:\n# print(find_min_index([5, -1, 2, 0, 2, -3])) # Ожидаемый результат: 3 (индекс 0 в [5, 2, 0, 2])\n# print(find_min_index([-1, -2, -3])) # Ожидаемый результат: -1\n# print(find_min_index([2, 2, 2])) # Ожидаемый результат: -1\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите программу, которая извлекает из строки с текстом все упоминания email-адресов и дат в формате DD.MM.YYYY с помощью регулярных выражений. Результат работы должен быть выведен в консоль в виде отформатированного списка, где каждый найденный элемент отделен от другого символом «|»."}, {"role": "assistant", "content": "```python\nimport re\n\ndef extract_data(text):\n # Регулярное выражение для email\n email_pattern = r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}'\n # Регулярное выражение для даты DD.MM.YYYY\n date_pattern = r'\\d{2}\\.\\d{2}\\.\\d{4}'\n \n # Поиск всех совпадений\n emails = re.findall(email_pattern, text)\n dates = re.findall(date_pattern, text)\n \n # Объединение результатов\n results = emails + dates\n \n # Вывод через разделитель |\n print(\"|\".join(results))\n\nif __name__ == \"__main__\":\n sample_text = \"Contact us at support@example.com or admin.office@company.org. The deadline is 12.05.2023 and the event is on 01.01.2024.\"\n extract_data(sample_text)\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Используя модуль `itertools` и генераторные выражения, создайте итератор, который находит все простые числа в заданном диапазоне, исключая те, что делятся на сумму своих цифр. Реализуйте функцию с ключевым словом `yield`, которая возвращает эти числа по одному, имитируя бесконечный поток данных для последующей обработки в генераторе списков."}, {"role": "assistant", "content": "```python\nimport itertools\n\ndef prime_stream(start, end):\n \"\"\"\n Генератор, который находит простые числа в диапазоне [start, end],\n исключая те, что делятся на сумму своих цифр.\n \"\"\"\n def is_prime(n):\n if n < 2:\n return False\n for i in range(2, int(n**0.5) + 1):\n if n % i == 0:\n return False\n return True\n\n def sum_digits(n):\n return sum(int(digit) for digit in str(n))\n\n # Создаем итератор по диапазону\n numbers = itertools.count(start)\n \n # Ограничиваем итератор верхней границей\n range_iter = itertools.takewhile(lambda x: x <= end, numbers)\n \n # Используем генераторное выражение для фильтрации\n # 1. Число простое\n # 2. Число НЕ делится на сумму своих цифр\n filtered_gen = (\n n for n in range_iter \n if is_prime(n) and n % sum_digits(n) != 0\n )\n\n for num in filtered_gen:\n yield num\n\nif __name__ == \"__main__\":\n # Параметры диапазона\n START = 1\n END = 100\n\n # Использование генератора в генераторе списков (list comprehension)\n # имитируя потребление потока данных\n result = [num for num in prime_stream(START, END)]\n\n print(result)\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите программу, которая одновременно запускает три корутины, имитирующие выполнение различных задач с помощью `asyncio.sleep`. Каждая задача должна выводить сообщение о начале и завершении своей работы через заданный интервал времени."}, {"role": "assistant", "content": "```python\nimport asyncio\n\nasync def task(name: str, delay: float):\n print(f\"Задача '{name}' началась (задержка: {delay}с)\")\n await asyncio.sleep(delay)\n print(f\"Задача '{name}' завершена\")\n\nasync def main():\n # Создаем список корутин с разными параметрами\n tasks = [\n task(\"A\", 1.5),\n task(\"B\", 0.5),\n task(\"C\", 2.0)\n ]\n \n # Запускаем их одновременно и ждем завершения всех\n await asyncio.gather(*tasks)\n\nif __name__ == \"__main__\":\n asyncio.run(main())\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите функцию, которая возвращает итератор, генерирующий сумму квадратов всех четных чисел в диапазоне, используя генераторное выражение, но при этом должна корректно обрабатывать ситуацию, когда исходный список содержит вложенные списки разной длины. Ваша реализация должна гарантировать, что при повторном использовании полученного итератора данные не будут дублироваться, несмотря на использование `itertools.cycle`."}, {"role": "assistant", "content": "```python\nimport itertools\n\ndef get_even_squares_iterator(nested_list):\n \"\"\"\n Returns an iterator that yields the sum of squares of all even numbers \n found within a nested list structure.\n \n To prevent issues with itertools.cycle and data duplication upon \n re-iteration, we flatten the structure into a single generator \n expression that yields values only once.\n \"\"\"\n \n # Flatten the nested list structure using a generator expression\n # This handles lists of varying lengths and depths (up to 2 levels as per typical 'nested list' context)\n # We use a generator to ensure we don't load everything into memory at once\n flat_gen = (\n item \n for sublist in nested_list \n for item in sublist \n if isinstance(item, (int, float))\n )\n \n # Filter even numbers and square them\n # Note: In Python, x % 2 == 0 works for integers. \n # We assume 'even' refers to integer values.\n squares_gen = (\n item**2 \n for item in flat_gen \n if isinstance(item, int) and item % 2 == 0\n )\n \n # The requirement asks for an iterator that generates the 'sum'.\n # Since an iterator yielding a single sum is trivial, and the prompt \n # mentions itertools.cycle (which implies a stream of values), \n # the most robust interpretation is an iterator that yields the \n # running sum or the individual squares.\n # However, to strictly follow \"sum of squares of all even numbers\", \n # we return an iterator that yields the final sum once.\n \n def sum_generator():\n total = sum(squares_gen)\n yield total\n\n return sum_generator()\n\n# Example usage and verification:\nif __name__ == \"__main__\":\n data = [[1, 2, 3], [4, 5], [6, 7, 8, 9, 10], []]\n \n # Create the iterator\n it = get_even_squares_iterator(data)\n \n # First use\n print(f\"First iteration: {next(it)}\") # Should be 2^2 + 4^2 + 6^2 + 8^2 + 10^2 = 4 + 16 + 36 + 64 + 100 = 220\n \n # Second use (demonstrating it's a one-time iterator as per standard Python iterator behavior)\n try:\n print(f\"Second iteration: {next(it)}\")\n except StopIteration:\n print(\"Iterator exhausted as expected.\")\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите функцию, которая выбрасывает кастомное исключение при определенных условиях, но при этом должна успешно завершить выполнение блока `finally` и вернуть значение, несмотря на перехват ошибки в `except`. В чем заключается логическая ловушка при попытке вернуть результат из блока `try` и одновременно выполнить `raise` внутри блока `except`?"}, {"role": "assistant", "content": "```python\nclass CustomError(Exception):\n \"\"\"Кастомное исключение для демонстрации.\"\"\"\n pass\n\ndef logic_trap_function(condition: bool):\n \"\"\"\n Функция демонстрирует поведение return в связке try-except-finally.\n \n Логическая ловушка:\n Если в блоке 'except' вызывается 'raise', выполнение прерывается, \n и управление передается в 'finally'. Если в 'finally' стоит ''return', \n он перекрывает (suppress) исключение, выброшенное в 'except', \n и функция возвращает значение, а не ошибку.\n Если же в 'try' стоит ''return', а в 'finally' — 'raise', \n то исключение из 'finally' перекроет результат из 'try'.\n \"\"\"\n try:\n if condition:\n print(\"Условие выполнено: выбрасываем исключение...\")\n raise CustomError(\"Произошла ошибка!\")\n return \"Успешное завершение\"\n except CustomError as e:\n print(f\"Перехват ошибки: {e}\")\n # Если мы просто сделаем raise здесь, функция выбросит ошибку.\n # Но если в finally будет return, ошибка \"исчезнет\".\n raise e \n finally:\n print(\"Выполнение блока finally...\")\n # Чтобы продемонстрировать, что мы можем вернуть значение \n # даже после raise в except, мы можем добавить return здесь.\n # Однако, в данном примере мы просто выведем сообщение.\n # Если раскомментировать строку ниже, ошибка из except будет проигнорирована:\n # return \"Значение из finally (перекрывает ошибку)\"\n\ndef demonstrate_suppression():\n \"\"\"\n Демонстрация того, как return в finally подавляет raise в except.\n \"\"\"\n print(\"--- Тест 1: Ошибка не подавлена ---\")\n try:\n logic_trap_function(True)\n except CustomError:\n print(\"Результат: Ошибка успешно проброшена выше.\")\n\n print(\"\\n--- Тест 2: Ошибка подавлена через return в finally ---\")\n def suppressed_function():\n try:\n raise CustomError(\"Скрытая ошибка\")\n except CustomError:\n print(\"Перехватили, но в finally будет return\")\n raise CustomError(\"Я пытаюсь вылететь\")\n finally:\n return \"Я победил, ошибки нет!\"\n\n result = suppressed_function()\n print(f\"Результат: {result}\")\n\nif __name__ == \"__main__\":\n demonstrate_suppression()\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите функцию, которая извлекает из строки все последовательности цифр, разделенные дефисом, и преобразует их в список целых чисел. Результат должен быть представлен в виде отформатированной строки, где каждое число дополнено ведущими нулями до заданной длины."}, {"role": "assistant", "content": "```python\nimport re\n\ndef extract_and_format_numbers(input_string: str, padding_length: int) -> str:\n \"\"\"\n Extracts sequences of digits separated by hyphens and returns a formatted string\n where each number is padded with leading zeros.\n \"\"\"\n # Find all sequences of digits\n numbers = re.findall(r'\\d+', input_string)\n \n # Convert to integers and then to padded strings\n formatted_numbers = [num.zfill(padding_length) for num in numbers]\n \n # Return as a single string (e.g., space-separated or comma-separated)\n # Based on the prompt \"result represented as a formatted string\", \n # I will return them joined by a space.\n return \" \".join(formatted_numbers)\n\n# Example usage:\nif __name__ == \"__main__\":\n test_str = \"abc-12-def-007-ghi-5\"\n length = 3\n # Expected: \"012 007 005\"\n print(extract_and_format_numbers(test_str, length))\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите функцию, которая принимает список целых чисел и возвращает новый отфильтрованный список, содержащий только уникальные элементы, отсортированные по убыванию. При этом необходимо исключить из итогового результата все числа, которые встречаются в исходном списке более одного раза."}, {"role": "assistant", "content": "```python\ndef get_unique_sorted_descending(numbers: list[int]) -> list[int]:\n \"\"\"\n Returns a list of elements that appear exactly once in the input list,\n sorted in descending order.\n \"\"\"\n from collections import Counter\n \n counts = Counter(numbers)\n return sorted([num for num, count in counts.items() if count == 1], reverse=True)\n\nif __name__ == \"__main__\":\n # Test cases\n assert get_unique_sorted_descending([1, 2, 2, 3, 4, 4, 5]) == [5, 3, 1]\n assert get_unique_sorted_descending([10, 20, 10, 30, 40, 20]) == [40, 30]\n assert get_unique_sorted_descending([1, 1, 1, 1]) == []\n assert get_unique_sorted_descending([]) == []\n assert get_unique_sorted_descending([5, 4, 3, 2, 1]) == [5, 4, 3, 2, 1]\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Создайте систему управления библиотекой, где базовый класс «Книга» реализует строковое представление объекта и логику сложения двух книг для получения общего количества страниц. Напишите производный класс «Электронная книга», который наследует свойства базового класса и переопределяет методы для учета специфических параметров цифрового формата."}, {"role": "assistant", "content": "```python\nclass Book:\n def __init__(self, title: str, author: str, pages: int):\n self.title = title\n self.author = author\n self.pages = pages\n\n def __str__(self) -> str:\n return f\"'{self.title}' by {self.author} ({self.pages} pages)\"\n\n def __add__(self, other: 'Book') -> int:\n if isinstance(other, Book):\n return self.pages + other.pages\n raise TypeError(\"Can only add Book to Book\")\n\n\nclass EBook(Book):\n def __init__(self, title: str, author: str, pages: int, file_format: str, file_size_mb: float):\n super().__init__(title, author, pages)\n self.file_format = file_format\n self.file_size_mb = file_size_mb\n\n def __str__(self) -> str:\n base_info = super().__str__()\n return f\"{base_info} [Digital Format: {self.file_format}, Size: {self.file_size_mb}MB]\"\n\n\nif __name__ == \"__main__\":\n book1 = Book(\"The Great Gatsby\", \"F. Scott Fitzgerald\", 180)\n book2 = Book(\"1984\", \"George Orwell\", 328)\n ebook1 = EBook(\"Digital Fortress\", \"Dan Brown\", 448, \"EPUB\", 2.5)\n\n print(book1)\n print(book2)\n print(ebook1)\n\n total_pages = book1 + book2\n print(f\"Total pages of book1 and book2: {total_pages}\")\n\n total_pages_with_ebook = book1 + ebook1\n print(f\"Total pages of book1 and ebook1: {total_pages_with_ebook}\")\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите программу, которая подсчитывает частоту появления каждого слова в заданном тексте, используя класс `Counter` из модуля `collections`. Полученный результат необходимо преобразовать в словарь, где ключами будут уникальные слова, а значениями — количество их упоминаний."}, {"role": "assistant", "content": "```python\nfrom collections import Counter\nimport re\n\ndef count_word_frequency(text: str) -> dict:\n # Приводим к нижнему регистру и используем регулярное выражение для поиска слов\n # \\w+ находит последовательности букв, цифр и подчеркиваний\n words = re.findall(r'\\w+', text.lower())\n \n # Используем Counter для подсчета и преобразуем в dict\n return dict(Counter(words))\n\nif __name__ == \"__main__\":\n sample_text = \"Python is great. Python is fast, and Python is easy to learn!\"\n result = count_word_frequency(sample_text)\n print(result)\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите рекурсивную функцию для вычисления $n$-го числа Фибоначчи, которая при стандартном подходе вызывает переполнение стека или работает бесконечно долго при больших значениях. Реализуйте оптимизацию с помощью мемоизации так, чтобы функция возвращала корректный результат, но при этом не использовала встроенный декоратор `functools.lru_cache`."}, {"role": "assistant", "content": "```python\ndef fibonacci(n, memo=None):\n if memo is None:\n memo = {0: 0, 1: 1}\n \n if n in memo:\n return memo[n]\n \n if n < 0:\n raise ValueError(\"n must be a non-negative integer\")\n\n memo[n] = fibonacci(n - 1, memo) + fibonacci(n - 2, memo)\n return memo[n]\n\n# Пример использования:\nif __name__ == \"__main__\":\n import sys\n # Увеличиваем лимит рекурсии для работы с большими n\n sys.setrecursionlimit(2000)\n \n print(fibonacci(10)) # 55\n print(fibonacci(100)) # 354224848179261915075\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите программу, которая анализирует текстовый файл и возвращает словарь, содержащий только те слова, которые встречаются в тексте строго определенное количество раз. Для решения используйте инструменты из модуля `collections`, чтобы эффективно подсчитать частоту слов и отфильтровать их с помощью множеств."}, {"role": "assistant", "content": "```python\nimport collections\nimport re\n\ndef get_words_with_exact_frequency(file_path: str, target_count: int) -> dict:\n \"\"\"\n Analyzes a text file and returns a dictionary of words \n that appear exactly target_count times.\n \"\"\"\n try:\n with open(file_path, 'r', encoding='utf-8') as file:\n text = file.read().lower()\n \n # Use regex to extract words (ignoring punctuation)\n words = re.findall(r'\\b\\w+\\b', text)\n \n # Efficiently count frequencies using collections.Counter\n counts = collections.Counter(words)\n \n # Use set comprehension to find words matching the target frequency\n # and construct the resulting dictionary\n target_words = {word for word, count in counts.items() if count == target_count}\n \n return {word: target_count for word in target_words}\n \n except FileNotFoundError:\n return {}\n except Exception:\n return {}\n\nif __name__ == \"__main__\":\n # Example usage:\n # Create a dummy file for demonstration\n filename = \"sample.txt\"\n with open(filename, \"w\", encoding=\"utf-8\") as f:\n f.write(\"Python is great. Python is fast. Learning Python is fun!\")\n\n # Find words that appear exactly 3 times\n result = get_words_with_exact_frequency(filename, 3)\n print(result) # Expected: {'python': 3}\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Дан список произвольных чисел, из которого необходимо отфильтровать только положительные значения. Полученный подсписок следует отсортировать по возрастанию и вывести на экран самый минимальный элемент."}, {"role": "assistant", "content": "```python\ndef solve(numbers):\n positive_numbers = sorted([x for x in numbers if x > 0])\n if positive_numbers:\n print(positive_numbers[0])\n else:\n print(\"No positive numbers found\")\n\nif __name__ == \"__main__\":\n # Example usage\n data = [10, -5, 3, 0, -1, 7, 2, -8, 1]\n solve(data)\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Дан список идентификаторов товаров, где некоторые элементы могут повторяться, а некоторые — отсутствовать в справочнике цен. Найдите количество уникальных товаров, цена которых не указана в словаре, используя максимально эффективный способ обработки множеств и словарей."}, {"role": "assistant", "content": "```python\ndef count_missing_prices(product_ids, price_directory):\n \"\"\"\n Находит количество уникальных товаров, цена которых отсутствует в справочнике.\n \n :param product_ids: List[Any] - список идентификаторов товаров (с дубликатами)\n :param price_directory: Dict[Any, float] - словарь {id: price}\n :return: int - количество уникальных товаров без цены\n \"\"\"\n # Превращаем список в множество для получения уникальных ID за O(N)\n unique_products = set(product_ids)\n \n # Создаем множество ключей из словаря цен за O(M)\n available_prices = set(price_directory.keys())\n \n # Находим пересечение (или разность) множеств. \n # Разность множеств (unique_products - available_prices) \n # вернет только те ID, которых нет в словаре.\n missing_products = unique_products - available_prices\n \n return len(missing_products)\n\n# Пример использования:\nif __name__ == \"__main__\":\n ids = [1, 2, 2, 3, 4, 4, 4, 5, 10, 10]\n prices = {1: 100.0, 2: 200.0, 3: 300.0, 5: 500.0}\n \n # Ожидаемый результат: \n # Уникальные ID: {1, 2, 3, 4, 5, 10}\n # Есть в ценах: {1, 2, 3, 5}\n # Отсутствуют: {4, 10} -> 2 товара\n \n result = count_missing_prices(ids, prices)\n print(result)\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите функцию, которая с помощью выражения-генератора и модуля `itertools` отбирает из бесконечной последовательности чисел только те, которые являются квадратами целых чисел и делятся на заданное число $k$. Функция должна возвращать генератор, выдающий первые $n$ таких элементов, используя ключевое слово `yield` для оптимизации памяти."}, {"role": "assistant", "content": "```python\nimport itertools\nimport math\n\ndef get_squares_divisible_by_k(k, n):\n \"\"\"\n Returns a generator yielding the first n perfect squares divisible by k.\n \"\"\"\n if k <= 0:\n raise ValueError(\"k must be a positive integer\")\n \n # Infinite sequence of integers starting from 0\n numbers = itertools.count(0)\n \n # Generator expression to filter squares divisible by k\n # x*x is a square, we check if (x*x) % k == 0\n squares_gen = (x * x for x in numbers if (x * x) % k == 0)\n \n def limited_generator(gen, count):\n for _ in range(count):\n yield next(gen)\n \n return limited_generator(squares_gen, n)\n\n# Example usage:\nif __name__ == \"__main__\":\n k_val = 3\n n_val = 5\n result = get_squares_divisible_by_k(k_val, n_val)\n print(list(result))\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Данная строка содержит скрытый идентификатор, который необходимо извлечь с помощью регулярного выражения, учитывая, что спецсимволы в срезах могут изменить ожидаемую длину подстроки. Будьте внимательны: при применении форматирования и срезов к результату поиска порядок индексов и обработка экранированных последовательностей могут привести к получению не той части строки, которую вы планировали."}, {"role": "assistant", "content": "```python\nimport re\n\ndef extract_identifier(input_string: str) -> str:\n \"\"\"\n Extracts a hidden identifier from a string using regex.\n The pattern looks for a specific sequence: \n an escaped character followed by a specific hex-like pattern.\n \"\"\"\n # Pattern: looks for an escaped character (e.g., \\x or \\u) \n # followed by a sequence of alphanumeric characters that form the ID.\n # We use a non-capturing group for the prefix to isolate the ID.\n pattern = r'(?:\\\\(?:x[0-9a-fA-F]{2}|u[0-9a-fA-F]{4}))([a-zA-Z0-9]{8,16})'\n \n match = re.search(pattern, input_string)\n \n if match:\n # The identifier is in the first capturing group\n return match.group(1)\n return \"\"\n\nif __name__ == \"__main__\":\n # Example case: The ID 'AlphaID123' is hidden after an escaped sequence\n test_string = \"System_Log_Data: [status=ok, id=\\\\x41lphaID123, checksum=0xFA]\"\n \n # Note: In a real raw string or file, the backslash might be literal.\n # If the input is a standard string, '\\\\' represents a single backslash.\n \n result = extract_identifier(test_string)\n print(result)\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Данная задача требует извлечь из строки все последовательности цифр, которые стоят между двумя дефисами, но при этом игнорировать числа, если они являются частью дробного значения с точкой. Учтите, что после извлечения необходимо отсортировать полученные значения по убыванию, используя только их строковое представление, что может привести к неожиданному результату."}, {"role": "assistant", "content": "```python\nimport re\n\ndef solve(input_string: str) -> list[str]:\n # Регулярное выражение ищет паттерн: дефис, затем цифры, затем дефис.\n # Используем lookbehind (?<=-) и lookahead (?=-) для проверки границ.\n # Чтобы исключить дробные числа с точкой, мы проверяем, что перед или после \n # найденной последовательности цифр нет точки.\n \n # Сначала найдем все вхождения между дефисами\n pattern = r'(?<=-)(\\d+)(?=-)'\n matches = re.findall(pattern, input_string)\n \n # Фильтрация: проверяем, не является ли ��исло частью дробного (с точкой)\n # Согласно условию: \"игнорировать числа, если они являются частью дробного значения с точкой\"\n # Это значит, что если в строке есть \".-123-\", то 123 нужно игнорировать.\n # Проверим контекст вокруг найденного совпадения.\n \n valid_numbers = []\n \n # Для точного соблюдения условия \"игнорировать, если часть дробного\"\n # найдем все потенциальные числа между дефисами и проверим их соседей\n for match in re.finditer(r'(?<=-)(\\d+)(?=-)', input_string):\n start, end = match.span()\n # Проверяем символ непосредственно перед началом и после конца найденного числа\n # (хотя regex (?<=-) уже гарантирует дефис, нам нужно проверить наличие точки)\n \n # Проверяем, нет ли точки в строке непосредственно перед или после найденного куска\n # в рамках логики дробного числа.\n is_fraction = False\n if start > 0 and input_string[start-1] == '.':\n is_fraction = True\n if end < len(input_string) and input_string[end] == '.':\n is_fraction = True\n \n if not is_fraction:\n valid_numbers.append(match.group(1))\n\n # Сортировка по убыванию, используя только строковое представление\n valid_numbers.sort(reverse=True)\n \n return valid_numbers\n\nif __name__ == \"__main__\":\n # Тестовый пример\n # -10- -2- -100- -1.5- -5-\n # Ожидаем: '5', '2', '10', '100' (но сортировка строк: '5', '2', '100', '10')\n # В строковой сортировке по убыванию: '5', '2', '100', '10'\n test_str = \"-10--2--100--1.5--5-\"\n result = solve(test_str)\n print(result)\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите функцию, которая принимает список словарей с данными о товарах и возвращает отфильтрованный список объектов, цена которых выше среднего значения. Полученный результат необходимо отсортировать по убыванию рейтинга товара, используя алгоритм быстрой сортировки или встроенные методы."}, {"role": "assistant", "content": "```python\ndef filter_and_sort_products(products: list[dict]) -> list[dict]:\n \"\"\"\n Фильтрует товары с ценой выше средней и сортирует их по рейтингу (убывание).\n \"\"\"\n if not products:\n return []\n\n # Вычисляем среднюю цену\n total_price = sum(item['price'] for item in products)\n avg_price = total_price / len(products)\n\n # Фильтруем товары, цена которых выше средней\n filtered_products = [item for item in products if item['price'] > avg_price]\n\n # Сортируем по рейтингу (rating) по убыванию\n # Используем встроенный Timsort (эффективен и стабилен)\n filtered_products.sort(key=lambda x: x['rating'], reverse=True)\n\n return filtered_products\n\nif __name__ == \"__main__\":\n # Тестовые данные\n data = [\n {\"name\": \"Laptop\", \"price\": 1000, \"rating\": 4.5},\n {\"name\": \"Mouse\", \"price\": 20, \"rating\": 4.8},\n {\"name\": \"Monitor\", \"price\": 300, \"rating\": 4.2},\n {\"name\": \"Keyboard\", \"price\": 80, \"rating\": 4.6},\n {\"name\": \"Smartphone\", \"price\": 700, \"rating\": 4.9},\n {\"name\": \"Headphones\", \"price\": 150, \"rating\": 4.0},\n ]\n\n result = filter_and_sort_products(data)\n print(result)\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Дан список целых чисел, в котором необходимо найти минимальный элемент, используя только метод фильтрации по условию строгого возрастания относительно предыдущего соседа. Однако из-за специфической структуры входных данных и использования фиксированного `seed=100312`, стандартный алгоритм поиска минимума может вернуть не самый маленький элемент, а первый попавшийся подходящий под фильтр."}, {"role": "assistant", "content": "```python\nimport random\n\ndef solve():\n # Установка фиксированного seed для воспроизводимости специфической структуры\n random.seed(100312)\n \n # Генерация входных данных\n data = [random.randint(1, 1000) for _ in range(20)]\n \n # Задача требует поиска \"минимального\" элемента через фильтрацию \n # по условию строгого возрастания относительно предыдущего соседа.\n # Это означает, что мы рассматриваем только те элементы, \n # которые больше своего левого соседа.\n \n # Реализация фильтрации:\n # Элемент x подходит, если x > data[i-1]\n # Первый элемент не имеет предыдущего соседа, по логике задачи \n # \"относительно предыдущего\" он не может быть включен в фильтр возрастания.\n \n filtered_elements = list(filter(\n lambda i: data[i] > data[i-1], \n range(1, len(data))\n ))\n \n # Извлекаем значения, прошедшие фильтр\n candidates = [data[i] for i in filtered_elements]\n \n # Согласно условию, из-за специфики мы ищем не min(candidates), \n # а \"первый попавшийся подходящий под фильтр\" в контексте \n # поиска минимального (что может быть интерпретировано как \n # первый элемент в отфильтрованном списке, если алгоритм поиска \n # ограничен условием фильтрации).\n \n if candidates:\n # Возвращаем первый элемент, который удовлетворил условию фильтрации\n result = candidates[0]\n else:\n result = None\n\n return data, candidates, result\n\nif __name__ == \"__main__\":\n original_data, filtered, result = solve()\n print(f\"Original Data: {original_data}\")\n print(f\"Filtered Candidates (strictly increasing): {filtered}\")\n print(f\"Result (first matching element): {result}\")\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Создайте класс `Product` с атрибутами названия и цены, реализовав методы `__repr__` для красивого вывода и `__add__` для суммирования стоимости двух товаров. Затем создайте подкласс `DiscountedProduct`, который наследует свойства базового класса, но переопределяет логику сложения с учетом скидки."}, {"role": "assistant", "content": "```python\nclass Product:\n def __init__(self, name: str, price: float):\n self.name = name\n self.price = price\n\n def __repr__(self) -> str:\n return f\"Product(name='{self.name}', price={self.price})\"\n\n def __add__(self, other: 'Product') -> float:\n if not isinstance(other, Product):\n return NotImplemented\n return self.price + other.price\n\n\nclass DiscountedProduct(Product):\n def __init__(self, name: str, price: float, discount: float):\n super().__init__(name, price)\n self.discount = discount # Например, 0.2 для 20%\n\n def __repr__(self) -> str:\n return f\"DiscountedProduct(name='{self.name}', price={self.price}, discount={self.discount})\"\n\n def __add__(self, other: 'Product') -> float:\n if not isinstance(other, Product):\n return NotImplemented\n # Логика: суммируем цены, но применяем скидку текущего товара к общей сумме\n total_price = self.price + other.price\n return total_price * (1 - self.discount)\n\n# Пример использования:\nif __name__ == \"__main__\":\n p1 = Product(\"Laptop\", 1000.0)\n p2 = Product(\"Mouse\", 50.0)\n \n dp1 = DiscountedProduct(\"Smartphone\", 500.0, 0.1) # 10% скидка\n \n print(f\"Base addition: {p1 + p2}\") # 1050.0\n print(f\"Discounted addition: {dp1 + p2}\") # (500 + 50) * 0.9 = 495.0\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Создайте класс `Product` с атрибутами названия и цены, реализовав методы `__repr__` для красивого вывода объекта и `__add__` для суммирования цен двух товаров. Затем создайте подкласс `DiscountedProduct`, который наследует свойства родителя, но переопределяет логику сложения с учетом скидки."}, {"role": "assistant", "content": "```python\nclass Product:\n def __init__(self, name: str, price: float):\n self.name = name\n self.price = price\n\n def __repr__(self) -> str:\n return f\"Product(name='{self.name}', price={self.price})\"\n\n def __add__(self, other: 'Product') -> float:\n if not isinstance(other, Product):\n raise TypeError(\"Can only add Product to Product\")\n return self.price + other.price\n\n\nclass DiscountedProduct(Product):\n def __init__(self, name: str, price: float, discount_rate: float):\n super().__init__(name, price)\n self.discount_rate = discount_rate # e.g., 0.1 for 10%\n\n def __repr__(self) -> str:\n return f\"DiscountedProduct(name='{self.name}', price={self.price}, discount={self.discount_rate})\"\n\n def __add__(self, other: 'Product') -> float:\n # Logic: Sum of prices, but the current object's price is taken after discount\n discounted_price = self.price * (1 - self.discount_rate)\n if isinstance(other, Product):\n return discounted_price + other.price\n raise TypeError(\"Can only add Product to Product\")\n\n\nif __name__ == \"__main__\":\n p1 = Product(\"Laptop\", 1000.0)\n p2 = Product(\"Mouse\", 50.0)\n dp1 = DiscountedProduct(\"Keyboard\", 100.0, 0.2) # 20% discount\n\n print(f\"p1: {p1}\")\n print(f\"p2: {p2}\")\n print(f\"dp1: {dp1}\")\n \n print(f\"Sum p1 + p2: {p1 + p2}\") # 1000 + 50 = 1050\n print(f\"Sum dp1 + p2: {dp1 + p2}\") # (100 * 0.8) + 50 = 130.0\n print(f\"Sum p1 + dp1: {p1 + dp1}\") # 1000 + 100 = 1100 (dp1 is 'other', no discount applied to self)\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите асинхронную функцию, которая запускает три корутины с разным временем ожидания через `asyncio.sleep`, но при этом должна завершиться максимально быстро, не дожидаясь выполнения самой долгой задачи. Учтите, что использование стандартного `asyncio.gather` без дополнительных механизмов управления не позволит прервать выполнение отложенных таймеров при наступлении условия выхода."}, {"role": "assistant", "content": "```python\nimport asyncio\n\nasync def task(name: str, delay: float):\n try:\n print(f\"Task {name} started with delay {delay}s\")\n await asyncio.sleep(delay)\n print(f\"Task {name} finished\")\n return f\"Result {name}\"\n except asyncio.CancelledError:\n print(f\"Task {name} was cancelled\")\n raise\n\nasync def run_fastest_first():\n # Define tasks with different delays\n tasks_data = [\n (\"A\", 1.0),\n (\"B\", 3.0),\n (\"C\", 5.0)\n ]\n \n # Create task objects\n coroutines = [task(name, delay) for name, delay in tasks_data]\n pending = [asyncio.create_task(coro) for coro in coroutines]\n\n try:\n # wait returns (done, pending)\n # return_when=asyncio.FIRST_COMPLETED ensures we don't wait for the longest one\n done, pending = await asyncio.wait(\n pending, \n return_when=asyncio.FIRST_COMPLETED\n )\n \n # Get the result of the first finished task\n first_finished = done.pop()\n print(f\"First task finished with result: {first_finished.result()}\")\n\n finally:\n # Crucial step: cancel all remaining tasks to prevent them from running in background\n for task_obj in pending:\n task_obj.cancel()\n \n # Wait for cancellation to propagate\n if pending:\n await asyncio.gather(*pending, return_exceptions=True)\n print(\"All remaining tasks cleaned up.\")\n\nif __name__ == \"__main__\":\n asyncio.run(run_fastest_first())\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите программу, которая извлекает из произвольной строки все последовательности цифр, используя регулярные выражения, и объединяет их в один список. Полученный список чисел необходимо вывести на экран в виде отформатированной строки, где каждое число отделено от следующего дефисом."}, {"role": "assistant", "content": "```python\nimport re\n\ndef extract_and_format_numbers(input_string: str) -> str:\n # Извлекаем все последовательности цифр с помощью регулярного выражения \\d+\n numbers = re.findall(r'\\d+', input_string)\n # Объединяем найденные элементы в строку через дефис\n return \"-\".join(numbers)\n\nif __name__ == \"__main__\":\n # Пример произвольной строки\n test_string = \"abc123def456ghi789jkl0\"\n result = extract_and_format_numbers(test_string)\n print(result)\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Найдите индекс первого элемента в списке, который не является максимальным значением, если при этом необходимо игнорировать все дубликаты текущего максимума. Учтите, что при наличии нескольких одинаковых максимальных значений алгоритм должен считать «максимумом» только первое вхождение, иначе логика поиска нарушится."}, {"role": "assistant", "content": "```python\ndef find_first_non_max_index(nums):\n if not nums:\n return None\n \n max_val = max(nums)\n \n # Согласно условию: \"считать максимумом только первое вхождение\"\n # и \"игнорировать все дубликаты текущего максимума\".\n # Это означает, что мы ищем первый элемент, который не равен max_val.\n \n for index, value in enumerate(nums):\n if value != max_val:\n return index\n \n return None\n\n# Тестовые случаи\nif __name__ == \"__main__\":\n test_cases = [\n ([10, 10, 5, 8, 10], 2), # Максимум 10, первый не 10 это 5 на индексе 2\n ([1, 2, 3, 3], 0), # Максимум 3, первый не 3 это 1 на индексе 0\n ([5, 5, 5], None), # Все элементы максимальные\n ([10, 9, 8], 1), # Максимум 10, первый не 10 это 9 на индексе 1\n ([], None) # Пустой список\n ]\n\n for arr, expected in test_cases:\n result = find_first_non_max_index(arr)\n assert result == expected, f\"Failed on {arr}: expected {expected}, got {result}\"\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите программу, которая находит наибольший общий делитель двух чисел и проверяет, является ли это число простым. Также вычислите факториал этого числа и выведите результат на экран."}, {"role": "assistant", "content": "```python\nimport math\n\ndef is_prime(n):\n if n < 2:\n return False\n for i in range(2, int(math.sqrt(n)) + 1):\n if n % i == 0:\n return False\n return True\n\ndef solve(a, b):\n gcd = math.gcd(a, b)\n prime_status = is_prime(gcd)\n factorial = math.factorial(gcd)\n \n print(f\"GCD: {gcd}\")\n print(f\"Is prime: {prime_status}\")\n print(f\"Factorial: {factorial}\")\n\nif __name__ == \"__main__\":\n try:\n num1 = int(input(\"Enter first number: \"))\n num2 = int(input(\"Enter second number: \"))\n solve(num1, num2)\n except ValueError:\n print(\"Please enter valid integers.\")\n except Exception as e:\n print(f\"An error occurred: {e}\")\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестир��ванное решение."}, {"role": "user", "content": "Напишите асинхронную программу, которая одновременно запускает три корутины, имитирующие выполнение различных задач с помощью случайных задержек. Каждая задача должна выводить сообщение о начале и завершении работы через заданный интервал времени с использованием `asyncio.sleep`."}, {"role": "assistant", "content": "```python\nimport asyncio\nimport random\n\nasync def task(name: str):\n delay = random.uniform(1, 3)\n print(f\"Задача '{name}' началась (ожидание {delay:.2f} сек.)\")\n await asyncio.sleep(delay)\n print(f\"Задача '{name}' завершена\")\n\nasync def main():\n tasks = [\n task(\"A\"),\n task(\"B\"),\n task(\"C\")\n ]\n await asyncio.gather(*tasks)\n\nif __name__ == \"__main__\":\n asyncio.run(main())\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите программу, которая находит наибольший общий делитель (НОД) двух чисел и вычисляет их факториалы. Также определите, является ли первое из введенных чисел простым."}, {"role": "assistant", "content": "```python\nimport math\n\ndef is_prime(n):\n if n < 2:\n return False\n for i in range(2, int(math.sqrt(n)) + 1):\n if n % i == 0:\n return False\n return True\n\ndef solve():\n try:\n num1 = int(input(\"Введите первое число: \"))\n num2 = int(input(\"Введите второе число: \"))\n\n gcd = math.gcd(num1, num2)\n \n fact1 = math.factorial(abs(num1)) if num1 >= 0 else \"Не определено (отрицательное)\"\n fact2 = math.factorial(abs(num2)) if num2 >= 0 else \"Не определено (отрицательное)\"\n \n prime_status = is_prime(num1)\n\n print(f\"НОД: {gcd}\")\n print(f\"Факториал первого числа: {fact1}\")\n print(f\"Факториал второго числа: {fact2}\")\n print(f\"Первое число простое: {prime_status}\")\n \n except ValueError:\n print(\"Ошибка: введите целые числа.\")\n except OverflowError:\n print(\"Ошибка: число слишком велико для вычисления факториала.\")\n\nif __name__ == \"__main__\":\n solve()\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Дан список строк, где некоторые элементы повторяются, и вам необходимо найти количество уникальных слов, которые встречаются в исходном списке ровно один раз. Будьте внимательны: при использовании стандартных методов подсчета и множеств результат может измениться, если не учитывать разницу между наличием элемента в коллекции и его частотой."}, {"role": "assistant", "content": "```python\nfrom collections import Counter\n\ndef count_unique_single_occurrence_words(words_list: list[str]) -> int:\n \"\"\"\n Finds the number of unique words that appear exactly once in the list.\n \"\"\"\n counts = Counter(words_list)\n return sum(1 for word in counts if counts[word] == 1)\n\nif __name__ == \"__main__\":\n # Test cases\n test_cases = [\n ([\"apple\", \"banana\", \"apple\", \"orange\", \"banana\", \"grape\"], 2), # orange, grape\n ([\"a\", \"b\", \"c\", \"a\", \"b\", \"c\"], 0), # all repeat\n ([\"hello\", \"world\", \"hello\", \"world\", \"python\"], 1), # python\n ([\"test\"], 1), # single element\n ([], 0), # empty list\n ([\"apple\", \"apple\", \"apple\"], 0), # all same\n ]\n\n for words, expected in test_cases:\n result = count_unique_single_occurrence_words(words)\n assert result == expected, f\"Failed on {words}: expected {expected}, got {result}\"\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиш�� чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Реализуйте класс `Vector`, который при сложении двух объектов возвращает не новый экземпляр класса, а строку, представляющую их сумму. Убедитесь, что при вызове `repr()` для полученного результата метод `__repr__` вызывается у строки, а не у исходного объекта."}, {"role": "assistant", "content": "```python\nclass Vector:\n def __init__(self, x: float, y: float):\n self.x = x\n self.y = y\n\n def __add__(self, other: 'Vector') -> str:\n if isinstance(other, Vector):\n res_x = self.x + other.x\n res_y = self.y + other.y\n return f\"Vector({res_x}, {res_y})\"\n return NotImplemented\n\n def __repr__(self) -> str:\n return f\"Vector({self.x}, {self.y})\"\n\nif __name__ == \"__main__\":\n v1 = Vector(1, 2)\n v2 = Vector(3, 4)\n \n result = v1 + v2\n \n assert isinstance(result, str)\n assert result == \"Vector(4, 6)\"\n assert repr(result) == \"'Vector(4, 6)'\"\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите программу, которая с помощью генератора списков фильтрует четные числа из последовательности, а затем использует выражение-генератор для вычисления их кубов. Затем примените функцию `yield` для создания итератора, который возвращает эти значения по одному, и продемонстрируйте работу с циклом или модулем `itertools`."}, {"role": "assistant", "content": "```python\nimport itertools\n\ndef cube_generator(numbers):\n \"\"\"Итератор, возвращающий кубы четных чисел.\"\"\"\n # 1. Генератор списка для фильтрации четных чисел\n even_numbers = [n for n in numbers if n % 2 == 0]\n \n # 2. Выражение-генератор для вычисления кубов\n cubes_gen = (n**3 for n in even_numbers)\n \n # 3. Использование yield для создания итератора\n for cube in cubes_gen:\n yield cube\n\nif __name__ == \"__main__\":\n # Исходная последовательность\n sequence = range(1, 11)\n\n # Создание итератора\n iterator = cube_generator(sequence)\n\n # Демонстрация работы с помощью itertools.islice (ограничим вывод первыми 3 значениями)\n print(\"Первые 3 куба четных чисел:\")\n for value in itertools.islice(iterator, 3):\n print(value)\n\n # Демонстрация работы с помощью обычного цикла (оставшиеся значения)\n print(\"\\nОстальные кубы четных чисел:\")\n for value in iterator:\n print(value)\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите программу, которая с помощью модуля `pathlib` находит в указанной директории все CSV-файлы и извлекает из них данные о пользователях. Затем преобразуйте полученную информацию в структурированный список словарей и сохраните результат в единый итоговый JSON-файл."}, {"role": "assistant", "content": "```python\nimport csv\nimport json\nfrom pathlib import Path\n\ndef process_csv_to_json(directory_path: str, output_filename: str):\n base_dir = Path(directory_path)\n \n if not base_dir.is_dir():\n raise ValueError(f\"Path {directory_path} is not a valid directory.\")\n\n all_users = []\n\n # Поиск всех .csv файлов в директории\n csv_files = list(base_dir.glob(\"*.csv\"))\n\n for file_path in csv_files:\n try:\n with file_path.open(mode='r', encoding='utf-8-sig') as csv_file:\n # DictReader автоматически использует первую строку как ключи словаря\n reader = csv.DictReader(csv_file)\n for row in reader:\n # Очистка данных от лишних пробелов в ключах и значен��ях\n clean_row = {k.strip(): v.strip() for k, v in row.items() if k is not None}\n if clean_row:\n # Добавляем метаданные о источнике (опционально)\n clean_row['source_file'] = file_path.name\n all_users.append(clean_row)\n except Exception as e:\n print(f\"Error processing {file_path.name}: {e}\")\n\n # Сохранение результата в JSON\n output_path = base_dir / output_filename\n with output_path.open(mode='w', encoding='utf-8') as json_file:\n json.dump(all_users, json_file, indent=4, ensure_ascii=False)\n \n return output_path\n\nif __name__ == \"__main__\":\n # Пример использования:\n # Создадим тестовые данные для демонстрации\n test_dir = Path(\"test_data\")\n test_dir.mkdir(exist_ok=True)\n \n file1 = test_dir / \"users_a.csv\"\n file1.write_text(\"id,name,email\\n1,Alice,alice@example.com\\n2,Bob,bob@example.com\", encoding=\"utf-8\")\n \n file2 = test_dir / \"users_b.csv\"\n file2.write_text(\"id,name,email\\n3,Charlie,charlie@example.com\\n4,David,david@example.com\", encoding=\"utf-8\")\n\n try:\n result_file = process_csv_to_json(\"test_data\", \"combined_users.json\")\n print(f\"Success! Data saved to: {result_file}\")\n except Exception as err:\n print(f\"Failed: {err}\")\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите программу, которая принимает на вход целое число и вычисляет для него значение факториала, а также находит наибольший общий делитель (НОД) этого числа и заданного пользователем значения. Дополнительно определите, является ли полученный факториал простым числом."}, {"role": "assistant", "content": "```python\nimport math\n\ndef is_prime(n):\n if n < 2:\n return False\n for i in range(2, int(math.sqrt(n)) + 1):\n if n % i == 0:\n return False\n return True\n\ndef solve():\n try:\n num1 = int(input())\n num2 = int(input())\n\n # Вычисление факториала\n if num1 < 0:\n factorial_val = None\n else:\n factorial_val = math.factorial(num1)\n\n # Вычисление НОД\n gcd_val = math.gcd(num1, num2)\n\n # Вывод результатов\n if factorial_val is not None:\n print(f\"Факториал: {factorial_val}\")\n print(f\"Является ли факториал простым числом: {is_prime(factorial_val)}\")\n else:\n print(\"Факториал не определен для отрицательных чисел\")\n \n print(f\"НОД: {gcd_val}\")\n\n except ValueError:\n pass\n\nif __name__ == \"__main__\":\n solve()\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Создайте класс `Vector`, который при сложении двух объектов через `__add__` возвращает новый объект того же класса, но при попытке вывести его через `__repr__` должен возвращать строку, представляющую результат как кортеж координат. Ловушка заключается в том, что при наследовании от этого класса пользовательский подкласс должен корректно сохранять тип возвращаемого объекта при сложении, не нарушая логику строкового представления родителя."}, {"role": "assistant", "content": "```python\nclass Vector:\n def __init__(self, *coords):\n self.coords = coords\n\n def __add__(self, other):\n if not isinstance(other, Vector):\n return NotImplemented\n \n # Вычисляем новые координаты\n new_coords = tuple(a + b for a, b in zip(self.coords, other.coords))\n \n # Используем type(self), чтобы вернуть экземпляр подкласса, если это наследник\n return type(self)(*new_coords)\n\n def __repr__(self):\n return str(self.coords)\n\nclass SubVector(Vector):\n pass\n\n# Тестирование\nif __name__ == \"__main__\":\n v1 = Vector(1, 2)\n v2 = Vector(3, 4)\n v3 = SubVector(5, 6)\n \n # Проверка базового класса\n res1 = v1 + v2\n print(f\"Vector repr: {res1}\") # (4, 6)\n assert isinstance(res1, Vector)\n \n # Проверка наследования (ловушка)\n res2 = v3 + v2\n print(f\"SubVector repr: {res2}\") # (8, 10)\n assert isinstance(res2, SubVector)\n```"}]} +{"messages": [{"role": "system", "content": "Ты опытный Python разработчик. Напиши чистое, рабочее и протестированное решение."}, {"role": "user", "content": "Напишите программу, которая с помощью модуля `pathlib` находит в заданной директории все CSV-файлы, считывает их содержимое и преобразует данные в единый структурированный JSON-файл. В процессе обработки необходимо отфильтровать строки по определенному критерию и сохранить итоговый результат в новую папку, созданную автоматически."}, {"role": "assistant", "content": "```python\nimport csv\nimport json\nfrom pathlib import Path\n\ndef process_csv_to_json(source_dir: str, output_dir: str, filter_column: str, filter_value: str):\n source_path = Path(source_dir)\n target_path = Path(output_dir)\n \n if not source_path.exists():\n raise FileNotFoundError(f\"Source directory {source_dir} does not exist.\")\n\n # Создаем целевую директорию автоматически\n target_path.mkdir(parents=True, exist_ok=True)\n \n combined_data = []\n\n # Поиск всех .csv файлов\n csv_files = list(source_path.glob(\"*.csv\"))\n \n if not csv_files:\n print(\"No CSV files found.\")\n return\n\n for file_path in csv_files:\n try:\n with file_path.open(mode='r', encoding='utf-8') as csv_file:\n reader = csv.DictReader(csv_file)\n for row in reader:\n # Фильтрация по критерию\n if row.get(filter_column) == filter_value:\n combined_data.append(row)\n except Exception as e:\n print(f\"Error processing {file_path.name}: {e}\")\n\n # Сохранение результата в JSON\n output_file = target_path / \"combined_data.json\"\n with output_file.open(mode='w', encoding='utf-8') as json_file:\n json.dump(combined_data, json_file, indent=4, ensure_ascii=False)\n\n print(f\"Processing complete. {len(combined_data)} rows saved to {output_file}\")\n\nif __name__ == \"__main__\":\n # Пример использования:\n # Создадим тестовые данные для демонстрации\n import os\n \n test_dir = Path(\"test_source\")\n test_dir.mkdir(exist_ok=True)\n \n file1 = test_dir / \"data1.csv\"\n file1.write_text(\"id,name,status\\n1,Alice,active\\n2,Bob,inactive\\n3,Charlie,active\", encoding=\"utf-8\")\n \n file2 = test_dir / \"data2.csv\"\n file2.write_text(\"id,name,status\\n4,David,active\\n5,Eve,pending\", encoding=\"utf-8\")\n\n # Запуск основной функции\n # Фильтруем строки, где status == 'active'\n process_csv_to_json(\n source_dir=\"test_source\", \n output_dir=\"processed_results\", \n filter_column=\"status\", \n filter_value=\"active\"\n )\n```"}]}