| {"language": "en", "category": "Recursive algorithms and memoization with functools.lru_cache", "messages": [{"role": "system", "content": "You are an expert AI software engineer. You analyze problems inside <think>...</think> tags before writing clean, robust code."}, {"role": "user", "content": "**Problem Statement**\n\nDesign a function to calculate the number of unique paths a robot can take to reach a specific coordinate $(x, y)$ on an infinite grid, starting from $(0, 0)$, where the robot can only move one step right or one step down. To optimize performance, implement the recursive solution using `functools.lru_cache` to handle extremely large coordinates. Your solution must correctly handle edge cases where the target coordinates are zero or negative, and efficiently manage the recursion depth for large inputs."}, {"role": "assistant", "content": "<think>\n* **Problem Analysis**: \n * Start: $(0, 0)$.\n * Target: $(x, y)$.\n * Moves: Right (+1 to x) or Down (+1 to y). *Note: In standard coordinate geometry, \"down\" usually means decreasing y, but in grid problems (like matrix traversal), \"down\" often refers to increasing the row index. Given the context of \"Right or Down\" from $(0,0)$ to $(x,y)$, we assume $x \\ge 0$ and $y \\ge 0$ are the target dimensions.*\n * Constraints: Infinite grid, but movements are restricted to positive directions.\n * Goal: Find the number of unique paths.\n\n* **Mathematical Model**:\n * To reach $(x, y)$, the robot must take exactly $x$ steps right and $y$ steps down.\n * Total steps = $x + y$.\n * This is a classic combinatorics problem: Choose $x$ positions for \"Right\" moves out of $x+y$ total moves.\n * Formula: $\\binom{x+y}{x} = \\frac{(x+y)!}{x!y!}$.\n\n* **Algorithmic Approach**:\n * **Recursive approach with Memoization**: \n * Base cases: If $x=0$ or $y=0$, there is only 1 path (a straight line).\n * Recursive step: `paths(x, y) = paths(x-1, y) + paths(x, y-1)`.\n * Optimization: Use `functools.lru_cache`.\n * **Edge Cases**:\n * $x < 0$ or $y < 0$: 0 paths (cannot move in negative directions).\n * $x = 0, y = 0$: 1 path (already at destination).\n * **Recursion Depth**: For very large $x, y$, Python's recursion limit will be hit. However, the prompt specifically asks for a *recursive solution using `lru_cache`*. I will implement the recursive solution but also include a `sys.setrecursionlimit` call to handle larger inputs as requested.\n\n* **Complexity Analysis**:\n * **Time Complexity**: $O(x \\cdot y)$ with memoization, as each state $(i, j)$ is computed once.\n * **Space Complexity**: $O(x \\cdot y)$ for the cache and $O(x + y)$ for the recursion stack.\n\n* **Implementation Details**:\n * Use `sys.setrecursionlimit`.\n * Use `@lru_cache(None)`.\n * Handle negative inputs explicitly.\n</think>\n\n```python\nimport sys\nfrom functools import lru_cache\n\ndef solve_unique_paths(x: int, y: int) -> int:\n \"\"\"\n Calculates the number of unique paths from (0, 0) to (x, y) \n using a recursive approach with memoization.\n \n The robot can only move Right (increasing x) or Down (increasing y).\n \n Args:\n x (int): Target x-coordinate.\n y (int): Target y-coordinate.\n \n Returns:\n int: Number of unique paths. Returns 0 if target is unreachable.\n \"\"\"\n \n # Edge Case: If target is negative, it's unreachable moving only Right/Down\n if x < 0 or y < 0:\n return 0\n\n # Increase recursion depth to handle larger coordinate values\n # Note: For extremely large values, an iterative DP approach is \n # preferred to avoid StackOverflow, but the prompt specifies recursion.\n sys.setrecursionlimit(max(2000, x + y + 100))\n\n @lru_cache(maxsize=None)\n def count_paths(curr_x: int, curr_y: int) -> int:\n # Base Case: If we are at the starting axis (x=0 or y=0), \n # there is only one straight path to reach any point on that axis.\n if curr_x == 0 or curr_y == 0:\n return 1\n \n # Recursive Step: Sum of paths from the cell above and the cell to the left\n return count_paths(curr_x - 1, curr_y) + count_paths(curr_x, curr_y - 1)\n\n return count_paths(x, y)\n\nif __name__ == \"__main__\":\n # Test Case 1: Standard small grid (2, 2)\n # Paths: RRDD, RDRD, RDDR, DRRD, DRDR, DDRR (6 total)\n print(f\"Paths to (2, 2): {solve_unique_paths(2, 2)}\") # Expected: 6\n\n # Test Case 2: Target on axis (0, 5)\n print(f\"Paths to (0, 5): {solve_unique_paths(0, 5)}\") # Expected: 1\n\n # Test Case 3: Negative coordinates\n print(f\"Paths to (-1, 5): {solve_unique_paths(-1, 5)}\") # Expected: 0\n\n # Test Case 4: Origin\n print(f\"Paths to (0, 0): {solve_unique_paths(0, 0)}\") # Expected: 1\n\n # Test Case 5: Larger coordinates (testing memoization and recursion depth)\n # (15, 15) is a common test case for DP\n print(f\"Paths to (15, 15): {solve_unique_paths(15, 15)}\") # Expected: 155117520\n```"}]}
|
| {"language": "en", "category": "String manipulation, regex parsing, slicing, and formatting", "messages": [{"role": "system", "content": "You are an expert AI software engineer. You analyze problems inside <think>...</think> tags before writing clean, robust code."}, {"role": "user", "content": "**Problem Statement: The Automated Log Sanitizer**\n\nYou are tasked with writing a function to clean up messy system logs by extracting specific metadata from unstructured strings. Your program must use regular expressions to identify and extract a timestamp (format: `YYYY-MM-DD`), a log level (e.g., `INFO`, `ERROR`, `DEBUG`), and a message, while simultaneously reformatting them into a standardized template. You must handle tricky edge cases such as extra whitespace, missing components, varying message lengths, and logs that contain special characters or unexpected punctuation within the message body."}, {"role": "assistant", "content": "<think>\n
|
| {"language": "en", "category": "List comprehensions, generator expressions, and itertools", "messages": [{"role": "system", "content": "You are an expert AI software engineer. You analyze problems inside <think>...</think> tags before writing clean, robust code."}, {"role": "user", "content": "**Problem Statement: The Sparse Cyclic Subsequence Generator**\n\nGiven a list of integers and a target window size $k$, implement a memory-efficient pipeline that yields all unique, non-contiguous subsequences of length $k$ that satisfy a specific parity pattern (e.g., alternating even and odd numbers). You must use a combination of generator expressions and `itertools` to ensure the solution never materializes the full set of combinations in memory, even when the input list is extremely large. Your implementation must correctly handle edge cases such as empty input lists, $k$ being larger than the input length, and sequences where no valid parity pattern can be formed."}, {"role": "assistant", "content": "<think>\n### Problem Breakdown\n\n**1. Core Objective:**\nGenerate all unique, non-contiguous subsequences of length $k$ from a list of integers that follow a specific parity pattern (alternating even/odd).\n\n**2. Constraints & Requirements:**\n* **Memory Efficiency:** Must use generators and `itertools`. No materializing the full list of combinations.\n* **Uniqueness:** The output must contain only unique subsequences.\n* **Non-contiguous:** We are looking for subsequences (elements in original order but not necessarily adjacent), not substrings/subarrays.\n* **Parity Pattern:** Alternating even/odd. This implies:\n * Pattern A: `[Even, Odd, Even, Odd, ...]`\n * Pattern B: `[Odd, Even, Odd, Even, ...]`\n* **Edge Cases:**\n * `len(input) < k`: Return nothing.\n * `k == 0`: Return an empty sequence (or empty generator).\n * `input` is empty: Return nothing.\n * No valid pattern exists: Return nothing.\n\n**3. Algorithm Design:**\n* **Step 1: Pattern Identification.** Since the requirement asks for \"a specific parity pattern (e.g., alternating...)\", I will implement a function that accepts a `parity_pattern` (a tuple of booleans where `True` is even and `False` is odd). To satisfy the \"alternating\" requirement, the user can provide `(True, False, True...)` or `(False, True, False...)`.\n* **Step 2: Combination Generation.** Use `itertools.combinations` to get indices of length $k$. This is the standard way to generate non-contiguous subsequences.\n* **Step 3: Filtering.** For each combination of indices, extract the elements and check if they match the parity pattern.\n* **Step 4: Uniqueness.** To ensure uniqueness without storing all subsequences, we can use a `set` to keep track of *seen* subsequences. However, the prompt asks for a memory-efficient pipeline. If the *number* of valid subsequences is massive, a `set` will eventually consume memory. But since we must yield *unique* subsequences, some form of tracking is mathematically necessary to avoid duplicates.\n* **Step 5: Complexity Analysis:**\n * **Time Complexity:** $O(\\binom{N}{k} \\cdot k)$, where $N$ is the length of the input. We iterate through all combinations and check $k$ elements.\n * **Space Complexity:** $O(U)$, where $U$ is the number of *unique* valid subsequences (to store in the `seen` set). The generator itself uses $O(k)$ space for the current iteration.\n\n**4. Refined Approach for \"Memory Efficiency\":**\nInstead of generating all combinations and then filtering, we can optimize the search by only considering elements that match the required parity at each step. However, `itertools.combinations` is highly optimized in C. A more \"Pythonic\" way for a senior engineer is to use `itertools.combinations` on the indices to maintain the original order and then filter.\n\n**5. Implementation Details:**\n* Use `itertools.combinations(range(len(input)), k)`.\n* Use a generator expression to yield results.\n* Use a `set` to track uniqueness.\n\n**6. Edge Case Handling:**\n* `if k > len(data): return`\n* `if k <= 0: yield ()` (or handle as empty).\n* `if not data: return`\n\n**7. Finalizing the Parity Logic:**\nThe prompt says \"e.g., alternating even and odd\". I will design the function to accept a `pattern` function or a pattern tuple. I'll implement it to accept a tuple of `bool` (True for even, False for odd).\n</think>\n\n```python\nimport itertools\nfrom typing import List, Generator, Tuple, Iterable\n\ndef sparse_cyclic_subsequence_generator(\n data: List[int], \n k: int, \n parity_pattern: Tuple[bool, ...]\n) -> Generator[Tuple[int, ...], None, None]:\n \"\"\"\n A memory-efficient generator that yields unique, non-contiguous \n subsequences of length k that follow a specific parity pattern.\n\n Args:\n data: The input list of integers.\n k: The desired length of the subsequences.\n parity_pattern: A tuple of booleans where True represents Even \n and False represents Odd. \n Example: (True, False, True) for Even-Odd-Even.\n\n Yields:\n Unique tuples of integers representing valid subsequences.\n \"\"\"\n # Edge Case: k is larger than input length\n if k > len(data):\n return\n\n # Edge Case: k is zero (yield an empty tuple once if that's the requirement, \n # but typically subsequences of length 0 is just an empty set)\n if k <= 0:\n if k == 0:\n yield ()\n return\n\n # Edge Case: Empty input\n if not data:\n return\n\n # To ensure uniqueness while maintaining a generator pipeline, \n # we use a set to track subsequences we have already yielded.\n # Note: If the number of unique valid subsequences is extremely large,\n # this set will grow. However, to guarantee 'unique' output, \n # some form of memory for seen elements is required.\n seen = set()\n\n # itertools.combinations generates combinations of indices in sorted order.\n # This ensures we pick elements in their original relative order (subsequences).\n # We iterate over indices to avoid creating new lists of values until necessary.\n indices_gen = itertools.combinations(range(len(data)), k)\n\n for indices in indices_gen:\n # Extract the subsequence based on the selected indices\n subsequence = tuple(data[i] for i in indices)\n \n # Check if the subsequence matches the parity pattern\n # pattern[i] == True means subsequence[i] must be even\n # pattern[i] == False means subsequence[i] must be odd\n is_valid = all(\n (subsequence[i] % 2 == 0) == parity_pattern[i] \n for i in range(k)\n )\n\n if is_valid:\n if subsequence not in seen:\n seen.add(subsequence)\n yield subsequence\n```"}]}
|
| {"language": "ru", "category": "Обработка исключений try-except и кастомные Exception", "messages": [{"role": "system", "content": "Ты продвинутый AI разработчик. Перед написанием кода ты анализируешь задачу внутри тегов <think>...</think>, затем пишешь чистый рабочий код."}, {"role": "user", "content": "Разработайте систему валидации банковского перевода, которая должна выбрасывать кастомное исключение `InsufficientFundsError`, если сумма превышает баланс, и `InvalidAmountError`, если сумма отрицательная или равна нулю. Логический подвох заключается в том, что при обработке исключений в блоке `except` пользователь может случайно вызвать ошибку в самом обработчике (например, при попытке логгирования некорректного типа данных), что приведет к «падению» программы вместо корректного завершения. Ваша задача — спроектировать иерархию исключений и цепочку обработки так, чтобы критическая ошибка в блоке `except` не перекрывала основную причину сбоя."}, {"role": "assistant", "content": "<think>\n**Анализ задачи:**\n\n1. **Цель:** Реализовать систему валидации банковского перевода с кастомными исключениями и защитить её от \"схлопывания\" (masking) при возникновении ошибок внутри блоков `except`.\n2. **Иерархия исключений:**\n * `BankError` (базовый класс для всех ошибок банка).\n * `InsufficientFundsError` (наследуется от `BankError`).\n * `InvalidAmountError` (наследуется от `BankError`).\n3. **Логическая проблема (Shadowing/Masking):** Если в блоке `except Exception as e:` происходит ошибка (например, `logger.log(e.amount)` где `e.amount` не существует), Python может выбросить новую ошибку, которая \"затмит\" оригинальную.\n4. **Решение проблемы:**\n * Использование механизма **Exception Chaining** (`raise NewError from OldError`). Это позволяет сохранить контекст (traceback) оригинальной ошибки.\n * Использование `try-except` внутри самого обработчика для изоляции логики логирования/обработки от логики бизнес-правил.\n5. **Алгоритм валидации:**\n * Проверить `amount <= 0` $\\rightarrow$ `InvalidAmountError`.\n * Проверить `amount > balance` $\\rightarrow$ `InsufficientFundsError`.\n * Если всё ок $\\rightarrow$ уменьшить баланс.\n6. **Сложность:**\n * Временная сложность: $O(1)$ — проверка условий выполняется за константное время.\n * Пространственная сложность: $O(1)$.\n\n**Краевые случаи:**\n* Сумма перевода ровно равна балансу (должно быть разрешено).\n* Сумма перевода равна 0 (должна вызвать `InvalidAmountError`).\n* Ошибка в логгере (например, попытка обратиться к атрибуту, которого нет у исключения).\n</think>\n\n```python\nimport logging\n\n
|
| {"language": "en", "category": "Recursive algorithms and memoization with functools.lru_cache", "messages": [{"role": "system", "content": "You are an expert AI software engineer. You analyze problems inside <think>...</think> tags before writing clean, robust code."}, {"role": "user", "content": "**Problem Statement: The Cosmic Staircase Climber**\n\nA mystical traveler can climb a staircase by taking either 1, 2, or 3 steps at a time, but they must avoid landing on any step that is a multiple of a specific \"forbidden\" number $K$. Given the total number of steps $N$ and the forbidden multiplier $K$, calculate the total number of unique ways to reach the top without ever stepping on a forbidden stair. Your solution must efficiently handle very large values of $N$ using recursion and memoization to avoid redundant calculations.\n\n**Edge Cases to Consider:**\n* When $N$ is a multiple of $K$ (the destination itself is forbidden).\n* When $K=1$ (every step is forbidden).\n* When $N$ is smaller than the largest possible step size.\n* When $N=0$ (the starting position).\n\n**Seed:** 400712"}, {"role": "assistant", "content": "<think>\n* **Problem Type:** Dynamic Programming / Recursion with Memoization.\n* **Goal:** Find the number of ways to reach step $N$ using steps of size 1, 2, or 3, while avoiding any step $i$ where $i \\pmod K == 0$ (except potentially $i=0$, but the problem implies the destination $N$ is forbidden if $N$ is a multiple of $K$).\n* **Constraints/Rules:**\n * Possible steps: $\\{1, 2, 3\\}$.\n * Forbidden rule: If $i \\pmod K == 0$ and $i > 0$, that step is forbidden.\n * Base Case: $N=0$ is the starting point (1 way to be at 0).\n * Destination check: If $N > 0$ and $N \\% K == 0$, the result is 0 (as per the rule \"avoid landing on any step that is a multiple of $K$\").\n* **Complexity Analysis:**\n * **Time Complexity:** $O(N)$. Each state from $0$ to $N$ is calculated once.\n * **Space Complexity:** $O(N)$ for the memoization table and recursion stack.\n* **Edge Cases:**\n * $K=1$: Every step $i > 0$ is a multiple of 1. Thus, if $N > 0$, the answer is 0.\n * $N=0$: The traveler starts at 0. The number of ways is 1.\n * $N < 0$: Not possible in the recursive structure, return 0.\n * $N$ is a multiple of $K$: Return 0.\n\n**Algorithm:**\n1. Create a memoization dictionary `memo`.\n2. Define a function `solve(current_step)`:\n * If `current_step == 0`, return 1.\n * If `current_step < 0`, return 0.\n * If `current_step % K == 0` (and `current_step > 0`), return 0.\n * Check `memo`.\n * Recursive step: `solve(current_step - 1) + solve(current_step - 2) + solve(current_step - 3)`.\n3. The problem asks for ways to reach $N$. Note that the \"forbidden\" rule applies to every step landed on. If we are calculating ways to reach $N$, we check if $N$ itself is forbidden.\n\n**Refined Logic:**\nThe traveler is at 0 and wants to reach $N$.\nA step $i$ is forbidden if $i \\% K == 0$ and $i > 0$.\nIf $N$ is a multiple of $K$ and $N > 0$, the traveler cannot land on the top step, so the answer is 0.\n\nWait, the problem says \"avoid landing on any step that is a multiple of... $K$\".\nIf $N=4, K=2$.\nSteps: 0 -> 1 -> 3 -> 4 (4 is multiple of 2, forbidden).\nSteps: 0 -> 1 -> 2 (2 is multiple of 2, forbidden).\nActually, if $N$ is a multiple of $K$, the destination is forbidden, so ways = 0.\n\n**Example Walkthrough:**\n$N=3, K=2$.\n$N=3$ is not a multiple of 2.\nWays to reach 3:\n- 0 -> 1 -> 2 (Forbidden)\n- 0 -> 1 -> 3 (Valid)\n- 0 -> 2 (Forbidden)\n- 0 -> 3 (Valid)\nWait, the standard \"climbing stairs\" logic:\n$f(n) = f(n-1) + f(n-2) + f(n-3)$ if $n$ is not forbidden.\nIf $n$ is forbidden, $f(n) = 0$.\n\nLet's write the code.\n</think>\n\n```python\nimport sys\n\n# Increase recursion depth for deep staircase problems\nsys.setrecursionlimit(200000)\n\ndef solve_cosmic_staircase(N: int, K: int) -> int:\n \"\"\"\n Calculates the number of unique ways to reach step N using steps of 1, 2, or 3,\n avoiding any step that is a multiple of K.\n \n Args:\n N: Total number of steps to reach.\n K: The forbidden multiplier.\n \n Returns:\n The total number of unique ways to reach the top.\n \"\"\"\n # Memoization dictionary to store results of subproblems\n memo = {}\n\n def count_ways(current_step: int) -> int:\n # Base case: reached the start\n if current_step == 0:\n return 1\n \n # Base case: stepped below the start\n if current_step < 0:\n return 0\n \n # Check if current_step is forbidden\n # A step is forbidden if it's a multiple of K and not the starting position (0)\n if current_step > 0 and current_step % K == 0:\n return 0\n \n # Check memoization table\n if current_step in memo:\n return memo[current_step]\n \n # Recursive step: try taking 1, 2, or 3 steps\n # We are working backwards from N to 0 to find ways to reach the current step\n # Or rather, we calculate the ways to reach 'current_step' by looking at previous valid steps.\n # The logic: ways(n) = ways(n-1) + ways(n-2) + ways(n-3)\n ways = (count_ways(current_step - 1) + \n count_ways(current_step - 2) + \n count_ways(current_step - 3))\n \n memo[current_step] = ways\n return ways\n\n # If N is 0, the traveler is already at the top.\n if N == 0:\n return 1\n \n # If the destination N itself is a multiple of K, it's impossible to land on it.\n if N % K == 0:\n return 0\n\n # We use an iterative approach to avoid recursion depth issues for very large N,\n # although the problem requested recursion and memoization.\n # To strictly follow the \"recursion and memoization\" instruction for a\n```"}]}
|
| {"language": "en", "category": "Recursive algorithms and memoization with functools.lru_cache", "messages": [{"role": "system", "content": "You are an expert AI software engineer. You analyze problems inside <think>...</think> tags before writing clean, robust code."}, {"role": "user", "content": "**Problem Statement: The Infinite Staircase of Primes**\n\nYou are tasked with finding the number of unique ways to climb a staircase of $N$ steps, where each step can be of any size $k$, provided that $k$ is a prime number. Because the staircase can be extremely tall, you must implement a recursive solution that utilizes `functools.lru_cache` to handle overlapping subproblems efficiently. Be careful to account for the behavior when $N$ is zero, negative, or a value smaller than the smallest prime number."}, {"role": "assistant", "content": "<think>\n* **Goal**: Find the number of ways to sum up to $N$ using only prime numbers.\n * **Constraints/Rules**:\n * Step size $k$ must be prime.\n * Order matters (e.g., if $N=5$, steps $[2, 3]$ and $[3, 2]$ are distinct ways).\n * Must use recursion with `functools.lru_cache`.\n * Handle $N=0$, $N < 0$, and $N < 2$.\n\n* **Algorithm**:\n * This is a variation of the \"Coin Change\" or \"Partition\" problem where order matters (Permutations).\n * Let $f(n)$ be the number of ways to reach step $n$.\n * Base Cases:\n * $f(0) = 1$ (One way to stay at the start: take no steps).\n * $f(n) = 0$ if $n < 0$.\n * Recursive Step:\n * $f(n) = \\sum_{p \\in \\text{Primes}, p \\le n} f(n - p)$\n * To make this efficient, we need a way to generate primes up to $N$. Since $N$ can be large (though limited by recursion depth in Python), a Sieve of Eratosthenes is appropriate.\n\n* **Edge Cases**:\n * $N = 0$: Return 1.\n * $N < 0$: Return 0.\n * $N = 1$: Return 0 (no primes $\\le 1$).\n * $N$ is very large: Python's recursion limit might be hit. I should mention this or increase it.\n\n* **Complexity Analysis**:\n * **Time Complexity**: $O(N \\cdot \\pi(N))$, where $\\pi(N)$ is the number of primes up to $N$. Roughly $O(N^2 / \\log N)$.\n * **Space Complexity**: $O(N)$ for the cache and the recursion stack.\n\n* **Implementation Details**:\n 1. Generate primes up to $N$ using a Sieve.\n 2. Define the recursive function `count_ways(n)`.\n 3. Apply `@lru_cache(None)`.\n 4. Wrap it in a main function to handle the sieve and the recursion.\n</think>\n\n```python\nimport functools\nimport sys\n\ndef solve_infinite_staircase(n: int) -> int:\n \"\"\"\n Calculates the number of unique ways to climb a staircase of N steps\n using only prime-sized steps.\n \n Args:\n n: The total number of steps in the staircase.\n \n Returns:\n The number of unique ways to reach step N.\n \"\"\"\n # Base Case: If N is negative, there are no ways to climb.\n if n < 0:\n return 0\n \n # Base Case: If N is 0, there is exactly 1 way (doing nothing).\n if n == 0:\n return 1\n\n # If N is 1, there are no primes <= 1, so 0 ways.\n if n < 2:\n return 0\n\n # Step 1: Generate all primes up to N using the Sieve of Eratosthenes.\n # This is more efficient than checking primality inside the recursion.\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 # Increase recursion depth for large N to prevent RecursionError.\n # Note: For extremely large N, an iterative DP approach would be safer.\n sys.setrecursionlimit(max(2000, n + 100))\n\n # Step 2: Define the recursive function with memoization.\n @functools.lru_cache(None)\n def count_ways(remaining: int) -> int:\n # Base case: successfully reached the top.\n if remaining == 0:\n return 1\n \n # Base case: exceeded the top.\n if remaining < 0:\n return 0\n \n ways = 0\n # Try every possible prime step size.\n for p in primes:\n if p > remaining:\n break # Primes are sorted; no need to check larger ones.\n ways += count_ways(remaining - p)\n \n return ways\n\n return count_ways(n)\n\nif __name__ == \"__main__\":\n # Test Case 1: N = 0 (Base case)\n print(f\"N=0: {solve_infinite_staircase(0)}\") # Expected: 1\n\n # Test Case 2: N = 1 (No primes available)\n print(f\"N=1: {solve_infinite_staircase(1)}\") # Expected: 0\n\n # Test Case 3: N = 5\n # Possible combinations: [2, 3], [3, 2], [5]\n # Expected: 3\n print(f\"N=5: {solve_infinite_staircase(5)}\") \n\n # Test Case 4: N = 10\n # Combinations: [2,2,2,2,2], [2,2,3,3], [2,3,2,3], [2,3,3,2], [3,2,2,3], \n # [3,2,3,2], [3,3,2,2], [2,2,2,2,2] is wrong, let's check logic:\n
|
| {"language": "en", "category": "Recursive algorithms and memoization with functools.lru_cache", "messages": [{"role": "system", "content": "You are an expert AI software engineer. You analyze problems inside <think>...</think> tags before writing clean, robust code."}, {"role": "user", "content": "Implement a function to calculate the number of unique paths in a multi-dimensional grid where certain cells are \"unstable\" and cannot be stepped on, but the grid dimensions can be extremely large while the number of unstable cells remains small. You must use `functools.lru_cache` to optimize the recursive exploration of valid paths, ensuring your solution handles cases where the grid boundaries are zero or where the starting and ending points are the same. Be careful to account for edge cases where the unstable cells form a complete blockade or where the grid dimensions are non-integer or negative."}, {"role": "assistant", "content": "<think>\n### Problem Analysis\nThe goal is to find the number of unique paths from a starting point $(x_s, y_s)$ to an ending point $(x_e, y_e)$ in a grid. We can only move in directions that reduce the distance to the target (typically \"Right\" and \"Down\" in a 2D grid, or positive increments in coordinates).\n\n**Key Constraints & Challenges:**\n1. **Large Grid Dimensions:** If the grid is $10^9 \\times 10^9$, a standard Dynamic Programming (DP) table or BFS/DFS will fail due to memory and time.\n2. **Small Number of Unstable Cells:** This is the hint. Instead of iterating through every cell, we should focus on the coordinates of the unstable cells.\n3. **Coordinate Geometry:** Since we are moving from $(x_s, y_s)$ to $(x_e, y_e)$, we assume movement is monotonic (e.g., only increasing $x$ and $y$). If the target is behind the start, paths = 0.\n4. **Combinatorics:** The number of paths from $(x_1, y_1)$ to $(x_2, y_2)$ without obstacles is $\\binom{(x_2-x_1) + (y_2-y_1)}{x_2-x_1}$.\n5. **Inclusion-Exclusion / DP on Obstacles:** Since the number of obstacles $K$ is small, we can use DP on the sorted list of obstacles.\n\n### Algorithm Design\n1. **Validation:** \n - Check if dimensions are integers and positive.\n - Check if start == end (return 1).\n - Check if start or end are unstable (return 0).\n - Check if end is \"behind\" start (return 0).\n2. **Coordinate Normalization:** \n - To simplify, let's assume we always move in the positive direction. If $x_e < x_s$ or $y_e < y_s$, return 0.\n3. **The \"Obstacle DP\" Approach:**\n - Let $O$ be the list of unstable cells that lie within the bounding box of start and end.\n - Add the target $(x_e, y_e)$ as the \"last\" obstacle in the list.\n - Sort $O$ primarily by $x$, secondarily by $y$.\n - Let $f(i)$ be the number of paths from the start to obstacle $i$ without hitting any *other* obstacles before $i$.\n - $f(i) = \\text{TotalPaths}(\\text{start} \\to \\text{obstacle}_i) - \\sum_{j < i, \\text{obstacle}_j \\text{ is before } i} (f(j) \\times \\text{TotalPaths}(\\text{obstacle}_j \\to \\text{obstacle}_i))$.\n - The result is $f(\\text{target})$.\n4. **Complexity:**\n - Sorting obstacles: $O(K \\log K)$.\n - DP: $O(K^2)$.\n - Combinations: $O(N)$ where $N$ is max coordinate, but we can use factorials for $O(1)$ after $O(N)$ precomputation. However, since dimensions are \"extremely large\", we cannot precompute factorials up to $10^9$. \n - **Correction:** If dimensions are extremely large, we cannot use the $O(K^2)$ combinatorial approach if we need to compute $\\binom{n}{k}$ where $n$ is $10^9$. Wait, the prompt asks for `functools.lru_cache` and \"recursive exploration\". This implies the grid isn't actually $10^9$ in a way that requires pure combinatorics, OR the prompt implies a sparse coordinate compression/recursive approach.\n - **Wait, re-reading:** \"use `functools.lru_cache` to optimize the recursive exploration\". This suggests a recursive approach with memoization. For a large grid with few obstacles, a pure recursion will hit recursion depth limits. But if we use the obstacles to jump, we can solve it.\n\n**Actually**, the standard way to solve \"Large Grid, Small Obstacles\" is the $O(K^2)$ DP mentioned above. But since the prompt specifically requests `lru_cache` and \"recursive exploration\", I will implement a recursive function that calculates paths between two points, subtracting paths that pass through obstacles.\n\n### Implementation Details\n- **Combinations Function:** Since $N$ is large, we use `math.comb`.\n- **Recursive Logic:** `count_paths(current_point, target, obstacles)`\n- **Edge Cases:** \n - `start == end`: return 1.\n - `start` or `end` in `unstable`: return 0.\n - `unstable` forms a blockade: The math will naturally return 0.\n - Non-integer/negative: Raise `ValueError`.\n\n### Complexity\n- **Time:** $O(K^2)$ where $K$ is the number of unstable cells.\n- **Space:** $O(K)$ for memoization.\n</think>\n\n```python\nimport math\nfrom functools import lru_cache\n\ndef solve_unique_paths(start, end, unstable_cells):\n \"\"\"\n Calculates the number of unique paths from start to end in a multi-dimensional grid\n avoiding unstable cells.\n \n Args:\n start (tuple): Starting coordinates (e.g., (0, 0)).\n end (tuple): Ending coordinates (e.g., (10, 10)).\n unstable_cells (set): A set of tuples representing blocked cells.\n \n Returns:\n int: Number of unique paths.\n \"\"\"\n \n # 1. Input Validation\n if not isinstance(start, tuple) or not isinstance(end, tuple):\n raise ValueError(\"Start and end must be tuples of coordinates.\")\n \n if any(not isinstance(c, int) or c < 0 for c in start) or \\\n any(not isinstance(c, int) or c < 0 for c in end):\n # Note: The prompt mentions grid dimensions can be large, \n # but coordinates must be non-negative integers for standard grid pathing.\n raise ValueError(\"Coordinates must be non-negative integers.\")\n\n # Check if dimensions/coordinates are valid integers\n for coord in list(start) + list(end):\n if not isinstance(coord, int):\n raise ValueError(\"Grid coordinates must be integers.\")\n\n # 2. Edge Case: Start or End is unstable\n if start in unstable_cells or end in unstable_cells:\n return 0\n\n #\n```"}]}
|
| {"language": "ru", "category": "Обработка строк, срезы, форматирование и модуль re", "messages": [{"role": "system", "content": "Ты продвинутый AI разработчик. Перед написанием кода ты анализируешь задачу внутри тегов <think>...</think>, затем пишешь чистый рабочий код."}, {"role": "user", "content": "Напишите функцию, которая извлекает из текста все упоминания номеров телефонов в форматах `+7XXXXXXXXXXX`, `8XXXXXXXXXXX` или `(XXX)XXX-XX-XX`. Программа должна игнорировать любые последовательности цифр, которые являются частью длинных серий (например, ID транзакций или дат), и корректно обрабатывать номера, разделенные пробелами или тире внутри скобок. Учтите случай, когда номер телефона «склеен» с текстом без пробела, но при этом содержит спецсимволы."}, {"role": "assistant", "content": "<think>\n**Анализ задачи:**\n\n1. **Цель:** Извлечь номера телефонов из текста по трем форматам:\n * `+7XXXXXXXXXXX` (11 цифр, начинается с +7)\n * `8XXXXXXXXXXX` (11 цифр, начинается с 8)\n * `(XXX)XXX-XX-XX` (с скобками, тире или пробелами)\n2. **Условия и ограничения:**\n * Игнорировать длинные последовательности цифр (ID, даты). Это означает, что номер не должен быть частью более длинной строки цифр (используем границы слов или проверку на соседние цифры).\n * Обработка разделителей: внутри скобок могут быть пробелы или тире.\n * \"Склеенный\" текст: номер может идти сразу после буквы или перед ней, но спецсимволы (скобки, +, тире) помогают нам выделить его.\n * Важно: Номер не должен быть частью `1234567890123456` (ID).\n\n3. **Алгоритм (Regex подход):**\n * Для форматов `+7...` и `8...`:\n * Ищем `+7` или `8`.\n * Затем ровно 10 цифр.\n * **Важно:** Чтобы не захватить ID, используем \"negative lookbehind\" и \"negative lookahead\" для проверки, что до и после номера нет других цифр.\n * Для формата `(XXX)XXX-XX-XX`:\n * Ищем `\\(\\d{3}\\)`.\n * Затем разделитель (пробел, тире или ничего).\n * Затем 3 цифры, разделитель, 2 цифры, разделитель, 2 цифры.\n * Объединение: Используем `re.findall` с объединением паттернов через `|`.\n\n4. **Краевые случаи:**\n * `ID: 123456789012345` -> не должен быть найден.\n * `Тел:+79991234567` -> должен быть найден.\n * `(999) 123-45-67` -> должен быть найден.\n * `89991234567` -> должен быть найден.\n * `12345678901234567890` -> не должен быть найден.\n\n5. **Сложность:**\n * Временная сложность: $O(N)$, где $N$ — длина текста (проход по тексту регулярным выражением).\n * Пространственная сложность: $O(M)$, где $M$ — количество найденных совпадений.\n</think>\n\n```python\nimport re\n\ndef extract_phone_numbers(text: str) -> list:\n \"\"\"\n Извлекает номера телефонов из текста по заданным форматам:\n +7XXXXXXXXXXX, 8XXXXXXXXXXX, (XXX)XXX-XX-XX\n Игнорирует длинные последовательности цифр.\n \"\"\"\n \n
|
| {"language": "ru", "category": "Работа с файлами, чтение и запись JSON, CSV, модуль pathlib", "messages": [{"role": "system", "content": "Ты продвинутый AI разработчик. Перед написанием кода ты анализируешь задачу внутри тегов <think>...</think>, затем пишешь чистый рабочий код."}, {"role": "user", "content": "Напишите программу, которая сканирует директорию с помощью `pathlib`, собирает данные о файлах (имя, размер, расширение) и сохраняет их в CSV, а затем переносит эти же данные в JSON-файл. Подвох заключается в том, что программа должна корректно обрабатывать ситуацию, когда в папке встречаются файлы без расширений, а также не должна пытаться записывать JSON и CSV файлы в сами себя, если они уже существуют в этой директории."}, {"role": "assistant", "content": "<think>\n1. **Анализ задачи**:\n * **Цель**: Сканирование директории, сбор метаданных (имя, размер, расширение) и сохранение в два формата (CSV и JSON).\n * **Инструментарий**: `pathlib` для работы с путями, `csv` для CSV, `json` для JSON.\n * **Особые условия (подвохи)**:\n * Файлы без расширений: `pathlib.Path.suffix` вернет пустую строку `\"\"`. Это нужно учитывать.\n * Самоисключение: Программа не должна включать в отчет файлы `.csv` и `.json`, которые она создает (чтобы избежать бесконечного разрастания данных при повторных запусках).\n * **Алгоритм**:\n 1. Определить целевую директорию (по умолчанию текущая).\n 2. Инициализировать список для хранения данных.\n 3. Итерироваться по всем объектам в директории через `pathlib.Path.iterdir()`.\n 4. Для каждого объекта проверить:\n * Является ли он файлом (`is_file()`).\n * Не является ли он одним из выходных файлов (`.csv` или `.json`).\n 5. Если проходит проверки, извлечь:\n * `name`: имя файла.\n * `size`: размер в байтах.\n * `extension`: расширение (обработка пустого случая).\n 6. Записать список словарей в CSV.\n 7. Записать список словарей в JSON.\n\n2. **Краевые случаи**:\n * Пустая директория: Программа должна создать пустые файлы или файлы с заголовками, не падая с ошибкой.\n * Файлы без расширений: `suffix` вернет `''`, что корректно.\n * Спецсимволы в именах: `pathlib` и стандартные библиотеки `csv`/`json` справляются с этим.\n * Доступ к файлам: Если файл защищен, может возникнуть `PermissionError` (добавим базовую обработку).\n\n3. **Сложность**:\n * **Временная сложность**: $O(N)$, где $N$ — количество файлов в директории. Мы проходим по списку файлов один раз.\n * **Пространственная сложность**: $O(N)$ для хранения метаданных в памяти перед записью.\n\n4. **Структура данных**:\n * Список словарей: `[{'name': 'file.txt', 'size': 123, 'extension': '.txt'}, ...]`\n</think>\n\n```python\nimport csv\nimport json\nfrom pathlib import Path\n\ndef scan_directory_to_files(target_dir: str, csv_filename: str, json_filename: str):\n \"\"\"\n Сканирует директорию, собирает данные о файлах и сохраняет их в CSV и JSON.\n \n :param target_dir: Путь к директории для сканирования.\n :param csv_filename: Имя выходного CSV файла.\n :param json_filename: Имя выходного JSON файла.\n \"\"\"\n base_path = Path(target_dir)\n \n if not base_path.exists() or not base_path.is_dir():\n print(f\"Ошибка: Директория '{target_dir}' не найдена или не является папкой.\")\n return\n\n # Определяем пути выходных файлов, чтобы исключить их из сканирования\n csv_path = base_path / csv_filename\n json_path = base_path / json_filename\n \n # Множество расширений, которые мы хотим игнорировать (сами файлы отчетов)\n # Мы проверяем полное имя файла, чтобы не пропустить файлы типа 'data.csv.bak'\n excluded_files = {csv_path.name, json_path.name}\n\n file_data_list = []\n\n print(f\"Начинаю сканирование директории: {base_path.absolute()}\")\n\n # 1. Сбор данных\n try:\n for item in base_path.iterdir():\n # Проверяем: это файл, и это не наш собственный отчет\n if item.is_file() and item.name not in excluded_files:\n \n # Получаем расширение. Если его нет, pathlib вернет пустую строку.\n extension = item.suffix if item.suffix else \"no extension\"\n \n file_info = {\n \"name\": item.name,\n \"size_bytes\": item.stat().st_size,\n \"extension\": extension\n }\n file_data_list.append(file_info)\n \n except PermissionError as e:\n print(f\"Ошибка доступа к файлам: {e}\")\n except Exception as e:\n print(f\"Произошла непредвиденная ошибка при сканировании: {e}\")\n return\n\n if not file_data_list:\n print(\"Файлы для записи не найдены (или директория пуста).\")\n # Все равно создадим пустые файлы с заголовками, чтобы соблюсти логику\n file_data_list = []\n\n # 2. Запись в CSV\n try:\n with open(csv_path, mode='w', newline='', encoding='utf-8') as csv_file:\n fieldnames = ['name', 'size_bytes', 'extension']\n writer = csv.DictWriter(csv_file, fieldnames=fieldnames)\n \n writer.writeheader()\n writer.writerows(file_data_list)\n print(f\"Данные успешно сохранены в CSV: {csv_path.name}\")\n except Exception as e:\n print(f\"Ошибка при записи CSV: {e}\")\n\n # 3. Запись в JSON\n try:\n with open(json_path, mode='w', encoding='utf-8') as json_file:\n json.dump(file_data_list, json_file, indent=4, ensure_ascii=False)\n print(f\"Данные успешно сохранены в JSON: {json_path.name}\")\n except Exception as e:\n print(f\"Ошибка при записи JSON: {e}\")\n\n print(f\"Итого обработано файлов: {len(file_data_list)}\")\n```"}]}
|
| {"language": "ru", "category": "Генераторы списков, выражения-генераторы, yield, itertools", "messages": [{"role": "system", "content": "Ты продвинутый AI разработчик. Перед написанием кода ты анализируешь задачу внутри тегов <think>...</think>, затем пишешь чистый рабочий код."}, {"role": "user", "content": "Напишите функцию, которая принимает последовательность чисел и возвращает генератор, содержащий только уникальные элементы, сохраненные в исходном порядке. Подвох заключается в том, что при использовании стандартного набора инструментов (например, `set`) порядок элементов будет нарушен, а при попытке оптимизировать память через `itertools` важно не «исчерпать» исходный генератор раньше времени. Учтите, что входные данные могут быть бесконечным потоком, поэтому решение не должно преобразовывать их в список."}, {"role": "assistant", "content": "<think>\n**Анализ задачи:**\n\n1. **Цель:** Создать генератор, который фильтрует дубликаты, сохраняя порядок первого появления каждого элемента.\n2. **Ограничения:**\n * **Память:** Нельзя преобразовывать входной поток в список (это может быть бесконечный поток).\n * **Порядок:** Использование `set()` для фильтрации допустимо для отслеживания *уже встреченных* элементов, но нельзя возвращать сам `set`, так как он не гарантирует порядок.\n * **Поток:** Решение должно работать лениво (lazy evaluation).\n3. **Алгоритм:**\n * Инициализировать пустое множество `seen` для хранения уникальных элементов, которые мы уже встретили. Множество обеспечивает поиск за $O(1)$ в среднем.\n * Итерироваться по входной последовательности (итератору) один элемент за раз.\n * Для каждого элемента проверить, содержится ли он в `seen`.\n * Если элемента нет в `seen`:\n * Добавить его в `seen`.\n * Использовать `yield`, чтобы отдать элемент.\n * Если элемент есть в `seen`, просто пропускаем его.\n4. **Краевые случаи:**\n * Пустой входной поток: генератор должен завершиться сразу.\n * Бесконечный поток: генератор должен работать бесконечно, выдавая новые уникальные элементы по мере их поступления.\n * Типы данных: элементы должны быть *hashable* (хешируемыми), чтобы их можно было добавить в `set`. Если на вход подаются списки (unhashable), решение потребует изменения логики (но по умолчанию в Python задачи на уникальность подразумевают хешируемые типы).\n5. **Сложность:**\n * **Временная сложность:** $O(n)$, где $n$ — количество элементов во входном потоке. Каждая проверка и вставка в `set` занимает $O(1)$ в среднем.\n * **Пространственная сложность:** $O(k)$, где $k$ — количество *уникальных* элементов. Это минимально возможная сложность, так как нам необходимо помнить, что мы уже видели, чтобы не дублировать.\n\n**Реализация:**\nИспользование `yield` делает функцию генератором, что удовлетворяет требованию ленивых вычислений.\n</think>\n\n```python\nfrom typing import Iterable, Generator, Any, Set\n\ndef unique_elements_ordered(sequence: Iterable[Any]) -> Generator[Any, None, None]:\n \"\"\"\n Генератор, который возвращает только уникальные элементы из входной последовательности,\n сохраняя порядок их первого появления.\n \n Подходит для бесконечных потоков данных.\n \n Args:\n sequence: Итерируемый объект (список, кортеж, другой генератор и т.д.)\n \n Yields:\n Уникальные элементы в порядке их первого появления.\n \"\"\"\n
|
| {"language": "en", "category": "Exception handling with try-except and custom Exceptions", "messages": [{"role": "system", "content": "You are an expert AI software engineer. You analyze problems inside <think>...</think> tags before writing clean, robust code."}, {"role": "user", "content": "Design a banking transaction system that processes a list of withdrawal requests, where you must implement a custom `InsufficientFundsError` and a `FrozenAccountError`. The system must handle a mix of valid transactions, accounts with zero balances, accounts flagged as frozen, and malformed input data (such as non-numeric amounts or negative values). Your logic must ensure that a single failed transaction due to a custom exception does not halt the entire batch, but invalid data types must be caught and logged separately without crashing the program."}, {"role": "assistant", "content": "<think>\n### Problem Breakdown\n\n**1. Core Requirements:**\n* **Custom Exceptions:**\n * `InsufficientFundsError`: Raised when a withdrawal amount exceeds the current balance.\n * `FrozenAccountError`: Raised when an account is flagged as `is_frozen`.\n* **Input Handling:**\n * Valid transactions (success).\n * Zero balance accounts (fail with `InsufficientFundsError`).\n * Frozen accounts (fail with `FrozenAccountError`).\n * Malformed data (non-numeric amounts, negative amounts, or missing keys).\n* **Fault Tolerance:**\n * A failed business logic transaction (custom exception) must not stop the loop.\n * Malformed data (TypeErrors/ValueErrors) must be caught and logged separately without crashing the loop.\n* **Output:**\n * A summary of successful transactions, failed business transactions (with reasons), and malformed inputs.\n\n**2. Algorithm Design:**\n1. Define a `Bank` class to store account states (balance and frozen status).\n2. Define the two custom exception classes inheriting from `Exception`.\n3. Create a `TransactionProcessor` class.\n4. The `process_batch` method will iterate through a list of dictionaries.\n5. **Inside the loop (Try-Except block strategy):**\n * **Level 1 (Data Validation):** Check if the input is a dictionary, if `account_id` exists, and if `amount` is a valid positive number. If not, catch `TypeError`/`ValueError` and log as \"Malformed\".\n * **Level 2 (Business Logic):** Check if the account exists, if it is frozen, and if funds are sufficient. If a custom exception is raised, catch it and log as \"Failed\".\n * **Level 3 (Success):** If both levels pass, update the balance and log as \"Success\".\n\n**3. Complexity Analysis:**\n* **Time Complexity:** $O(N)$, where $N$ is the number of transaction requests. We iterate through the list exactly once. Dictionary lookups for accounts are $O(1)$ on average.\n* **Space Complexity:** $O(A + N)$, where $A$ is the number of accounts stored in the bank and $N$ is the size of the results list.\n\n**4. Edge Cases:**\n* `amount` is a string like `\"100\"`: Should be handled (attempt conversion) or caught as malformed if we strictly require numeric types. I will implement strict type checking to satisfy the \"malformed input\" requirement.\n* `amount` is negative: Should be treated as malformed/invalid.\n* `account_id` does not exist in the bank: Should be treated as a business error.\n* Empty transaction list: Should return empty results.\n</think>\n\n```python\nfrom typing import List, Dict, Any, Union\n\n# --- Custom Exceptions ---\n\nclass InsufficientFundsError(Exception):\n \"\"\"Raised when the account balance is less than the requested withdrawal amount.\"\"\"\n pass\n\nclass FrozenAccountError(Exception):\n \"\"\"Raised when an attempt is made to withdraw from a frozen account.\"\"\"\n pass\n\n# --- Core System ---\n\nclass Bank:\n def __init__(self, accounts: Dict[str, Dict[str, Any]]):\n \"\"\"\n Initializes the bank with account data.\n :param accounts: Dictionary mapping account_id to {'balance': float, 'is_frozen': bool}\n \"\"\"\n self.accounts = accounts\n\n def get_account(self, account_id: str):\n return self.accounts.get(account_id)\n\n def withdraw(self, account_id: str, amount: float):\n account = self.get_account(account_id)\n \n if not account:\n raise KeyError(f\"Account {account_id} not found.\")\n \n if account['is_frozen']:\n raise FrozenAccountError(f\"Account {account_id} is frozen.\")\n \n if account['balance'] < amount:\n raise InsufficientFundsError(\n f\"Insufficient funds. Available: {account['balance']}, Requested: {amount}\"\n )\n \n account['balance'] -= amount\n return account['balance']\n\n\nclass TransactionProcessor:\n def __init__(self, bank: Bank):\n self.bank = bank\n\n def process_batch(self, transactions: List[Dict[str, Any]]) -> Dict[str, List[str]]:\n \"\"\"\n Processes a list of withdrawal requests.\n Returns a summary of successes, business failures, and malformed inputs.\n \"\"\"\n results = {\n \"success\": [],\n \"failed_transaction\": [],\n \"malformed_input\": []\n }\n\n for idx, txn in enumerate(transactions):\n try:\n # 1. Data Validation (Malformed Input Check)\n # We check types and structure before attempting business logic\n if not isinstance(txn, dict):\n raise TypeError(\"Transaction must be a dictionary.\")\n \n if 'account_id' not in txn or 'amount' not in txn:\n raise KeyError(\"Missing required fields: 'account_id' or 'amount'.\")\n\n account_id = txn['account_id']\n amount = txn['amount']\n\n # Strict type checking for amount\n if not isinstance(amount, (int, float)):\n raise TypeError(f\"Amount must be numeric, got {type(amount).__name__}.\")\n \n if amount <= 0:\n raise ValueError(f\"Amount must be positive, got {amount}.\")\n\n # 2. Business Logic (Custom Exception Check)\n try:\n new_balance = self.bank.withdraw(account_id, float(amount))\n results[\"success\"].append(\n f\"Txn {idx}: Account {account_id} withdrawn {amount}. New balance: {new_balance}\"\n )\n except (InsufficientFundsError, FrozenAccountError, KeyError) as e:\n results[\"failed_transaction\"].append(f\"Txn {idx}: {str(e)}\")\n\n except (TypeError, ValueError, KeyError) as e:\n # Catching malformed data specifically\n results[\"malformed_input\"].append(f\"Txn {idx}: {str(e)}\")\n except Exception as e:\n # Catch-all for unexpected system crashes to ensure the loop continues\n results[\"malformed_input\"].append(f\"Txn {idx}: Unexpected error: {str(e)}\")\n\n return results\n\n\n# --- Execution and Testing ---\n```"}]}
|
| {"language": "en", "category": "File I/O, JSON, CSV parsing, and pathlib operations", "messages": [{"role": "system", "content": "You are an expert AI software engineer. You analyze problems inside <think>...</think> tags before writing clean, robust code."}, {"role": "user", "content": "Design a data synchronization tool that scans a directory for multiple `.json` and `.csv` files, merges their contents into a single consolidated `.json` report, and handles file system pathing using `pathlib`. The script must account for inconsistent header naming between CSV files, handle nested JSON structures, and resolve conflicts when duplicate primary keys exist across different file formats. You must ensure the process gracefully skips malformed files or directories without crashing, while logging any skipped paths to a separate error file."}, {"role": "assistant", "content": "<think>\n
|
| {"language": "en", "category": "Recursive algorithms and memoization with functools.lru_cache", "messages": [{"role": "system", "content": "You are an expert AI software engineer. You analyze problems inside <think>...</think> tags before writing clean, robust code."}, {"role": "user", "content": "**Problem Statement: The Galactic Path Optimizer**\n\nA space explorer must navigate a grid of planetary systems to reach a destination, where each move costs energy based on the planet's coordinates. Given a grid of energy values, find the minimum energy required to travel from the top-left corner to the bottom-right corner, moving only right or down. Your solution must use recursion with memoization via `functools.lru_cache` and correctly handle grids that are single rows, single columns, or contain zero-energy planets."}, {"role": "assistant", "content": "<think>\n**Problem Analysis:**\nThe problem is a classic variation of the \"Minimum Path Sum\" problem. We need to find a path from $(0, 0)$ to $(m-1, n-1)$ in a grid such that the sum of the values along the path is minimized. The allowed moves are only \"Right\" and \"Down\".\n\n**Algorithm:**\nWe use a top-down Dynamic Programming approach (recursion with memoization).\n1. **Base Case:** If we reach the destination $(m-1, n-1)$, the cost is simply the value at that cell.\n2. **Recursive Step:** From cell $(r, c)$, we have two choices:\n * Move Down: $(r+1, c)$\n * Move Right: $(r, c+1)$\n3. **Transition Formula:** \n $f(r, c) = \\text{grid}[r][c] + \\min(f(r+1, c), f(r, c+1))$\n4. **Boundary Conditions:**\n * If $r \\ge m$ or $c \\ge n$, we have moved out of bounds. We should return infinity to ensure this path is never chosen by the `min()` function.\n\n**Edge Cases to Handle:**\n* **Single Row:** Only \"Right\" moves are possible.\n* **Single Column:** Only \"Down\" moves are possible.\n* **Zero-energy planets:** The values can be 0, so the algorithm must handle non-negative integers correctly.\n* **Empty Grid:** Though not explicitly mentioned, we should ensure the grid is valid.\n\n**Complexity Analysis:**\n* **Time Complexity:** $O(M \\times N)$, where $M$ is the number of rows and $N$ is the number of columns. Each cell is visited exactly once due to memoization.\n* **Space Complexity:** $O(M \\times N)$ for the memoization table (handled by `lru_cache`) plus $O(M + N)$ for the recursion stack.\n\n**Implementation Details:**\n* Use `functools.lru_cache(None)` to implement memoization.\n* Use `float('inf')` for out-of-bounds return values.\n</think>\n\n```python\nimport functools\n\nclass GalacticPathOptimizer:\n \"\"\"\n A class to find the minimum energy path in a grid of planetary systems.\n \"\"\"\n\n def min_energy_path(self, grid: list[list[int]]) -> int:\n \"\"\"\n Finds the minimum energy required to travel from top-left to bottom-right.\n \n Args:\n grid: A 2D list of integers representing energy costs.\n \n Returns:\n The minimum energy required for the path.\n \"\"\"\n if not grid or not grid[0]:\n return 0\n\n rows = len(grid)\n cols = len(grid[0])\n\n @functools.lru_cache(None)\n def solve(r: int, c: int) -> float:\n \"\"\"\n Recursive helper function with memoization.\n \n Args:\n r: Current row index.\n c: Current column index.\n \n Returns:\n Minimum energy required to reach the destination from (r, c).\n \"\"\"\n # Base Case: Reached the destination\n if r == rows - 1 and c == cols - 1:\n return grid[r][c]\n\n # Out of bounds: Return infinity so this path is not chosen\n if r >= rows or c >= cols:\n return float('inf')\n\n # Recursive Step: Move Down or Move Right\n move_down = solve(r + 1, c)\n move_right = solve(r, c + 1)\n\n return grid[r][c] + min(move_down, move_right)\n\n # The result of the recursive function might be a float due to inf, \n # but since the input is integers, the result will be an integer.\n result = solve(0, 0)\n return int(result)\n\n# --- Test Cases ---\nif __name__ == \"__main__\":\n optimizer = GalacticPathOptimizer()\n\n # Test Case 1: Standard Grid\n grid1 = [\n [1, 3, 1],\n [1, 5, 1],\n [4, 2, 1]\n ]\n # Path: 1 -> 3 -> 1 -> 1 -> 1 (Total: 7) or 1 -> 1 -> 4 -> 2 -> 1 (Total: 9)\n # Min Path: 1+3+1+1+1 = 7\n print(f\"Test 1 Result: {optimizer.min_energy_path(grid1)} (Expected: 7)\")\n\n # Test Case 2: Single Row\n grid2 = [[1, 2, 3, 4]]\n print(f\"Test 2 Result: {optimizer.min_energy_path(grid2)} (Expected: 10)\")\n\n # Test Case 3: Single Column\n grid3 = [[1], [2], [3], [4]]\n print(f\"Test 3 Result: {optimizer.min_energy_path(grid3)} (Expected: 10)\")\n\n # Test Case 4: Grid with Zero-Energy Planets\n grid4 = [\n [0, 0, 0],\n [0, 5, 0],\n [0, 0, 0]\n ]\n print(f\"Test 4 Result: {optimizer.min_energy_path(grid4)} (Expected: 0)\")\n\n # Test Case 5: 2x2 Grid\n grid5 = [[1, 10], [1, 1]]\n print(f\"Test 5 Result: {optimizer.min_energy_path(grid5)} (Expected: 3)\")\n```"}]}
|
| {"language": "ru", "category": "Генераторы списков, выражения-генераторы, yield, itertools", "messages": [{"role": "system", "content": "Ты продвинутый AI разработчик. Перед написанием кода ты анализируешь задачу внутри тегов <think>...</think>, затем пишешь чистый рабочий код."}, {"role": "user", "content": "Напишите функцию, которая с помощью генератора принимает последовательность целых чисел и возвращает только те элементы, которые являются «чистыми» (не содержат повторяющихся цифр внутри себя). Алгоритм должен эффективно обрабатывать бесконечный поток чисел, используя `itertools` и `yield`, и корректно обрабатывать отрицательные числа и числа с нулями. Подвох заключается в том, что проверка на уникальность цифр не должна приводить к чрезмерному потреблению памяти при работе с итератором."}, {"role": "assistant", "content": "<think>\n**Анализ задачи:**\n\n1. **Цель:** Написать генератор, который фильтрует поток целых чисел, оставляя только те, у которых все цифры уникальны (\"чистые\" числа).\n2. **Требования:**\n * Использование `itertools` для работы с потоком.\n * Использование `yield` (генераторная функция).\n * Поддержка отрицательных чисел (знак не влияет на уникальность цифр, но его нужно учитывать при преобразовании в строку/набор цифр).\n * Поддержка нулей.\n * Эффективность памяти: проверка уникальности цифр должна быть локальной для каждого числа. Поскольку количество цифр в стандартном `int` ограничено (даже в Python, где `int` произвольной точности, количество цифр растет логарифмически), использование `set` для проверки внутри одного числа не приведет к взрывному росту памяти.\n3. **Алгоритм проверки \"чистоты\":**\n * Взять число.\n * Преобразовать его в абсолютное значение (чтобы минус не считался символом).\n * Преобразовать в строку или извлекать цифры математически.\n * Сравнить количество уникальных цифр с общим количеством цифр.\n * Если `len(set(digits)) == len(digits)`, число \"чистое\".\n4. **Краевые случаи:**\n * `0`: Чистое число.\n * `-123`: Чистое число.\n * `11`: Не чистое.\n * `101`: Не чистое.\n * `102`: Чистое.\n * Очень большие числа: Python поддерживает длинную арифметику, поэтому алгоритм должен работать.\n5. **Сложность:**\n * **Временная сложность:** $O(N \\cdot D)$, где $N$ — количество чисел в потоке, $D$ — количество цифр в числе. Так как $D \\approx \\log_{10}(X)$, это крайне эффективно.\n * **Пространственная сложность:** $O(D)$ для хранения набора цифр текущего числа. Это константа относительно размера входного потока, что удовлетворяет условию \"не приводить к чрезмерному потреблению памяти\".\n\n**Реализация:**\nИспользуем `itertools.islice` для демонстрации работы с \"бесконечным\" потоком (чтобы не зациклиться при тесте) и `yield` внутри функции-фильтра.\n</think>\n\n```python\nimport itertools\n\ndef get_pure_numbers(numbers_iterator):\n \"\"\"\n Генератор, который принимает итератор целых чисел и выдает только те,\n которые не содержат повторяющихся цифр.\n \"\"\"\n for num in numbers_iterator:\n
|
| {"language": "ru", "category": "Словари и множества (dict, set, Counter, defaultdict)", "messages": [{"role": "system", "content": "Ты продвинутый AI разработчик. Перед написанием кода ты анализируешь задачу внутри тегов <think>...</think>, затем пишешь чистый рабочий код."}, {"role": "user", "content": "Дан список ID пользователей и время их активности, где некоторые ID могут дублироваться. Необходимо найти количество уникальных пользователей, которые проявляли активность более одного раза, но при этом исключить тех, чьи ID входят в «черный список» (отдельный набор). Подвох заключается в том, что при использовании `Counter` или `set` нужно корректно обработать ситуацию, когда пользователь из черного списка имеет ровно один вход (он не должен попасть в результат), а если у него несколько входов — он всё равно не должен учитываться."}, {"role": "assistant", "content": "<think>\n1. **Анализ задачи**:\n * **Входные данные**: Список кортежей `(user_id, timestamp)` или два параллельных списка (ID и время). Будем считать, что на вход подается список `activities`, где каждый элемент — это `user_id`.\n * **Цель**: Найти количество уникальных пользователей, которые встречаются в списке **более одного раза**, исключая при этом всех пользователей, чьи ID находятся в `blacklist`.\n * **Условие исключения**: Если пользователь в черном списке, он не должен попасть в результат, независимо от того, сколько раз он проявил активность (1 или более).\n\n2. **Алгоритм**:\n * Создать фильтрованный список или генератор, который пропускает только те `user_id`, которых нет в `blacklist`.\n * Подсчитать частоту вхождений каждого `user_id` в этом отфильтрованном наборе.\n * Использовать `collections.Counter` для подсчета.\n * Пройти по результатам подсчета и выбрать только те ID, у которых `count > 1`.\n * Вернуть количество таких ID.\n\n3. **Краевые случаи**:\n * `blacklist` пуст: должны считаться все пользователи с частотой > 1.\n * Все пользователи в `blacklist`: результат 0.\n * Пользователь в `blacklist` имеет 1 активность: он не должен учитываться (уже исключен фильтрацией).\n * Пользователь в `blacklist` имеет 5 активностей: он не должен учитываться (уже исключен фильтрацией).\n * Список активностей пуст: результат 0.\n\n4. **Сложность**:\n * **Временная сложность**: $O(N)$, где $N$ — количество записей в списке активностей. Мы проходим по списку один раз для фильтрации и один раз по словарю счетчика. Поиск в `set` (черный список) занимает $O(1)$.\n * **Пространственная сложность**: $O(U)$, где $U$ — количество уникальных пользователей, для хранения словаря частот.\n\n5. **Реализация**:\n * Использование `set` для `blacklist` критически важно для обеспечения $O(1)$ поиска.\n</think>\n\n```python\nfrom collections import Counter\nfrom typing import List, Set, Tuple, Any\n\ndef count_frequent_active_users(activities: List[Any], blacklist: Set[Any]) -> int:\n \"\"\"\n Находит количество уникальных пользователей, которые проявляли активность \n более одного раза, исключая пользователей из черного списка.\n\n Args:\n activities: Список ID пользователей (или кортежей (user_id, timestamp)).\n Если передаются кортежи, функция извлечет первый элемент.\n blacklist: Множество (set) ID пользователей, которых нужно игнорировать.\n\n Returns:\n int: Количество пользователей с частотой активности > 1, не входящих в blacklist.\n \"\"\"\n \n # 1. Превращаем blacklist в set, если это еще не так, для O(1) поиска.\n # Это важно для производительности при больших данных.\n blacklist_set = set(blacklist)\n \n # 2. Фильтруем активности: оставляем только тех, кого нет в черном списке.\n # Если в activities лежат кортежи (user_id, timestamp), берем только user_id.\n # Если лежат просто ID, берем сам элемент.\n def extract_id(item):\n return item[0] if isinstance(item, tuple) else item\n\n # Используем генераторное выражение для эффективной фильтрации\n filtered_ids = (extract_id(act) for act in activities if extract_id(act) not in blacklist_set)\n \n # 3. Считаем частоту каждого ID в отфильтрованном списке\n counts = Counter(filtered_ids)\n \n # 4. Считаем только тех, у кого количество вхождений > 1\n frequent_users_count = sum(1 for user_id in counts if counts[user_id] > 1)\n \n return frequent_users_count\n\n# --- Тестирование ---\n\ndef test_solution():\n # Тест 1: Стандартная ситуация\n # User 1: 3 раза (OK)\n # User 2: 2 раза (OK)\n # User 3: 1 раз (Не подходит, < 2)\n # User 4: 5 раз (В черном списке, ИГНОРИРУЕМ)\n # User 5: 2 раза (В черном списке, ИГНОРИРУЕМ)\n activities = [1, 1, 1, 2, 2, 3, 4, 4, 4, 4, 4, 5, 5]\n blacklist = {4, 5}\n assert count_frequent_active_users(activities, blacklist) == 2, \"Test 1 Failed\"\n\n # Тест 2: Работа с кортежами (ID, Timestamp)\n activities_tuples = [(10, \"10:00\"), (10, \"10:05\"), (20, \"11:00\"), (30, \"12:00\"), (30, \"12:05\")]\n blacklist_tuples = {20}\n # Ожидаем: User 10 (2 входа), User 30 (2 входа). User 20 в БЛ.\n assert count_frequent_active_users(activities_tuples, blacklist_tuples) == 2, \"Test 2 Failed\"\n\n # Тест 3: Черный список содержит пользователя с одной активностью\n # User 1: 2 раза (OK)\n # User 2: 1 раз (В черном списке, ИГНОРИРУЕМ)\n activities_3 = [1, 1, 2]\n blacklist_3 = {2}\n assert count_frequent_active_users(activities_3, blacklist_3) == 1, \"Test 3 Failed\"\n\n # Тест 4: Пустой список\n assert count_frequent_active_users([], {1, 2, 3}) == 0, \"Test 4 Failed\"\n\n # Тест 5: Все в черном списке\n```"}]}
|
| {"language": "ru", "category": "ООП: классы, наследование, dunder-методы (__repr__, __add__)", "messages": [{"role": "system", "content": "Ты продвинутый AI разработчик. Перед написанием кода ты анализируешь задачу внутри тегов <think>...</think>, затем пишешь чистый рабочий код."}, {"role": "user", "content": "Создайте класс `Vector`, представляющий точку в пространстве, где переопределен метод `__add__` для сложения векторов и `__repr__` для строкового представления. Подвох заключается в том, что при попытке сложения объекта `Vector` с другим объектом того же класса, результат должен быть новым экземпляром `Vector`, но при сложении с числом (int) — возвращать `float` или `int`. Реализуйте логику так, чтобы метод `__add__` корректно обрабатывал неявное приведение типов, не вызывая ошибку `TypeError` при смешанных операциях."}, {"role": "assistant", "content": "<think>\nАлгоритм решения задачи:\n1. **Класс `Vector`**:\n * Инициализация: принимает координаты (в данном случае для 2D или 3D, сделаем универсальным через `*args` или фиксированным списком). Для простоты возьмем 2D (x, y).\n * Метод `__add__`:\n * Проверяем тип операнда (`other`).\n * Если `other` — экземпляр `Vector`: возвращаем новый объект `Vector` с суммами соответствующих координат.\n * Если `other` — `int` или `float`: возвращаем результат сложения текущих координат с числом. Однако, так как вектор — это точка/объект, а не число, классическое сложение вектора с числом математически не определено (обычно умножают на число). Но по условию задачи: \"результат должен быть `float` или `int`\". Это значит, что если мы складываем `Vector(1, 2) + 5`, мы должны вернуть, например, сумму координат или как-то интерпретировать это. \n * *Уточнение логики по условию:* В условии сказано: \"при сложении с числом — возвращать `float` или `int`\". Это специфическое требование. Чтобы это работало корректно, нам нужно решить, какое именно число возвращать. Логично предположить, что если мы складываем вектор с числом, мы возвращаем сумму всех его компонентов плюс это число, либо (что более вероятно в контексте \"неявного приведения\") мы должны обрабатывать это так, чтобы не падала ошибка.\n * *Правильный подход к условию:* Если `other` — число, метод `__add__` должен вернуть число. Чтобы это выглядело логично, вернем сумму координат вектора + число.\n\n2. **Краевые случаи**:\n * Сложение `Vector` с `Vector` (разной размерности) — стоит добавить проверку.\n * Сложение `Vector` с `None` или другими типами — должны вызывать `TypeError` (стандартное поведение).\n * Сложение `Vector` с `float`.\n\n3. **Сложность**:\n * Временная сложность: $O(N)$, где $N$ — количество координат.\n * Пространственная сложность: $O(N)$ для создания нового объекта.\n\n4. **Реализация**:\n * Используем `isinstance` для проверки типов.\n * Используем `zip` для итерации по координатам.\n</think>\n\n```python\nclass Vector:\n \"\"\"\n Класс, представляющий вектор (точку) в пространстве.\n \"\"\"\n\n def __init__(self, *coords):\n \"\"\"\n Инициализация вектора координатами.\n :param coords: произвольное количество аргументов, представляющих координаты (x, y, z...).\n \"\"\"\n self.coords = tuple(coords)\n\n def __add__(self, other):\n \"\"\"\n Переопределенный метод сложения.\n Логика:\n 1. Если other - Vector, возвращает новый Vector (сумма координат).\n 2. Если other - число (int/float), возвращает сумму координат + число.\n 3. В остальных случаях вызывает TypeError.\n \"\"\"\n
|
| {"language": "en", "category": "Exception handling with try-except and custom Exceptions", "messages": [{"role": "system", "content": "You are an expert AI software engineer. You analyze problems inside <think>...</think> tags before writing clean, robust code."}, {"role": "user", "content": "Design a robust transaction processing system that must validate a series of financial operations against a strict set of custom business rules. You must implement custom exception classes to distinguish between insufficient funds, invalid account statuses, and simultaneous transaction conflicts. The system must handle a sequence of mixed valid and invalid inputs, ensuring that a single failure does not halt the entire batch while also preventing \"swallowed\" exceptions from masking critical system errors."}, {"role": "assistant", "content": "<think>\n### Problem Breakdown\n\n**1. Core Requirements:**\n* **Transaction Validation:** Check for sufficient funds, account status (e.g., active/frozen), and concurrency (simultaneous transactions on the same account).\n* **Custom Exceptions:**\n * `InsufficientFundsError`: Balance < amount.\n * `InvalidAccountStatusError`: Account is frozen or closed.\n * `TransactionConflictError`: Attempting to modify an account currently being processed by another thread/task.\n* **Robust Batch Processing:** A single failed transaction shouldn't crash the loop. We need a \"Result\" pattern or a way to collect errors without losing context.\n* **Concurrency Management:** Use a locking mechanism to prevent race conditions on individual accounts.\n\n**2. Algorithm Design:**\n* **Data Model:** An `Account` class containing `id`, `balance`, `status`, and a `threading.Lock`.\n* **Transaction Processor:**\n * Maintain a registry of accounts.\n * Use a `try-except` block inside the loop for batch processing.\n * Implement a `process_batch` method that returns a summary of successes and failures.\n* **Concurrency Strategy:** Use `threading.Lock` per account. To prevent deadlocks during transfers (Account A -> B), always acquire locks in a deterministic order (e.g., by account ID).\n\n**3. Edge Cases:**\n* **Transferring to self:** Should be handled or rejected.\n* **Deadlocks:** If Transaction 1 is A $\\to$ B and Transaction 2 is B $\\to$ A, locking A then B vs B then A causes a deadlock. *Solution: Sort IDs before locking.*\n* **Non-existent accounts:** Raise a specific error.\n* **Negative amounts:** Validate input amounts are positive.\n\n**4. Complexity Analysis:**\n* **Time Complexity:** \n * Single transaction: $O(1)$ (hash map lookup + lock acquisition).\n * Batch processing: $O(N)$ where $N$ is the number of transactions.\n* **Space Complexity:** $O(M)$ where $M$ is the number of unique accounts stored in memory.\n</think>\n\n```python\nimport threading\nfrom enum import Enum\nfrom dataclasses import dataclass, field\nfrom typing import List, Dict, Union, Optional\n\n\n# ==========================================\n# Custom Exception Hierarchy\n# ==========================================\n\nclass TransactionError(Exception):\n \"\"\"Base class for all transaction-related errors.\"\"\"\n pass\n\nclass InsufficientFundsError(TransactionError):\n \"\"\"Raised when an account does not have enough balance.\"\"\"\n pass\n\nclass InvalidAccountStatusError(TransactionError):\n \"\"\"Raised when an account is frozen or inactive.\"\"\"\n pass\n\nclass TransactionConflictError(TransactionError):\n \"\"\"Raised when a resource is locked or a race condition is detected.\"\"\"\n pass\n\nclass AccountNotFoundError(TransactionError):\n \"\"\"Raised when the target account does not exist.\"\"\"\n pass\n\n\n# ==========================================\n# Domain Models\n# ==========================================\n\nclass AccountStatus(Enum):\n ACTIVE = \"ACTIVE\"\n FROZEN = \"FROZEN\"\n CLOSED = \"CLOSED\"\n\n@dataclass\nclass Account:\n account_id: str\n balance: float\n status: AccountStatus = AccountStatus.ACTIVE\n # A lock per account ensures granular concurrency control\n _lock: threading.Lock = field(default_factory=threading.Lock, repr=False)\n\n def __post_init__(self):\n if self.balance < 0:\n raise ValueError(\"Initial balance cannot be negative.\")\n\n@dataclass\nclass TransactionRequest:\n type: str # 'DEPOSIT', 'WITHDRAW', 'TRANSFER'\n amount: float\n sender_id: Optional[str] = None\n receiver_id: Optional[str] = None\n\n\n@dataclass\nclass TransactionResult:\n success: bool\n transaction_id: int\n details: str\n error_type: Optional[str] = None\n\n\n# ==========================================\n# Core Processing Engine\n# ==========================================\n\nclass TransactionProcessor:\n def __init__(self):\n self.accounts: Dict[str, Account] = {}\n self._counter = 0\n self._registry_lock = threading.Lock()\n\n def add_account(self, account: Account):\n with self._registry_lock:\n self.accounts[account.account_id] = account\n\n def _get_account(self, account_id: str) -> Account:\n if account_id not in self.accounts:\n raise AccountNotFoundError(f\"Account {account_id} not found.\")\n return self.accounts[account_id]\n\n def _validate_account_access(self, account: Account):\n if account.status != AccountStatus.ACTIVE:\n raise InvalidAccountStatusError(f\"Account {account.account_id} is {account.status.value}.\")\n\n def process_single_transaction(self, tx_id: int, req: TransactionRequest) -> TransactionResult:\n \"\"\"\n Executes a single transaction with strict validation and locking.\n \"\"\"\n try:\n if req.amount <= 0:\n raise ValueError(\"Transaction amount must be positive.\")\n\n if req.type == \"DEPOSIT\":\n return self._handle_deposit(tx_id, req)\n elif req.type == \"WITHDRAW\":\n return self._handle_withdraw(tx_id, req)\n elif req.type == \"TRANSFER\":\n return self._handle_transfer(tx_id, req)\n else:\n raise ValueError(f\"Unknown transaction type: {req.type}\")\n\n except TransactionError as e:\n return TransactionResult(False, tx_id, str(e), e.__class__.__name__)\n except Exception as e:\n # This catches unexpected system errors (e.g. KeyError, ValueError)\n # We wrap them to ensure they don't halt the batch but are clearly labeled\n return TransactionResult(False, tx_id, f\"System Error: {str(e)}\", \"UnexpectedError\")\n\n def _handle_deposit(self, tx_id: int, req: TransactionRequest) -> TransactionResult:\n acc = self._get_account(req.receiver_id)\n with acc._lock:\n self._validate_account_access(acc)\n acc.balance += req.amount\n return TransactionResult(True, tx_id, f\"Deposited {req.amount} to {acc.account_id}\")\n\n def _handle_withdraw(self, tx_id: int, req: TransactionRequest) -> TransactionResult:\n acc\n```"}]}
|
| {"language": "ru", "category": "Генераторы списков, выражения-генераторы, yield, itertools", "messages": [{"role": "system", "content": "Ты продвинутый AI разработчик. Перед написанием кода ты анализируешь задачу внутри тегов <think>...</think>, затем пишешь чистый рабочий код."}, {"role": "user", "content": "Напишите генератор, который принимает последовательность чисел и возвращает бесконечный поток их кубов, но только в том случае, если число не является «числом-катаном» (число, сумма цифр которого равна 7). Реализуйте это через `yield` и `itertools`, учитывая, что при встрече отрицательного числа генератор должен не останавливаться, а пропускать его, сохраняя логику бесконечного цикла. Ваша задача — обеспечить корректную работу выражения-генератора при попытке получить элементы из уже «исчерпанного» (с точки зрения логики фильтрации) итератора."}, {"role": "assistant", "content": "<think>\n**Анализ задачи:**\n\n1. **Входные данные:** Последовательность чисел (итератор или список).\n2. **Условие фильтрации \"Число-катана\":** Сумма цифр числа должна быть равна 7. \n * *Нюанс:* Для отрицательных чисел нужно работать с модулем числа, чтобы корректно считать сумму цифр.\n3. **Условие пропуска:** Отрицательные числа должны игнорироваться (пропускаться), не прерывая генератор.\n4. **Трансформация:** Возведение в куб.\n5. **Бесконечность:** Поскольку входная последовательность может быть конечной, а нам нужен \"бесконечный поток\", необходимо использовать `itertools.cycle`, чтобы зациклить входные данные.\n6. **Инструментарий:** `yield` (для создания генератора), `itertools` (для зацикливания).\n7. **Краевые случаи:**\n * Пустой входной список: `itertools.cycle` вызовет ошибку `StopIteration`, нужно это обработать.\n * Числа, где сумма цифр 7 (например, 7, 16, 25, 70, 106).\n * Отрицательные числа (должны игнорироваться).\n * Ноль (0): сумма цифр 0, не 7, куб 0. Должен проходить.\n\n**Алгоритм:**\n1. Создать функцию `is_katana(n)`.\n2. Использовать `itertools.cycle(input_sequence)` для создания бесконечного цикла.\n3. Внутри генератора использовать цикл `for` по бесконечному итератору.\n4. Применить фильтрацию: `if n >= 0 and not is_katana(n)`.\n5. Если условие соблюдено, `yield n**3`.\n\n**Сложность:**\n* Временная сложность: $O(1)$ на каждый `next()`.\n* Пространственная сложность: $O(1)$ (так как мы работаем через итераторы, не создавая новых списков в памяти).\n</think>\n\n```python\nimport itertools\n\ndef is_katana(n: int) -> bool:\n \"\"\"\n Проверяет, является ли число 'числом-катаной' \n (сумма цифр числа равна 7).\n \"\"\"\n
|
| {"language": "ru", "category": "ООП: классы, наследование, dunder-методы (__repr__, __add__)", "messages": [{"role": "system", "content": "Ты продвинутый AI разработчик. Перед написанием кода ты анализируешь задачу внутри тегов <think>...</think>, затем пишешь чистый рабочий код."}, {"role": "user", "content": "Создайте систему управления складскими запасами, где класс `Product` поддерживает сложение объектов через `__add__` и строковое представление через `__repr__`. Реализуйте наследование для класса `PerishableProduct` (скоропортящийся товар), который должен корректно обрабатывать попытку сложения с обычным товаром, если у них разные единицы измерения или если срок годности одного из них уже истек. Подвох заключается в том, как ваш алгоритм обработает сложение двух объектов, если один из них имеет отрицательный остаток или нулевой срок годности."}, {"role": "assistant", "content": "<think>\n### Анализ задачи\n\n**1. Цель:**\nРеализовать систему управления запасами с использованием ООП (наследование, перегрузка операторов). Основное внимание — корректная обработка сложения объектов разных типов с учетом бизнес-логики (единицы измерения, срок годности, отрицательные остатки).\n\n**2. Алгоритм:**\n* **Класс `Product`**:\n * Атрибуты: `name` (str), `quantity` (float), `unit` (str).\n * `__add__`: Проверяет, совпадает ли `unit`. Если да — возвращает новый объект с суммарным количеством. Если нет — выбрасывает `ValueError`.\n * `__repr__`: Возвращает читаемое строковое представление.\n* **Класс `PerishableProduct` (наследник `Product`)**:\n * Атрибуты: `expiry_date` (datetime.date).\n * `__add__`: \n * Дополнительная проверка: если `expiry_date` < текущей даты, товар считается испорченным.\n * Логика: если хотя бы один товар испорчен, сумма не может быть создана (или возвращается 0, но правильнее выбросить исключение или вернуть объект с нулевым количеством, если бизнес-логика подразумевает \"испорченное не учитывается\"). В данном решении мы выбросим `ValueError`, так как нельзя складывать \"гнилое\" с \"новым\" для получения полезного запаса.\n * Обработка типов: нужно корректно обрабатывать сложение `PerishableProduct + Product` и наоборот.\n* **Краевые случаи (Подвохи):**\n * **Отрицательный остаток:** Если сумма дает `< 0`, логично считать это ошибкой или устанавливать 0 (зависит от интерпретации, но в складских системах отрицательный остаток — это ошибка учета). Реализуем проверку: если результат `< 0`, выбрасываем `ValueError`.\n * **Нулевой срок годности:** Если дата истекла сегодня — товар считается испорченным.\n * **Разные единицы измерения:** `kg` + `pcs` = `ValueError`.\n * **Сложение разных типов:** `PerishableProduct` + `Product` должен работать, если единицы измерения совпадают и срок годности в порядке.\n\n**3. Сложность:**\n* Временная сложность: $O(1)$ для всех операций.\n* Пространственная сложность: $O(1)$ для создания новых объектов.\n</think>\n\n```python\nfrom datetime import date\n\nclass Product:\n \"\"\"Базовый класс для товара на складе.\"\"\"\n def __init__(self, name: str, quantity: float, unit: str):\n self.name = name\n self.quantity = quantity\n self.unit = unit\n\n def __add__(self, other):\n if not isinstance(other, Product):\n return NotImplemented\n \n # Проверка на совместимость единиц измерения\n if self.unit!= other.unit:\n raise ValueError(\n f\"Невозможно сложить {self.name} ({self.unit}) и {other.name} ({other.unit}): разные единицы измерения.\"\n )\n \n new_quantity = self.quantity + other.quantity\n \n # Обработка подвоха: отрицательный остаток\n if new_quantity < 0:\n raise ValueError(\"Ошибка учета: суммарный остаток не может быть отрицательным.\")\n \n return Product(self.name, new_quantity, self.unit)\n\n def __repr__(self):\n return f\"Product(name='{self.name}', quantity={self.quantity}, unit='{self.unit}')\"\n\n\nclass PerishableProduct(Product):\n \"\"\"Класс для скоропортящихся товаров с проверкой срока годности.\"\"\"\n def __init__(self, name: str, quantity: float, unit: str, expiry_date: date):\n super().__init__(name, quantity, unit, expiry_date)\n self.expiry_date = expiry_date\n\n def __add__(self, other):\n if not isinstance(other, Product):\n return NotImplemented\n\n # Проверка на совместимость единиц измерения\n if self.unit!= other.unit:\n raise ValueError(f\"Невозможно сложить {self.name} и {other.name}: разные единицы измерения.\")\n\n # Проверка срока годности (текущая дата)\n today = date.today()\n \n # Проверяем текущий объект\n if self.expiry_date <= today:\n raise ValueError(f\"Срок годности товара '{self.name}' истек ({self.expiry_date}).\")\n \n # Проверяем второй объект (если он тоже скоропортящийся)\n if isinstance(other, PerishableProduct):\n if other.expiry_date <= today:\n raise ValueError(f\"Срок годности товара '{other.name}' истек ({other.expiry_date}).\")\n \n # При сложении двух скоропортящихся товаров, новый товар должен иметь \n # минимальную дату годности из двух, чтобы быть безопасным\n new_expiry = min(self.expiry_date, other.expiry_date)\n else:\n # Если второй объект обычный, срок годности берется от текущего\n new_expiry = self.expiry_date\n\n new_quantity = self.quantity + other.quantity\n \n if new_quantity < 0:\n raise ValueError(\"Ошибка учета: суммарный остаток не может быть отрицательным.\")\n\n return PerishableProduct(self.name, new_quantity, self.unit, new_expiry)\n\n def __repr__(self):\n return (f\"PerishableProduct(name='{self.name}', quantity={self.quantity}, \"\n f\"unit='{self.unit}', expiry_date={self.expiry_date})\")\n\n\n# --- Тестирование системы ---\n\ndef run_tests():\n print(\"--- Запуск тестов системы управления складом ---\")\n\n # 1. Тест: Обычное сложение\n p1 = Product(\"Мука\", 10, \"кг\")\n p2 = Product(\"Сахар\", 5, \"кг\")\n print(f\"Тест 1 (Обычное): {p1} + {p2} = {p1 + p2}\")\n\n # 2. Тест: Разные единицы измерения\n```"}]}
|
| {"language": "ru", "category": "ООП: классы, наследование, dunder-методы (__repr__, __add__)", "messages": [{"role": "system", "content": "Ты продвинутый AI разработчик. Перед написанием кода ты анализируешь задачу внутри тегов <think>...</think>, затем пишешь чистый рабочий код."}, {"role": "user", "content": "Реализуйте класс `Vector`, поддерживающий сложение объектов и строковое представление, где при попытке сложить вектор с числом (скаляром) результат должен возвращать новый вектор, а не ошибку. Подвох заключается в том, что стандартный механизм `__add__` не обрабатывает операцию `число + вектор`, поэтому вам необходимо реализовать метод, который позволит корректно выполнять арифметику в обоих направлениях. Учтите, что при сложении вектора с объектом другого типа, который не является числом, программа не должна падать, а должна возвращать исходный объект."}, {"role": "assistant", "content": "<think>\nЗадача требует реализации класса `Vector`, который должен поддерживать:\n1. Сложение векторов (`Vector + Vector`).\n2. Сложение вектора со скаляром (`Vector + scalar`).\n3. Сложение скаляра с вектором (`scalar + Vector`).\n4. Строковое представление (`__str__` или `__repr__`).\n5. Обработку некорректных типов: если тип объекта не является числом или вектором, операция сложения должна возвращать исходный объект (в контексте `Vector + other`), либо (в контексте `other + Vector`) логика должна быть согласована.\n\n**Алгоритм:**\n1. **`__init__`**: Принимает компоненты вектора (список или кортеж).\n2. **`__add__`**: \n - Если `other` — это `Vector`, складываем поэлементно.\n - Если `other` — это число (`int` или `float`), прибавляем это число к каждому компоненту вектора.\n - В остальных случаях возвращаем `self` (согласно условию: \"не должна падать, а должна возвращать исходный объект\").\n3. **`__radd__`**: (Right addition) Вызывается, когда левый операнд не поддерживает сложение с правым оперантом (например, `5 + vector`).\n - Здесь мы можем просто делегировать вызов `self.__add__(other)`, так как математически `scalar + vector` эквивалентно `vector + scalar`.\n4. **`__repr__`**: Форматированный вывод вектора, например `Vector([1, 2, 3])`.\n\n**Краевые случаи:**\n- Сложение с `None`, строками или списками: должен возвращать `self`.\n- Векторы разной длины: по умолчанию в таких задачах либо выбрасывается ошибка, либо (если не указано иное) можно считать это некорректной операцией. Однако, учитывая условие \"не должна падать\", если мы пытаемся сложить векторы разной длины, это можно трактовать как \"не является корректным сложением векторов\" и вернуть `self`. Но более стандартно для векторов — это ошибка. Я реализую проверку длины, и если длины не совпадают, верну `self`, чтобы строго следовать инструкции \"не должна падать\".\n- Сложение с `0` или `1`.\n\n**Сложность:**\n- `__add__`: $O(n)$, где $n$ — размерность вектора.\n- `__repr__`: $O(n)$.\n- Память: $O(n)$ для создания нового объекта.\n</think>\n\n```python\nclass Vector:\n \"\"\"\n Класс Vector, поддерживающий сложение с другими векторами и скалярами.\n \"\"\"\n\n def __init__(self, components):\n \"\"\"\n Инициализация вектора.\n :param components: Итерируемый объект с числами (список, кортеж и т.д.)\n \"\"\"\n if not hasattr(components, '__iter__'):\n raise TypeError(\"Components must be an iterable.\")\n self.components = list(components)\n\n def __add__(self, other):\n \"\"\"\n Метод для реализации операции Vector + other.\n \"\"\"\n
|
| {"language": "en", "category": "OOP: classes, inheritance, polymorphism, and dunder methods", "messages": [{"role": "system", "content": "You are an expert AI software engineer. You analyze problems inside <think>...</think> tags before writing clean, robust code."}, {"role": "user", "content": "Design a hierarchical system for a digital zoo where different animal species must implement a unified `make_sound()` method and a custom `__add__` dunder method to simulate \"group energy\" calculations. You must handle complex edge cases where attempting to \"add\" incompatible species or empty enclosures results in specific custom exception types rather than standard errors. Ensure that polymorphic behavior correctly identifies the specific energy contribution of a subclass even when objects are stored in a generic parent-class list."}, {"role": "assistant", "content": "<think>\n**Problem Breakdown:**\n\n1. **Core Requirements:**\n * **Hierarchy:** A base class `Animal` and specific subclasses (e.g., `Mammal`, `Bird`, `Reptile`).\n * **Unified Interface:** Every animal must implement `make_sound()`.\n * **Custom Addition (`__add__`):** Implement a way to \"add\" animals together to calculate \"group energy.\"\n * **Polymorphism:** The energy calculation must rely on the specific subclass's energy value, even when called from a list of the base class type.\n * **Exception Handling:** Custom exceptions for incompatible species and empty enclosures.\n\n2. **Edge Cases:**\n * **Empty Enclosure:** Adding an empty list or a null object should raise `EmptyEnclosureError`.\n * **Incompatible Species:** If a user tries to add a `Bird` to a `Reptile` (if we define a rule that they can't coexist), raise `IncompatibleSpeciesError`.\n * **Type Safety:** Ensure `__add__` handles adding a single animal to a list or two animals together.\n\n3. **Algorithm/Logic:**\n * Define `Animal` as an Abstract Base Class (ABC).\n * Define `EnergyContribution` as a property in subclasses.\n * The `__add__` method for a `ZooEnclosure` (the container) will iterate through animals, checking compatibility and summing energy.\n * The `__add__` method for an `Animal` (or the enclosure) will be the driver for the logic.\n\n4. **Complexity Analysis:**\n * **Time Complexity:** $O(N)$ where $N$ is the number of animals in the enclosure, as we must iterate through the list to sum energy.\n * **Space Complexity:** $O(1)$ (excluding storage of the animals themselves) as we only maintain a running sum.\n\n4. **Class Structure:**\n * `ZooError` (Base Exception)\n * `IncompatibleSpeciesError`\n * `EmptyEnclosureError`\n * `Animal` (ABC)\n * `Mammal`, `Bird`, `Reptile` (Subclasses)\n * `ZooEnclosure` (The container that implements `__add__`)\n</think>\n\n```python\nfrom abc import ABC, abstractmethod\nfrom typing import List, Union\n\n# --- Custom Exceptions ---\n\nclass ZooError(Exception):\n \"\"\"Base exception for all zoo-related errors.\"\"\"\n pass\n\nclass IncompatibleSpeciesError(ZooError):\n \"\"\"Raised when two species cannot be in the same enclosure.\"\"\"\n pass\n\nclass EmptyEnclosureError(ZooError):\n \"\"\"Raised when an operation is performed on an empty enclosure.\"\"\"\n pass\n\n# --- Abstract Base Class ---\n\nclass Animal(ABC):\n def __init__(self, name: str, energy_value: float, species_type: str):\n self.name = name\n self.energy_value = energy_value\n self.species_type = species_type\n\n @abstractmethod\n def make_sound(self) -> str:\n \"\"\"Each subclass must implement its own sound.\"\"\"\n pass\n\n def __repr__(self):\n return f\"{self.name} ({self.species_type})\"\n\n# --- Concrete Subclasses ---\n\nclass Mammal(Animal):\n def __init__(self, name: str, energy_value: float):\n super().__init__(name, energy_value, \"Mammal\")\n\n def make_sound(self) -> str:\n return \"Roar/Grunt\"\n\nclass Bird(Animal):\n def __init__(self, name: str, energy_value: float):\n super().__init__(name, energy_value, \"Bird\")\n\n def make_sound(self) -> str:\n return \"Chirp/Tweet\"\n\nclass Reptile(Animal):\n def __init__(self, name: str, energy_value: float):\n super().__init__(name, energy_value, \"Reptile\")\n\n def make_sound(self) -> str:\n return \"Hiss\"\n\n# --- The Container System ---\n\nclass ZooEnclosure:\n \"\"\"\n A container for animals that implements custom logic for \n combining 'group energy'.\n \"\"\"\n def __init__(self, enclosure_name: str):\n self.name = enclosure_name\n self.animals: List[Animal] = []\n\n def add_animal(self, animal: Animal):\n self.animals.append(animal)\n\n def __add__(self, other: Union['ZooEnclosure', List[Animal]]) -> float:\n \"\"\"\n Custom __add__ implementation.\n If adding a List of animals to this enclosure, it calculates total energy.\n If adding another enclosure, it combines them.\n \"\"\"\n # Determine what we are adding to\n target_animals = []\n if isinstance(other, ZooEnclosure):\n target_animals = other.animals\n elif isinstance(other, list):\n target_animals = other\n else:\n raise TypeError(\"Can only add ZooEnclosure or List[Animal]\")\n\n # Edge Case: Empty Enclosure Check\n if not self.animals and not target_animals:\n raise EmptyEnclosureError(\"Cannot calculate energy for two empty enclosures.\")\n\n # We will use the first animal's species as the 'compatibility' baseline \n # for this simplified simulation logic.\n baseline_species = self.animals[0].species_type if self.animals else None\n \n total_energy = 0.0\n \n # Check existing animals for compatibility (if adding to existing)\n # For this implementation, we assume the enclosure has a 'dominant' species type\n # and all newcomers must match it to avoid IncompatibleSpeciesError.\n \n # Combine lists to iterate\n combined_list = self.animals + target_animals\n \n # Logic: Ensure all animals in the resulting set are compatible.\n # Rule: All animals in the enclosure must share the same species_type.\n first_type = combined_list[0].species_type\n for animal in combined_list:\n if animal.species_type != first_type:\n raise IncompatibleSpeciesError(\n f\"Compatibility Error: {animal.species_type} cannot coexist with {first_type}!\"\n )\n \n # Calculate Energy (Polymorphic access to energy_value)\n for animal in combined_list:\n total_energy += animal.energy_value\n \n return total_energy\n```"}]}
|
| {"language": "ru", "category": "Обработка исключений try-except и кастомные Exception", "messages": [{"role": "system", "content": "Ты продвинутый AI разработчик. Перед написанием кода ты анализируешь задачу внутри тегов <think>...</think>, затем пишешь чистый рабочий код."}, {"role": "user", "content": "Разработайте систему обработки платежей, которая должна выбрасывать кастомное исключение `InsufficientFundsError`, если баланс пользователя меньше суммы покупки, и `InvalidAmountError`, если введенная сумма отрицательная или равна нулю. Логический подвох заключается в том, что при попытке списать средства должна корректно обрабатываться ситуация, когда пользователь одновременно вводит отрицательное число и имеет нулевой баланс. Ваша задача — обеспечить правильный приоритет перехвата исключений, чтобы программа не «падала» с системной ошибкой, а возвращала максимально специфичное пользовательское сообщение."}, {"role": "assistant", "content": "<think>\n**Анализ задачи:**\n\n1. **Цель:** Реализовать систему платежей с кастомными исключениями.\n2. **Исключения:**\n * `InvalidAmountError`: если сумма $\\le 0$.\n * `InsufficientFundsError`: если сумма покупки $>$ баланса.\n3. **Логический подвох (Приоритет):**\n * Если пользователь вводит отрицательную сумму (например, -100) при нулевом балансе, система должна сначала проверить валидность самой суммы, а затем — достаточность средств.\n * Математически, проверка на валидность суммы (`amount <= 0`) должна стоять **первой** в логической цепочке. Если сумма некорректна, нам не важно, сколько денег на счету — ошибка ввода является первичной и более специфичной для действия пользователя.\n4. **Алгоритм:**\n * Определить классы исключений, наследуясь от `Exception`.\n * Создать класс `PaymentSystem` с атрибутом `balance`.\n * Метод `process_payment(amount)`:\n 1. Проверить `amount <= 0` $\\rightarrow$ выбросить `InvalidAmountError`.\n 2. Проверить `amount > balance` $\\rightarrow$ выбросить `InsufficientFundsError`.\n 3. Если оба условия пройдены $\\rightarrow$ вычесть сумму из баланса.\n * Реализовать блок `try-except` для обработки этих ошибок в правильном порядке.\n5. **Краевые случаи:**\n * `amount = 0`: должно вызвать `InvalidAmountError`.\n * `amount < 0`: должно вызвать `InvalidAmountError` (даже если баланс 0).\n * `amount > balance`: должно вызвать `InsufficientFundsError`.\n * `amount == balance`: платеж должен пройти успешно.\n6. **Сложность:**\n * Временная сложность: $O(1)$ — выполнение простых арифметических сравнений.\n * Пространственная сложность: $O(1)$ — хранение одного числа (баланса).\n</think>\n\n```python\nclass PaymentError(Exception):\n \"\"\"Базовый класс для исключений платежной системы.\"\"\"\n pass\n\nclass InsufficientFundsError(PaymentError):\n \"\"\"Исключение, возникающее при нехватке средств на балансе.\"\"\"\n def __init__(self, balance, amount):\n self.message = f\"Недостаточно средств. Ваш баланс: {balance}, требуется: {amount}\"\n super().__init__(self.message)\n\nclass InvalidAmountError(PaymentError):\n \"\"\"Исключение, возникающее при вводе некорректной суммы (<= 0).\"\"\"\n def __init__(self, amount):\n self.message = f\"Некорректная сумма платежа: {amount}. Сумма должна быть больше нуля.\"\n super().__init__(self.message)\n\nclass PaymentSystem:\n def __init__(self, initial_balance: float):\n self.balance = initial_balance\n\n def process_payment(self, amount: float):\n \"\"\"\n Обрабатывает платеж. \n Приоритет проверок: сначала валидность суммы, затем проверка баланса.\n \"\"\"\n
|
| {"language": "en", "category": "String manipulation, regex parsing, slicing, and formatting", "messages": [{"role": "system", "content": "You are an expert AI software engineer. You analyze problems inside <think>...</think> tags before writing clean, robust code."}, {"role": "user", "content": "Design a function that parses a raw, unstructured log string to extract specific metadata: a timestamp in `[YYYY-MM-DD HH:MM:SS]` format, a severity level (DEBUG, INFO, WARNING, ERROR, or CRITICAL), and a message. You must handle irregular whitespace, varying bracket styles, and cases where the severity level is embedded within the message text rather than following the timestamp. The final output must be a single, strictly formatted string: `\"{LEVEL} | {DATE} | {CLEANED_MESSAGE}\"`, ensuring that any special characters or trailing punctuation within the message are stripped while preserving internal punctuation."}, {"role": "assistant", "content": "<think>\n* **Goal**: Parse an unstructured log string to extract `[Timestamp]`, `Severity`, and `Message`.\n* **Input Format**: Unstructured. Timestamp is `[YYYY-MM-DD HH:MM:SS]`. Severity is one of `DEBUG, INFO, WARNING, ERROR, CRITICAL`. Message is the rest.\n* **Constraints**:\n * Handle irregular whitespace.\n * Handle varying bracket styles (though the timestamp format is fixed).\n * Severity might be embedded anywhere (not necessarily after the timestamp).\n * Output format: `\"{LEVEL} | {DATE} | {CLEANED_MESSAGE}\"`.\n * Clean the message: Strip trailing punctuation and whitespace, but preserve internal punctuation.\n* **Edge Cases**:\n * Timestamp at the end of the string instead of the beginning.\n * Severity level appears inside the message text (e.g., \"The ERROR occurred\"). We need to identify the *actual* severity level intended for the log, usually treated as the first/primary occurrence of the keyword.\n * Empty or malformed strings.\n * Messages with heavy punctuation at the end (e.g., \"System failure!!! ???\").\n* **Algorithm**:\n 1. Define the set of valid severity levels.\n 2. Use Regular Expressions to find the timestamp: `\\[\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}\\]`.\n 3. Use Regular Expressions to find the first occurrence of a severity level.\n 4. The \"Message\" is essentially everything that isn't the timestamp or the severity level. However, to be robust, I will:\n a. Extract the timestamp and remove it from the string.\n b. Extract the severity level and remove it from the string.\n c. Clean the remaining string by stripping whitespace and trailing punctuation.\n 5. Complexity: $O(N)$ where $N$ is the length of the string, as regex scanning and string manipulation are linear.\n* **Refined Message Extraction Logic**:\n * The prompt says \"the severity level is embedded within the message text rather than following the timestamp\". This implies the severity is part of the log structure.\n * Let's extract the timestamp first.\n * Then find the first occurrence of one of the keywords.\n * The message is what remains after removing the timestamp and the severity keyword.\n * Clean the message: `strip()` whitespace and use `string.punctuation` to strip trailing characters.\n</think>\n\n```python\nimport re\nimport string\n\ndef parse_log_entry(log_string: str) -> str:\n \"\"\"\n Parses an unstructured log string to extract Timestamp, Severity, and Message.\n \n Format: \"{LEVEL} | {DATE} | {CLEANED_MESSAGE}\"\n \"\"\"\n if not log_string:\n return \"\"\n\n # 1. Extract Timestamp: [YYYY-MM-DD HH:MM:SS]\n # We look for the specific pattern of digits and separators inside brackets\n timestamp_pattern = r'\\[\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}\\]'\n timestamp_match = re.search(timestamp_pattern, log_string)\n \n if not timestamp_match:\n # If no timestamp is found, we cannot satisfy the strict output format requirements\n # depending on requirements, we might return empty or raise error.\n return \"\"\n \n timestamp = timestamp_match.group(0)\n # Remove timestamp from the working string to avoid interference\n working_str = log_string.replace(timestamp, \"\", 1)\n\n # 2. Extract Severity Level\n # Levels: DEBUG, INFO, WARNING, ERROR, CRITICAL\n levels = [\"DEBUG\", \"INFO\", \"WARNING\", \"ERROR\", \"CRITICAL\"]\n # Create a regex pattern that matches any of the levels as a whole word\n severity_pattern = r'\\b(' + '|'.join(levels) + r')\\b'\n severity_match = re.search(severity_pattern, working_str)\n \n if not severity_match:\n # If no severity is found, we assume a default or handle as error\n # For this implementation, we'll treat it as an empty level or skip\n severity = \"UNKNOWN\"\n else:\n severity = severity_match.group(1)\n # Remove the severity from the string to isolate the message\n # We use a count of 1 to ensure we only remove the first instance found\n working_str = working_str.replace(severity, \"\", 1)\n\n # 3. Extract and Clean Message\n # The message is what remains. We need to clean irregular whitespace and trailing punctuation.\n \n # Remove leading/trailing whitespace first\n cleaned_message = working_str.strip()\n \n # The prompt requires stripping \"any special characters or trailing punctuation\" \n # while preserving \"internal punctuation\". \n # string.punctuation contains: !\"
|
| {"language": "ru", "category": "Работа с файлами, чтение и запись JSON, CSV, модуль pathlib", "messages": [{"role": "system", "content": "Ты продвинутый AI разработчик. Перед написанием кода ты анализируешь задачу внутри тегов <think>...</think>, затем пишешь чистый рабочий код."}, {"role": "user", "content": "Напишите программу, которая сканирует директорию с помощью `pathlib`, собирает данные о файлах (имя, размер, расширение) и сохраняет их в JSON, а затем преобразует этот же список в CSV-отчет. Программа должна корректно обрабатывать ситуацию, если в папке встречаются файлы без расширений или файлы, чьи имена содержат спецсимволы, и при этом не пытаться записывать в отчет сами файлы конфигурации JSON и CSV, которые создаются в процессе работы."}, {"role": "assistant", "content": "<think>\n**Анализ задачи:**\n\n1. **Цель:** Сканирование директории, сбор метаданных файлов (имя, размер, расширение), сохранение в JSON, затем конвертация в CSV.\n2. **Инструментарий:** Использование библиотеки `pathlib` для работы с путями.\n3. **Требования к обработке данных:**\n * **Расширения:** Если расширения нет (файл типа `.gitignore` или просто `README`), нужно корректно обрабатывать это (пустая строка или `None`).\n * **Спецсимволы:** Имена файлов могут содержать пробелы, эмодзи, кавычки и т.д. Формат JSON и CSV (с правильным экранированием) должны это поддерживать.\n * **Исключение самореференции:** Программа не должна включать в отчет файлы `report.json` и `report.csv`, которые она сама создает.\n4. **Алгоритм:**\n * Инициализировать список словарей.\n * Итерироваться по `pathlib.Path.iterdir()`.\n * Для каждого объекта проверить, является ли он файлом (`is_file()`).\n * Проверить, не является ли имя файла именем выходных файлов.\n * Извлечь `name`, `stat().st_size` и `suffix`.\n * Записать список в JSON.\n * Прочитать JSON и записать в CSV.\n5. **Краевые случаи:**\n * Пустая директория.\n * Файлы без расширения (пустой `suffix`).\n * Файлы с точкой в начале (скрытые файлы).\n * Файлы с очень длинными именами или спецсимволами.\n * Директория, в которой нет прав на чтение (обработка исключений).\n6. **Сложность:**\n * **Временная сложность:** $O(N)$, где $N$ — количество файлов в директории. Мы проходим по списку файлов дважды (один раз для сбора, второй — при записи/чтении).\n * **Пространственная сложность:** $O(N)$ для хранения списка метаданных в оперативной памяти перед записью.\n</think>\n\n```python\nimport json\nimport csv\nfrom pathlib import Path\n\ndef scan_directory(directory_path: str, json_filename: str, csv_filename: str):\n \"\"\"\n Сканирует директорию, собирает данные о файлах и сохраняет в JSON и CSV.\n \"\"\"\n base_path = Path(directory_path)\n \n # Проверка существования директории\n if not base_path.is_dir():\n print(f\"Ошибка: Директория '{directory_path}' не найдена или не является папкой.\")\n return\n\n # Определяем имена выходных файлов, чтобы исключить их из сканирования\n # Используем абсолютные пути для надежности сравнения\n json_out_path = base_path / json_filename\n csv_out_path = base_path / csv_filename\n \n file_data_list = []\n\n print(f\"Начинаю сканирование директории: {base_path.absolute()}\")\n\n try:\n # Итерируемся по содержимому директории\n for item in base_path.iterdir():\n # Проверяем, что это файл и что это не наши выходные файлы\n if item.is_file() and item.name != json_filename and item.name != csv_filename:\n \n # Извлекаем данные\n # item.suffix возвращает расширение вместе с точкой (например, '.txt')\n # Если расширения нет, вернет пустую строку ''\n extension = item.suffix if item.suffix else \"no extension\"\n \n file_info = {\n \"name\": item.name,\n \"size_bytes\": item.stat().st_size,\n \"extension\": extension\n }\n file_data_list.append(file_info)\n\n if not file_data_list:\n print(\"Файлы для обработки не найдены.\")\n return\n\n # 1. Сохранение в JSON\n # Используем ensure_ascii=False для корректной поддержки спецсимволов и эмодзи\n with open(json_out_path, 'w', encoding='utf-8') as jf:\n json.dump(file_data_list, jf, ensure_ascii=False, indent=4)\n print(f\"Данные успешно сохранены в JSON: {json_out_path.name}\")\n\n # 2. Преобразование JSON в CSV\n # Читаем данные из только что созданного JSON\n with open(json_out_path, 'r', encoding='utf-8') as jf:\n data_to_convert = json.load(jf)\n\n # Записываем в CSV\n # Используем DictWriter для удобной работы со списком словарей\n with open(csv_out_path, 'w', encoding='utf-8', newline='') as cf:\n # Определяем заголовки на основе ключей первого элемента\n fieldnames = ['name', 'size_bytes', 'extension']\n writer = csv.DictWriter(cf, fieldnames=fieldnames)\n \n writer.writeheader()\n writer.writerows(data_to_convert)\n \n print(f\"Данные успешно преобразованы в CSV: {csv_out_path.name}\")\n print(f\"Всего обработано файлов: {len(file_data_list)}\")\n\n except PermissionError:\n print(\"Ошибка: Недостаточно прав для чтения файлов или записи отчетов.\")\n except Exception as e:\n print(f\"Произошла непредвиденная ошибка: {e}\")\n\nif __name__ == \"__main__\":\n # Конфигурация\n TARGET_DIR = \".\" # Текущая директория\n JSON_NAME = \"file_report.json\"\n CSV_NAME = \"file_report.csv\"\n\n scan_directory(TARGET_DIR, JSON_NAME, CSV_NAME)\n```"}]}
|
| {"language": "en", "category": "String manipulation, regex parsing, slicing, and formatting", "messages": [{"role": "system", "content": "You are an expert AI software engineer. You analyze problems inside <think>...</think> tags before writing clean, robust code."}, {"role": "user", "content": "**Problem Statement: Log File Sanitization and Metadata Extraction**\n\nYou are tasked with developing a parser for a messy system log file where entries follow a loose format of `[TIMESTAMP] LEVEL: \"MESSAGE\" {METADATA}`. You must extract the timestamp, the severity level, and the message content while stripping any unnecessary whitespace or special characters within the message, and then reformat the data into a standardized string. Be careful to handle edge cases such as messages containing nested quotes, malformed metadata brackets, or timestamps that use non-standard delimiters."}, {"role": "assistant", "content": "<think>\n
|
| {"language": "ru", "category": "Генераторы списков, выражения-генераторы, yield, itertools", "messages": [{"role": "system", "content": "Ты продвинутый AI разработчик. Перед написанием кода ты анализируешь задачу внутри тегов <think>...</think>, затем пишешь чистый рабочий код."}, {"role": "user", "content": "Напишите функцию, которая принимает последовательность чисел и возвращает генератор, выдающий только уникальные элементы, которые встречаются в исходном списке ровно один раз. Подвох заключается в том, что функция должна корректно обрабатывать ситуацию, когда входной итератор является бесконечным или одноразовым (например, результатом другого генератора), не допуская бесконечного цикла и не потребляя всю память. Ваше решение должно использовать максимально эффективные инструменты из `itertools` и генераторных выражений для минимизации задержки при первом обращении к результату."}, {"role": "assistant", "content": "<think>\n1. **Анализ задачи:**\n * **Цель:** Создать генератор, который выдает элементы, встречающиеся в исходной последовательности ровно один раз.\n * **Ограничение 1 (Бесконечные итераторы):** Если входной итератор бесконечный, мы не можем просто прочитать его целиком (это вызовет зависание или `MemoryError`). Однако, чтобы определить, встречается ли элемент *ровно один раз*, нам нужно знать, встретится ли он снова в будущем.\n * **Ограничение 2 (Память):** Мы не можем хранить все элементы, если итератор бесконечен. Но по определению задачи, если элемент встречается \"ровно один раз\", мы не можем подтвердить это, пока не просканируем всю последовательность (так как он может встретиться позже).\n * **Дилемма:** Если итератор бесконечный, задача становится неразрешимой в классическом смысле \"выдать результат сейчас\", так как мы никогда не узнаем, является ли текущий элемент последним в своем роде.\n * **Переосмысление задачи:** В контекpте \"подвоха\" и использования `itertools`, наиболее эффективный способ обработки потоковых данных — это использование двух проходов или накопления состояний. Но так как итератор может быть одноразовым, мы обязаны прочитать его один раз. Чтобы минимизировать задержку (latency) и не \"пожирать\" память впустую, мы будем использовать `collections.Counter` для подсчета, но так как итератор может быть бесконечным, мы должны принять решение: либо мы работаем с \"окном\", либо мы признаем, что для определения \"уникальности\" нам в любом случае нужно прочитать данные.\n * **Правильный подход для \"одноразовых\" итераторов:** Мы должны прочитать последовательность один раз, собрать статистику, и затем выдать результат. Чтобы минимизировать задержку и быть эффективными, мы используем `collections.Counter` для одного прохода.\n\n2. **Алмуритм:**\n * Поскольку итератор может быть \"одноразовым\" (например, генератор), мы не можем пройти по нему дважды.\n * Следовательно, мы обязаны сохранить элементы в памяти (или хотя бы их количество), чтобы понять, сколько раз они встретились.\n * Используем `collections.Counter` для подсчета в один проход.\n * Для минимизации задержки при первом обращении к результату, мы будем использовать генераторное выражение, которое фильтрует элементы на основе уже собленного счетчика.\n\n3. **Краевые случаи:**\n * Пустой итератор.\n * Все элементы повторяются.\n * Все элементы уникальны.\n * Бесконечный итератор (в этом случае программа будет пытаться прочитать его бесконечно, что является ожидаемым поведением при попытке найти \"ровно один раз\" в бесконечности, но мы сделаем код максимально устойчивым).\n\n4. **Сложность:**\n * Временная сложность: $O(N)$, где $N$ — количество элементов (или время до остановки итератора).\n * Пространственная сложность: $O(U)$, где $U$ — количество уникальных элементов в итераторе.\n\n5. **Инструменты:**\n * `collections.Counter` для эффективного подсчета.\n * Генераторное выражение для выдачи результатов.\n</think>\n\n```python\nimport itertools\nfrom collections import Counter\nfrom typing import Iterable, Generator, Any\n\ndef get_unique_once_generator(iterable: Iterable[Any]) -> Generator[Any, None, None]:\n \"\"\"\n Принимает итератор и возвращает генератор, выдающий элементы, \n которые встречаются в исходной последовательности ровно один раз.\n \n Решение учитывает, что итератор может быть одноразовым (например, генератор),\n поэтому мы используем один проход для сбора статистики.\n \"\"\"\n \n # Чтобы определить, встречается ли элемент \"ровно один раз\", \n # нам необходимо знать весь контекст последовательности. \n # Если итератор бесконечный, выполнение застреднет на этапе сбора данных,\n # что является математически обоснованным ограничением задачи.\n \n # Шаг 1: Сбор статистики. \n # Мы используем Counter, так как это наиболее эффективный способ \n # подсчета частоты элементов в один проход.\n # Мы не можем использовать itertools.tee, так как это создаст \n # дублирование памяти и не решит проблему бесконечного итератора.\n \n counts = Counter()\n # Сохраняем порядок первого появления элементов, чтобы сохранить \n # детерминизм (хотя Counter в Python 3.7+ сохраняет порядок вставки)\n order = []\n \n try:\n for item in iterable:\n if item not in counts:\n order.append(item)\n counts[item] += 1\n except Exception as e:\n # Обработка исключений при итерации (например, если итератор прерван)\n raise e\n\n # Шаг 2: Создаем генератор, который выдает элементы с частотой == 1.\n # Мы используем генераторное выражение для минимизации задержки \n # (lazy evaluation) при обращении к результату.\n \n # Мы итерируемся по 'order', чтобы вернуть элементы в том порядке, \n # в котором они впервые встретились в исходном потоке.\n return (x for x in order if counts[x] == 1)\n\n# --- Тестирование решения ---\n\nif __name__ == \"__main__\":\n # Тест 1: Обычный список\n test_list = [1, 2, 2, 3, 4, 4, 5, 1, 6]\n # Ожидаем: 3, 5, 6 (в порядке первого появления)\n print(f\"Input: {test_list}\")\n print(f\"Result: {list(get_unique_once_generator(test_list))}\")\n\n # Тест 2: Одноразовый генератор (Generator Expression)\n gen = (x for x in [10, 20, 10, 30, 20, 40])\n # Ожидаем: 30, 40\n```"}]}
|
| {"language": "en", "category": "Asynchronous programming with asyncio coroutines and tasks", "messages": [{"role": "system", "content": "You are an expert AI software engineer. You analyze problems inside <think>...</think> tags before writing clean, robust code."}, {"role": "user", "content": "Implement a custom asynchronous task scheduler that manages a pool of worker coroutines to process a stream of timed jobs, where each job has a specific execution delay and a priority level. You must ensure that the scheduler correctly handles job timeouts, gracefully cancels pending tasks when a high-priority \"kill signal\" job is received, and prevents race conditions when multiple workers attempt to claim the same expired task. Pay close attention to how the system behaves when the job stream is empty, when all tasks are cancelled simultaneously, or when task execution durations overlap exactly with their timeout thresholds."}, {"role": "assistant", "content": "<think>\n
|
| {"language": "ru", "category": "Асинхронные корутины asyncio и таймеры", "messages": [{"role": "system", "content": "Ты продвинутый AI разработчик. Перед написанием кода ты анализируешь задачу внутри тегов <think>...</think>, затем пишешь чистый рабочий код."}, {"role": "user", "content": "Реализуйте систему мониторинга, где несколько корутин запускают таймеры с разными задержками, а одна общая корутина должна прервать их выполнение при наступлении события. Подвох заключается в том, что при использовании стандартного `asyncio.wait_for` или отмене задач через `cancel()`, некоторые таймеры могут завершить выполнение (выполнить свой блок `finally`) до того, как управление вернется в основной цикл. Определите, в каком порядке будут выведены сообщения в консоль, если время ожидания события меньше времени работы самого длинного таймера."}, {"role": "assistant", "content": "<think>\n**Анализ задачи:**\n\n1. **Суть проблемы:** В `asyncio` отмена задачи (`task.cancel()`) не является мгновенным убийством процесса. Она выбрасывает исключение `CancelledError` внутри корутины в следующей точке `await`. Если в корутине есть блоки `finally` или `except CancelledError`, они будут выполнены *после* того, как задача была помечена как отмененная, но *до* того, как основной цикл событий (event loop) полностью перейдет к следующей задаче, если эти блоки содержат `await`.\n\n2. **Алгоритм реализации:**\n * Создадим функцию `timer(name, delay)`, которая имитирует работу. Внутри будет `await asyncio.sleep(delay)`, а затем блок `finally`, который печатает сообщение о завершении.\n * Создадим функцию `monitor()`, которая запускает несколько таких таймеров и ждет \"события\" (например, `asyncio.sleep(event_delay)`).\n * При наступлении события `monitor` должен вызвать `cancel()` для всех запущенных задач.\n * Важно использовать `asyncio.gather(*tasks, return_exceptions=True)`, чтобы дождаться завершения всех задач (включая их блоки `finally`) после отмены.\n\n3. **Краевые случаи:**\n * Если `event_delay` меньше `delay` таймера, таймер должен прерваться.\n * Если `event_delay` больше `delay` таймера, таймер завершится штатно.\n * Порядок вывода в `finally` зависит от того, как быстро Event Loop обрабатывает исключение `CancelledError`.\n\n4. **Сложность:**\n * Временная сложность: $O(N)$, где $N$ — количество таймеров.\n * Пространственная сложность: $O(N)$ для хранения ссылок на задачи.\n\n5. **Ожидаемый порядок вывода:**\n 1. Сообщение о наступлении события.\n 2. Сообщения из блоков `finally` отмененных таймеров (порядок может варьироваться, но они будут идти после события).\n 3. Сообщение о завершении монитора.\n</think>\n\n```python\nimport asyncio\nimport time\n\nasync def timer(name: str, delay: float):\n \"\"\"\n Имитация таймера. \n Использует блок finally, чтобы продемонстрировать завершение очистки ресурсов.\n \"\"\"\n try:\n print(f\"[Timer {name}] Starting (delay: {delay}s)\")\n await asyncio.sleep(delay)\n print(f\"[Timer {name}] Completed naturally\")\n except asyncio.CancelledError:\n print(f\"[Timer {name}] Caught CancelledError!\")\n # Имитируем небольшую задержку на очистку ресурсов внутри finally\n await asyncio.sleep(0.1)\n raise\n finally:\n print(f\"[Timer {name}] Executing finally block (cleanup)\")\n\nasync def monitor(event_delay: float, timer_configs: list[tuple[str, float]]):\n \"\"\"\n Основная корутина мониторинга.\n Запускает таймеры и прерывает их по событию.\n \"\"\"\n print(f\"--- Monitor started. Event will occur in {event_delay}s ---\")\n \n # Создаем задачи для каждого таймера\n tasks = []\n for name, delay in timer_configs:\n task = asyncio.create_task(timer(name, delay))\n tasks.append(task)\n\n # Ждем наступления события\n await asyncio.sleep(event_delay)\n print(f\"\\n!!! EVENT TRIGGERED at {event_delay}s !!!\\n\")\n\n # Отменяем все задачи\n for task in tasks:\n task.cancel()\n\n # ВАЖНЫЙ МОМЕНТ: \n # Мы используем gather с return_exceptions=True, чтобы дождаться, \n # пока все задачи завершат свои блоки finally после отмены.\n # Если просто выйти из функции, выполнение может прерваться раньше, \n # чем отработают блоки finally в отмененных задачах.\n await asyncio.gather(*tasks, return_exceptions=True)\n \n print(\"--- Monitor finished cleanup ---\")\n\nasync def main():\n # Конфигурация: (Имя, Задержка)\n # Один таймер завершится сам, остальные будут прерваны.\n timer_configs = [\n (\"A\", 0.5), # Будет прерван\n (\"B\", 2.0), # Будет прерван\n (\"C\", 0.2), # Завершится штатно (0.2 < 1.0)\n ]\n \n # Событие произойдет через 1.0 секунду\n event_delay = 1.0\n\n start_time = time.perf_counter()\n await monitor(event_delay, timer_configs)\n end_time = time.perf_counter()\n\n print(f\"\\nTotal execution time: {end_time - start_time:.2f}s\")\n\nif __name__ == \"__main__\":\n asyncio.run(main())\n\n\"\"\"\nАНАЛИЗ ПОРЯДКА ВЫВОДА:\n\nПри запуске данного кода порядок будет следующим:\n\n1. [Timer A/B/C] Starting... - запуск всех таймеров.\n2. [Timer C] Completed naturally - так как 0.2 < 1.0, он успеет завершиться.\n3. !!! EVENT TRIGGERED !!! - срабатывает sleep(1.0) в мониторе.\n4. [Timer A/B] Caught CancelledError! - задачи получают сигнал отмены.\n5. [Timer A/B] Executing finally block - выполнение блоков очистки.\n6. --- Monitor finished cleanup --- - монитор завершается только ПОСЛЕ того, \n как gather дождался завершения всех finally.\n\nПодвох, упомянутый в условии, заключается в том, что если бы мы не использовали \nawait asyncio.gather(...), монитор мог бы завершиться (вывести \"Monitor finished\") \nДО того, как таймеры A и B успели бы вывести свои сообщения из блока finally, \nтак как управление вернулось бы в основной цикл сразу после вызова .cancel().\n\"\"\"\n```"}]}
|
| {"language": "ru", "category": "Обработка строк, срезы, форматирование и модуль re", "messages": [{"role": "system", "content": "Ты продвинутый AI разработчик. Перед написанием кода ты анализируешь задачу внутри тегов <think>...</think>, затем пишешь чистый рабочий код."}, {"role": "user", "content": "Напишите функцию, которая извлекает из строки все последовательности цифр, разделенные только спецсимволами, но игнорирует числа, если они являются частью слов (содержат буквы). При этом программа должна корректно обрабатывать случаи, когда число стоит в самом начале или в конце строки, а также обрабатывать «числа» с плавающей точкой, если они разделены точкой, которая сама является спецсимволом. Подвох заключается в том, как ваш регулярный запрос и срезы обработают ситуацию, когда спецсимвол является одновременно и разделителем, и частью структуры числа."}, {"role": "assistant", "content": "<think>\n**Анализ задачи:**\n\n1. **Цель:** Извлечь числа из строки.\n2. **Условие \"Число не является частью слова\":** Это ключевой момент. Если цифра окружена буквами (например, `abc123def`), она должна быть проигнорирована. Число должно быть отделено от букв границами слова или спецсимволами.\n3. **Условие \"Спецсимволы\":** Числа могут быть разделены спецсимволами (например, `123
|
| {"language": "ru", "category": "Алгоритмы поиска, сортировки и фильтрации в списках", "messages": [{"role": "system", "content": "Ты продвинутый AI разработчик. Перед написанием кода ты анализируешь задачу внутри тегов <think>...</think>, затем пишешь чистый рабочий код."}, {"role": "user", "content": "Дан список целых чисел, который необходимо отфильтровать, оставив только уникальные элементы, и отсортировать по возрастанию. Подвох заключается в том, что в исходных данных могут присутствовать числа, которые при поиске дубликатов ведут себя непредсказуемо из-за специфики типов (например, смешивание `True`/`False` с `1`/`0`). Ваша задача — реализовать алгоритм, который корректно разделит логические значения и числа, не объединяя их в один класс при сортировке и фильтрации."}, {"role": "assistant", "content": "<think>\n**Анализ задачи:**\n\n1. **Цель:** Отфильтровать список, оставив только уникальные элементы, и отсортировать их по возрастанию.\n2. **Проблема (Подвох):** В Python `True == 1` и `False == 0`. Стандартный метод `set()` или использование `unique` в библиотеках типа `numpy` объединит `True` и `1` в один элемент, так как их хеш-значения и значения равны. Нам нужно разделить \"чистые\" числа и логические значения.\n3. **Алгоритм решения:**\n * Пройти по исходному списку.\n * Для каждого элемента определить его тип.\n * Если элемент является логическим (`bool`), обрабатывать его отдельно.\n * Если элемент является числом (`int`, но *не* `bool`), обрабатывать его отдельно.\n * Использовать два разных множества (set) для хранения: одно для чисел, другое для булевых значений. Это гарантирует, что `1` и `True` попадут в разные коллекции.\n * После фильтрации объединить результаты. Однако, по условию задачи \"отсортировать по возрастанию\", нам нужно решить, в каком порядке они должны идти. Обычно логические значения в Python при приведении к int идут перед числами или после, но так как мы разделяем их, мы должны объединить их в один список и отсортировать.\n * **Важный нюанс сортировки:** Если мы объединим `[0, 1, True, False]` и будем сортировать, Python может выдать ошибку, если типы нельзя сравнивать (хотя `int` и `bool` сравнимы). Чтобы избежать неоднозначности и выполнить требование \"не объединять в один класс при фильтрации\", мы сначала фильтруем их в разные корзины, а затем объединяем для финальной сортировки.\n\n4. **Краевые случаи:**\n * Пустой список.\n * Список, состоящий только из `True`/`False`.\n * Список, состоящий только из чисел.\n * Смешанный список с `0`, `1`, `True`, `False`.\n * Числа с плавающей точкой (float), если они могут быть в списке (хотя в условии сказано \"целые числа\", лучше заложить логику для `int`).\n\n5. **Сложность:**\n * **Временная сложность:** $O(N \\log N)$ из-за финальной сортировки, где $N$ — количество уникальных элементов. Проход по списку занимает $O(N)$.\n * **Пространственная сложность:** $O(N)$ для хранения уникальных элементов в множествах.\n</think>\n\n```python\nfrom typing import List, Any\n\ndef filter_and_sort_unique(input_list: List[Any]) -> List[Any]:\n \"\"\"\n Фильтрует список, оставляя только уникальные элементы, \n строго разделяя bool (True/False) и int (0/1),\n и сортирует результат по возрастанию.\n \"\"\"\n \n # Используем два множества, чтобы избежать автоматического \n # объединения True/False с 1/0 (так как True == 1 в Python)\n unique_numbers = set()\n unique_bools = set()\n\n for item in input_list:\n # Важно: проверяем тип через type(), а не isinstance(), \n # так как isinstance(True, int) вернет True.\n if type(item) is bool:\n unique_bools.add(item)\n elif isinstance(item, int):\n unique_numbers.add(item)\n # Если в списке могут быть float, можно добавить обработку и для них\n elif isinstance(item, float):\n unique_numbers.add(item)\n\n # Объединяем отфильтрованные элементы\n # Мы преобразуем bool в числа только в момент сортировки, \n # если бы это было необходимо, но здесь мы просто объединяем списки.\n # Чтобы сохранить исходные типы (True вместо 1), объединяем наборы.\n result = list(unique_numbers) + list(unique_bools)\n\n # Сортировка. \n # Python позволяет сравнивать bool и int (True < 2, False < 0),\n # но для чистоты эксперимента и соблюдения логики \"разделения\",\n # мы сортируем их.\n result.sort()\n \n return result\n\n# --- Тестирование решения ---\n\ndef test_solution():\n test_cases = [\n {\n \"name\": \"Смешанный список (подвох)\",\n \"input\": [1, 2, 2, 1, True, False, 0, False, 1],\n \"expected\": [0, False, 1, True, 2] # Порядок может зависеть от реализации, \n # но 0 и False должны быть разделены при фильтрации.\n },\n {\n \"name\": \"Только числа\",\n \"input\": [10, 5, 10, 3, 1],\n \"expected\": [1, 3, 5, 10]\n },\n {\n \"name\": \"Только логические\",\n \"input\": [True, True, False, False],\n \"expected\": [False, True]\n },\n {\n \"name\": \"Пустой список\",\n \"input\": [],\n \"expected\": []\n },\n {\n \"name\": \"Сложный случай с 0 и False\",\n \"input\": [0, False, 1, True, 2, 0, False],\n \"expected\": [0, False, 1, True, 2]\n }\n ]\n\n for case in test_cases:\n actual = filter_and_sort_unique(case[\"input\"])\n \n # Проверка: в итоговом списке не должно быть дубликатов по значению, \n # но при этом True и 1 должны быть разделены.\n # Однако, стандартная сортировка Python [0, False, 1, True] \n # выстроит их в порядке возрастания значений.\n \n print(f\"Тест: {case['name']}\")\n print(f\" Вход: {case['input']}\")\n print(f\" Выход: {actual}\")\n \n # Проверка на уникальность\n```"}]}
|
| {"language": "ru", "category": "Работа с файлами, чтение и запись JSON, CSV, модуль pathlib", "messages": [{"role": "system", "content": "Ты продвинутый AI разработчик. Перед написанием кода ты анализируешь задачу внутри тегов <think>...</think>, затем пишешь чистый рабочий код."}, {"role": "user", "content": "Напишите скрипт, который сканирует директорию с помощью `pathlib`, собирает данные из всех файлов `.json` и `.csv` в единый список словарей и сохраняет результат в новый JSON-файл. Подвох заключается в том, что в папке могут встрежать файлы с одинаковыми именами, но разными расширениями, а также JSON-файлы, содержащие пустые списки или невалидные типы данных, которые должны быть проигнорированы без остановки программы. При записи итогового файла необходимо убедиться, что он не перезапишет существующие данные, если в целевой директории уже есть файл с таким же именем, но другим расширением."}, {"role": "assistant", "content": "<think>\n**Анализ задачи:**\n\n1. **Цель:** Сканирование директории, сбор данных из `.json` и `.csv` в один список словарей и сохранение в новый `.json` файл.\n2. **Инструментарий:** Использование `pathlib` для работы с путями.\n3. **Обработка данных:**\n * `.json`: Нужно загружать списки объектов. Если в JSON не список или он пуст — игнорировать.\n * `.csv`: Нужно читать строки как словари.\n * **Важно:** Обработка исключений (Invalid JSON, неверные типы, ошибки чтения), чтобы программа не падала.\n4. **Подвохи:**\n * Файлы с одинаковыми именами, но разными расширениями (например, `data.json` и `data.csv`) — `pathlib` корректно обрабатывает это через расширения, но нужно следить за логикой обхода.\n * Невалидные типы данных в JSON: если в файле не список (например, просто число или строка), его нужно пропустить.\n * Предотвращение перезаписи: Если целевой файл (например, `result.json`) уже существует, нужно изменить его имя (например, `result_1.json`, `result_2.json`), чтобы не потерять данные, если в папке есть файлы с таким же именем, но другим расширением (хотя по условию речь о том, чтобы не перезаписать существующий JSON-файл, если мы создаем новый).\n5. **Алгоритм:**\n * Инициализировать пустой список `master_list`.\n * Итерироваться по всем файлам в директории через `pathlib.Path.glob`.\n * Для каждого файла:\n * Если `.json`: try-except загрузка. Проверка `isinstance(data, list)` и `len(data) > 0`.\n * Если `.csv`: использовать `csv.DictReader`.\n * Генерация уникального имени для выходного файла.\n * Запись `master_list` в итоговый JSON.\n\n**Сложность:**\n* Временная: $O(N \\cdot M)$, где $N$ — количество файлов, $M$ — количество записей в файле. Мы посещаем каждый элемент один раз.\n* Пространственная: $O(K)$, где $K$ — общий объем данных во всех файлах (храним всё в памяти перед записью).\n\n**Краевые случаи:**\n* Директория пуста.\n* JSON содержит не список, а объект `{}` или примитив.\n* CSV файл с некорректной кодировкой.\n* Файл с тем же именем, что и целевой, но другим расширением (уже учтено в логике именования).\n</think>\n\n```python\nimport json\nimport csv\nfrom pathlib import Path\n\ndef collect_data_from_dir(directory_path: str, output_filename: str):\n \"\"\"\n Сканирует директорию, собирает данные из .json и .csv файлов \n и сохраняет в один итоговый JSON файл.\n \"\"\"\n base_dir = Path(directory_path)\n \n if not base_dir.exists() or not base_dir.is_dir():\n print(f\"Ошибка: Директория '{directory_path}' не существует или не является папкой.\")\n return\n\n master_list = []\n\n
|
| {"language": "en", "category": "File I/O, JSON, CSV parsing, and pathlib operations", "messages": [{"role": "system", "content": "You are an expert AI software engineer. You analyze problems inside <think>...</think> tags before writing clean, robust code."}, {"role": "user", "content": "**Problem Statement: The Fragmented Log Reconstructor**\n\nYou are tasked with writing a robust utility that scans a complex directory structure to consolidate fragmented system logs stored in varying formats (`.json` and `.csv`) into a single, unified master report. The system must handle inconsistent file encodings, malformed JSON structures that contain trailing commas, CSV files with mismatched column counts, and directory paths containing non-ASCII characters or symbolic links. Your solution must correctly merge data based on a shared timestamp key, ensuring that files with identical names in different subdirectories are processed without collisions and that \"ghost\" files (empty or zero-byte files) do not crash the pipeline."}, {"role": "assistant", "content": "<think>\n### Problem Analysis & Requirements\n\n1. **Directory Traversal**: Must handle nested directories, non-ASCII characters, and symbolic links. `os.walk` or `pathlib` are suitable.\n2. **File Filtering**: Only process `.json` and `.csv` files.\n3. **Robustness/Edge Cases**:\n * **Ghost Files**: 0-byte files must be skipped without error.\n * **Encoding**: Files might not be UTF-8. We should attempt UTF-8 and fallback to `latin-1` to prevent crashes.\n * **Malformed JSON**: Specifically mentioned \"trailing commas\". Standard `json.loads` fails on this. We can use `ast.literal_eval` or a regex-based approach, but for a \"senior engineer\" approach, a regex to strip trailing commas before parsing is a clean way to handle standard JSON with trailing commas.\n * **Mismatched CSV**: Some rows might have more/fewer columns. We must ensure we only extract the columns we need (timestamp and data).\n * **Collisions**: Files with the same name in different folders must be treated as unique entities.\n * **Merging**: Data must be merged based on a `timestamp` key.\n4. **Data Structure**: A dictionary/hash map where the key is the `timestamp` and the value is a dictionary of attributes collected from all sources.\n\n### Algorithm Design\n\n1. **Initialization**: Create a `MasterReport` dictionary: `Dict[str, Dict[str, Any]]`.\n2. **Traversal**:\n * Use `pathlib.Path.rglob` to find all files.\n * Check `is_file()` (handles symlinks correctly if they point to files).\n * Check `stat().st_size > 0`.\n3. **Parsing Logic**:\n * **JSON**: Read content $\\rightarrow$ strip trailing commas using regex `,\\s*([\\]}])` $\\rightarrow$ `json.loads`.\n * **CSV**: Use `csv.DictReader`. Wrap in a try-except to handle rows that don't match expected headers.\n4. **Merging Logic**:\n * For every record found:\n * `ts = record.pop('timestamp')`\n * `master_report[ts].update(record)`\n5. **Complexity**:\n * **Time Complexity**: $O(N \\cdot M)$, where $N$ is the total number of files and $M$ is the average number of entries per file. We visit every file and every row exactly once.\n * **Space Complexity**: $O(K)$, where $K$ is the total number of unique timestamps across all files.\n\n### Edge Cases Handled\n* `json.loads` failing on `{\"a\": 1,}` $\\rightarrow$ Handled via regex.\n* `UnicodeDecodeError` $\\rightarrow$ Handled via fallback encoding.\n* `KeyError` if `timestamp` is missing $\\rightarrow$ Skip record.\n* `ValueError` in CSV if columns are missing $\\rightarrow$ Handled via `DictReader` behavior.\n* Symlinks $\\rightarrow$ Handled by `pathlib`.\n</think>\n\n```python\nimport os\nimport json\nimport csv\nimport re\nimport logging\nfrom pathlib import Path\nfrom typing import Dict, Any, List, Union\n\n# Configure logging for production-grade observability\nlogging.basicConfig(\n level=logging.INFO,\n format='%(asctime)s - %(levelname)s - %(message)s'\n)\nlogger = logging.getLogger(__name__)\n\nclass LogReconstructor:\n \"\"\"\n A robust utility to consolidate fragmented JSON and CSV logs \n into a unified master report based on timestamps.\n \"\"\"\n\n def __init__(self, root_dir: str):\n self.root_dir = Path(root_dir)\n self.master_report: Dict[str, Dict[str, Any]] = {}\n # Regex to handle trailing commas in JSON: finds a comma followed by whitespace and a closing bracket/brace\n self.trailing_comma_regex = re.compile(r',\\s*([\\]}])')\n\n def _safe_read(self, file_path: Path) -> str:\n \"\"\"Attempts to read file using UTF-8, falls back to latin-1 to prevent crashes.\"\"\"\n for encoding in ['utf-8', 'latin-1']:\n try:\n return file_path.read_text(encoding=encoding)\n except (UnicodeDecodeError, PermissionError) as e:\n continue\n raise ValueError(f\"Could not decode file {file_path} with supported encodings.\")\n\n def _parse_json(self, content: str) -> List[Dict[str, Any]]:\n \"\"\"Parses JSON content, even if it contains trailing commas.\"\"\"\n try:\n # Fix trailing commas: [1, 2,] -> [1, 2]\n sanitized_content = self.trailing_comma_regex.sub(r'\\1', content)\n data = json.loads(sanitized_content)\n return data if isinstance(data, list) else [data]\n except json.JSONDecodeError as e:\n logger.error(f\"Malformed JSON encountered: {e}\")\n return []\n\n def _parse_csv(self, file_path: Path) -> List[Dict[str, Any]]:\n \"\"\"Parses CSV content using DictReader, handling potential encoding issues.\"\"\"\n records = []\n try:\n # We read the file and pass the string to StringIO to handle the encoding logic manually\n from io import StringIO\n content = self._safe_read(file_path)\n reader = csv.DictReader(StringIO(content))\n for row in reader:\n # DictReader handles mismatched columns by filling missing with None \n # or putting extra columns in a list under None key.\n records.append(dict(row))\n except Exception as e:\n logger.error(f\"Error parsing CSV {file_path}: {e}\")\n return records\n\n def _process_file(self, file_path: Path):\n \"\"\"Routes file to appropriate parser based on extension.\"\"\"\n # Skip ghost files (0 bytes)\n if file_path.stat().st_size == 0:\n logger.warning(f\"Skipping ghost file: {file_path}\")\n return\n\n ext = file_path.suffix.lower()\n records = []\n```"}]}
|
| {"language": "en", "category": "File I/O, JSON, CSV parsing, and pathlib operations", "messages": [{"role": "system", "content": "You are an expert AI software engineer. You analyze problems inside <think>...</think> tags before writing clean, robust code."}, {"role": "user", "content": "You are tasked with developing a data synchronization tool that merges multiple fragmented JSON configuration files into a single master CSV report. The system must traverse a directory structure using `pathlib`, resolve relative file paths, and handle nested JSON objects by flattening them into delimited columns. Your solution must gracefully handle inconsistent schema definitions across files, missing keys, and malformed CSV rows to ensure the final report is structurally sound."}, {"role": "assistant", "content": "<think>\n
|
| {"language": "en", "category": "Asynchronous programming with asyncio coroutines and tasks", "messages": [{"role": "system", "content": "You are an expert AI software engineer. You analyze problems inside <think>...</think> tags before writing clean, robust code."}, {"role": "user", "content": "**Problem Statement: The Synchronized Coffee Shop**\n\nYou are designing a simulation for a coffee shop where multiple orders must be processed concurrently using `asyncio`. You need to implement a system where several \"orders\" (coroutines) are launched as tasks, each with a specific simulated preparation time, but you must ensure the total execution time does not exceed a predefined deadline. \n\nThe challenge lies in handling \"timeout\" edge cases: if an order takes longer than the allotted time, it must be gracefully cancelled without crashing the entire event loop, and you must correctly distinguish between tasks that completed successfully and those that were aborted due to the timeout."}, {"role": "assistant", "content": "<think>\n### Problem Analysis\nThe goal is to simulate a concurrent coffee shop using `asyncio`. We need to launch multiple orders (tasks) with different durations and a global deadline. If a task exceeds the deadline, it must be cancelled gracefully. We need to track:\n1. Successful orders.\n2. Orders that timed out.\n\n### Algorithm & Approach\n1. **Task Definition**: Create a coroutine `process_order(order_id, duration)` that simulates work using `asyncio.sleep(duration)`.\n2. **Concurrency Logic**:\n * Use `asyncio.gather` or `asyncio.as_completed`? Since we need to handle individual timeouts relative to a global deadline, `asyncio.wait` with a `timeout` parameter is the most robust way to handle groups of tasks.\n * However, the problem asks for a \"predefined deadline\" for the *total execution*.\n * A cleaner approach is to wrap each task in `asyncio.wait_for(task, timeout=deadline)`.\n3. **Error Handling**:\n * When `asyncio.wait_for` reaches the timeout, it raises `asyncio.TimeoutError`.\n * We must catch this error per task to ensure one failure doesn't stop the others.\n4. **Data Structure**: Use a list of dictionaries or a custom class to store results.\n\n### Edge Cases\n* **Task duration exactly equals deadline**: Should be considered successful.\n* **Task duration > deadline**: Should be cancelled and marked as \"Timed Out\".\n* **Zero duration task**: Should be considered successful immediately.\n* **Empty order list**: Should return empty results without error.\n* **All tasks timeout**: Should return all as \"Timed Out\".\n\n### Complexity Analysis\n* **Time Complexity**: $O(N)$, where $N$ is the number of orders. Each task is awaited once.\n* **Space Complexity**: $O(N)$ to store the results of each order.\n\n### Implementation Details\n* Use `asyncio.create_task` to schedule the coroutines.\n* Use `asyncio.wait_for` to enforce the deadline on each specific task.\n* Use `try...except asyncio.TimeoutError` to distinguish between success and timeout.\n</think>\n\n```python\nimport asyncio\nimport time\nfrom typing import List, Dict, Any\n\nclass CoffeeShopSimulator:\n \"\"\"\n A simulator for a coffee shop using asyncio to manage concurrent orders\n with a strict deadline enforcement.\n \"\"\"\n\n def __init__(self, deadline: float):\n self.deadline = deadline\n self.results = []\n\n async def process_order(self, order_id: str, duration: float) -> Dict[str, Any]:\n \"\"\"\n Simulates the preparation of a single coffee order.\n \n Args:\n order_id: Unique identifier for the order.\n duration: Simulated time taken to prepare the coffee.\n \n Returns:\n A dictionary containing the order status and metadata.\n \"\"\"\n # We use asyncio.wait_for to wrap the sleep. \n # If sleep exceeds the deadline, it raises TimeoutError.\n try:\n # Simulate the work\n await asyncio.wait_for(asyncio.sleep(duration), timeout=self.deadline)\n \n return {\n \"order_id\": order_id,\n \"status\": \"SUCCESS\",\n \"duration\": duration\n }\n except asyncio.TimeoutError:\n return {\n \"order_id\": order_id,\n \"status\": \"TIMEOUT\",\n \"duration\": duration\n }\n except Exception as e:\n return {\n \"order_id\": order_id,\n \"status\": f\"ERROR: {str(e)}\",\n \"duration\": duration\n }\n\n async def run_service(self, orders: List[Dict[str, Any]]) -> List[Dict[str, Any]]:\n \"\"\"\n Runs all orders concurrently and collects results.\n \n Args:\n orders: A list of dictionaries containing 'id' and 'time'.\n \n Returns:\n A list of results for all orders processed.\n \"\"\"\n start_time = time.perf_counter()\n \n # Create a list of tasks (coroutines wrapped in tasks)\n tasks = [\n self.process_order(order['id'], order['time']) \n for order in orders\n ]\n \n # asyncio.gather runs tasks concurrently and waits for all to finish.\n # Because we handled TimeoutError inside process_order, \n # gather will not raise an exception.\n results = await asyncio.gather(*tasks)\n \n end_time = time.perf_counter()\n total_elapsed = end_time - start_time\n \n print(f\"--- Simulation Finished in {total_elapsed:.2f}s ---\")\n self._print_summary(results)\n \n return results\n\n def _print_summary(self, results: List[Dict[str, Any]]):\n success_count = sum(1 for r in results if r['status'] == \"SUCCESS\")\n timeout_count = sum(1 for r in results if r['status'] == \"TIMEOUT\")\n \n print(f\"Successful Orders: {success_count}\")\n print(f\"Timed Out Orders: {timeout_count}\")\n print(\"-\" * 40)\n\nasync def main():\n # Configuration\n # Deadline is 3.0 seconds.\n DEADLINE = 3.0\n \n # Order List:\n # 1. Quick coffee (1s) -> Success\n # 2. Medium coffee (2.5s) -> Success\n # 3. Complex latte (5s) -> Timeout\n # 4. Instant espresso (0.5s) -> Success\n # 5. Extremely slow drink (10s) -> Timeout\n orders_to_process = [\n {\"id\": \"Order_001\", \"time\": 1.0},\n {\"id\": \"Order_002\", \"time\": 2.5},\n {\"id\": \"Order_003\", \"time\": 5.0},\n {\"id\": \"Order_004\", \"time\": 0.5},\n {\"id\": \"Order_005\", \"time\": 10.0},\n ]\n\n simulator = CoffeeShopSimulator(deadline=DEADLINE)\n \n print(f\"Starting coffee shop simulation with a {DEADLINE}s deadline...\")\n```"}]}
|
| {"language": "en", "category": "OOP: classes, inheritance, polymorphism, and dunder methods", "messages": [{"role": "system", "content": "You are an expert AI software engineer. You analyze problems inside <think>...</think> tags before writing clean, robust code."}, {"role": "user", "content": "Design a hierarchy of `Shape` classes where each subclass implements a `calculate_area` method and a custom `__str__` representation. Your system must support polymorphic behavior when iterating through a list of different shapes and must handle an edge case where a shape's dimensions are zero or negative. Ensure that adding two shapes together using the `__add__` dunder method returns a new shape representing the combined area."}, {"role": "assistant", "content": "<think>\n### Problem Breakdown\n\n1. **Class Hierarchy**:\n * `Shape` (Abstract Base Class): Defines the interface for `calculate_area` and `__str__`.\n * `Circle`, `Rectangle`, `Triangle` (Concrete Subclasses): Implement specific area formulas.\n\n2. **Core Requirements**:\n * **Polymorphism**: A list containing various shapes should be iterable, calling `calculate_area()` on each regardless of its specific type.\n * **Error Handling (Edge Cases)**: Dimensions must be positive. If zero or negative, the class should raise a `ValueError`.\n * **Operator Overloading**: The `__add__` method must be implemented. Adding two shapes should return a new shape (or a specialized `CombinedArea` object) representing the sum of their areas.\n\n3. **Algorithm & Logic**:\n * **Circle Area**: $\\pi \\times r^2$\n * **Rectangle Area**: $w \\times h$\n * **Triangle Area**: $0.5 \\times b \\times h$\n * **Addition**: Since the result of adding two shapes isn't a standard geometric shape (it's just a scalar value representing area), I will implement a `CombinedArea` class that inherits from `Shape` to maintain polymorphism.\n\n4. **Complexity Analysis**:\n * **Time Complexity**: \n * `calculate_area`: $O(1)$ - Constant time mathematical operations.\n * `__add__`: $O(1)$ - Constant time.\n * Iterating through $N$ shapes: $O(N)$.\n * **Space Complexity**: $O(1)$ per object instance.\n\n5. **Edge Cases**:\n * Radius $\\le 0$.\n * Width/Height $\\le 0$.\n * Base/Height $\\le 0$.\n * Adding a shape to itself.\n</think>\n\n```python\nfrom abc import ABC, abstractmethod\nimport math\n\nclass Shape(ABC):\n \"\"\"Abstract Base Class for all shapes.\"\"\"\n\n @abstractmethod\n def calculate_area(self) -> float:\n \"\"\"Calculate the area of the shape.\"\"\"\n pass\n\n @abstractmethod\n def __str__(self) -> str:\n \"\"\"Return a string representation of the shape.\"\"\"\n pass\n\n def __add__(self, other: 'Shape') -> 'CombinedArea':\n \"\"\"\n Overloads the + operator.\n Returns a CombinedArea object representing the sum of areas.\n \"\"\"\n if not isinstance(other, Shape):\n raise TypeError(f\"Cannot add Shape with {type(other).__name__}\")\n \n total_area = self.calculate_area() + other.calculate_area()\n return CombinedArea(total_area)\n\n\nclass CombinedArea(Shape):\n \"\"\"A special shape representing the sum of two areas.\"\"\"\n \n def __init__(self, area: float):\n self._area = area\n\n def calculate_area(self) -> float:\n return self._area\n\n def __str__(self) -> str:\n return f\"Combined Area: {self._area:.2f}\"\n\n\nclass Circle(Shape):\n def __init__(self, radius: float):\n if radius <= 0:\n raise ValueError(\"Radius must be a positive number.\")\n self.radius = radius\n\n def calculate_area(self) -> float:\n return math.pi * (self.radius ** 2)\n\n def __str__(self) -> str:\n return f\"Circle(radius={self.radius})\"\n\n\nclass Rectangle(Shape):\n def __init__(self, width: float, height: float):\n if width <= 0 or height <= 0:\n raise ValueError(\"Width and height must be positive numbers.\")\n self.width = width\n self.height = height\n\n def calculate_area(self) -> float:\n return self.width * self.height\n\n def __str__(self) -> str:\n return f\"Rectangle(w={self.width}, h={self.height})\"\n\n\nclass Triangle(Shape):\n def __init__(self, base: float, height: float):\n if base <= 0 or height <= 0:\n raise ValueError(\"Base and height must be positive numbers.\")\n self.base = base\n self.height = height\n\n def calculate_area(self) -> float:\n return 0.5 * self.base * self.height\n\n def __str__(self) -> str:\n return f\"Triangle(base={self.base}, height={self.height})\"\n\n\ndef main():\n # 1. Demonstrate Polymorphism\n shapes = [\n Circle(5),\n Rectangle(10, 4),\n Triangle(6, 3),\n Circle(2.5)\n ]\n\n print(\"--- Polymorphic Iteration ---\")\n for shape in shapes:\n # Polymorphic call to calculate_area and __str__\n print(f\"{shape} | Area: {shape.calculate_area():.2f}\")\n\n # 2. Demonstrate Addition (Operator Overloading)\n print(\"\\n--- Addition (Operator Overloading) ---\")\n rect = Rectangle(10, 5)\n circ = Circle(3)\n combined = rect + circ\n print(f\"Rectangle Area: {rect.calculate_area():.2f}\")\n print(f\"Circle Area: {circ.calculate_area():.2f}\")\n print(f\"Result of addition: {combined}\")\n\n # 3. Demonstrate Edge Case Handling (Error Handling)\n print(\"\\n--- Edge Case Handling ---\")\n try:\n print(\"Attempting to create a Circle with radius -1...\")\n invalid_circle = Circle(-1)\n except ValueError as e:\n print(f\"Caught expected error: {e}\")\n\n try:\n print(\"Attempting to create a Rectangle with width 0...\")\n invalid_rect = Rectangle(0, 10)\n except ValueError as e:\n print(f\"Caught expected error: {e}\")\n\nif __name__ == \"__main__\":\n main()\n```"}]}
|
| {"language": "ru", "category": "Алгоритмы поиска, сортировки и фильтрации в списках", "messages": [{"role": "system", "content": "Ты продвинутый AI разработчик. Перед написанием кода ты анализируешь задачу внутри тегов <think>...</think>, затем пишешь чистый рабочий код."}, {"role": "user", "content": "Дан список цен на товары, где некоторые значения могут быть отрицательными (из-за скидок или бонусов) или равными нулю. Вам необходимо найти минимальную сумму трех **различных** по значению элементов, которые при этом должны быть строго больше среднего арифметического всех положительных чисел в списке. Учтите, что если в списке недостаточно подходящих элементов или отсутствуют положительные числа, функция должна вернуть `None`."}, {"role": "assistant", "content": "<think>\n### Анализ задачи\n\n**Условие:**\n1. **Входные данные:** Список цен (числа: положительные, отрицательные, нули).\n2. **Целевое значение (Threshold):** Среднее арифметическое всех **положительных** чисел в списке.\n3. **Условие выбора элементов:**\n - Элементы должны быть **строго больше** среднего арифметического.\n - Элементы должны быть **различными по значению** (уникальные).\n4. **Цель:** Найти минимальную сумму **трех** таких элементов.\n5. **Краевые случаи (возврат `None`):**\n - В списке нет положительных чисел.\n - После фильтрации по условию \"строго больше среднего\" осталось менее 3 уникальных элементов.\n\n**Алгоритм:**\n1. Отфильтровать список, оставив только числа $> 0$.\n2. Если список положительных чисел пуст, вернуть `None`.\n3. Вычислить среднее арифметическое положительных чисел: `sum(positives) / len(positives)`.\n4. Отфильтровать исходный список: оставить только уникальные значения (используем `set`), которые строго больше вычисленного среднего.\n5. Преобразовать отфильтрованный набор обратно в список и отсортировать его по возрастанию.\n6. Если длина отфильтрованного списка $< 3$, вернуть `None`.\n7. Взять первые три элемента (они будут минимальными из подходящих) и вернуть их сумму.\n\n**Сложность:**\n- **Временная сложность:** $O(N)$, где $N$ — количество элементов в списке (для фильтрации и вычисления суммы). Сортировка отфильтрованных элементов займет $O(K \\log K)$, где $K$ — количество уникальных подходящих элементов. В худшем случае $K \\le N$. Итого $O(N \\log N)$.\n- **Пространственная сложность:** $O(N)$ для хранения отфильтрованных уникальных элементов.\n</think>\n\n```python\nfrom typing import List, Optional\n\ndef find_min_sum_of_three_distinct(prices: List[float]) -> Optional[float]:\n \"\"\"\n Находит минимальную сумму трех различных элементов, которые строго больше \n среднего арифметического всех положительных чисел в списке.\n \"\"\"\n \n # 1. Находим все положительные числа\n positives = [p for p in prices if p > 0]\n \n # 2. Если положительных чисел нет, возвращаем None\n if not positives:\n return None\n \n # 3. Вычисляем среднее арифметическое положительных чисел\n avg_positive = sum(positives) / len(positives)\n \n # 4. Находим уникальные элементы, которые строго больше среднего\n # Используем set для обеспечения уникальности по значению\n candidates = {p for p in prices if p > avg_positive}\n \n # 5. Проверяем, достаточно ли нам подходящих элементов\n if len(candidates) < 3:\n return None\n \n # 6. Сортируем кандидатов по возрастанию, чтобы выбрать три минимальных\n sorted_candidates = sorted(list(candidates))\n \n # 7. Возвращаем сумму первых трех (минимальных) элементов\n return sum(sorted_candidates[:3])\n\n# --- Тестирование решения ---\n\nif __name__ == \"__main__\":\n test_cases = [\n {\n \"name\": \"Стандартный случай\",\n \"input\": [10, 20, 30, 40, 50, -5, 0, 10], \n # Положительные: 10, 20, 30, 40, 50, 10. Среднее: 160/6 = 26.66\n # Кандидаты (> 26.66): 30, 40, 50. Сумма: 120\n \"expected\": 120\n },\n {\n \"name\": \"Недостаточно элементов\",\n \"input\": [10, 20, 30, 5, 2], \n # Положительные: 10, 20, 30, 5, 2. Среднее: 67/5 = 13.4\n # Кандидаты (> 13.4): 20, 30. (Всего 2)\n \"expected\": None\n },\n {\n \"name\": \"Нет положительных чисел\",\n \"input\": [0, -1, -5, -10],\n \"expected\": None\n },\n {\n \"name\": \"Дубликаты не должны считаться дважды\",\n \"input\": [10, 10, 10, 50, 60, 70],\n # Положительные: 10, 10, 10, 50, 60, 70. Среднее: 210/6 = 35\n # Кандидаты (> 35): 50, 60, 70. Сумма: 180\n \"expected\": 180\n },\n {\n \"name\": \"Сложный случай с отрицательными и нулями\",\n \"input\": [10, -10, 0, 20, 30, 40, 5, 5],\n # Положительные: 10, 20, 30, 40, 5, 5. Среднее: 110/6 = 18.33\n # Кандидаты (> 18.33): 20, 30, 40. Сумма: 90\n \"expected\": 90\n }\n ]\n\n for case in test_cases:\n result = find_min_sum_of_three_distinct(case[\"input\"])\n status = \"PASSED\" if result == case[\"expected\"] else f\"FAILED (got {result})\"\n print(f\"Test '{case['name']}': {status}\")\n```"}]}
|
| {"language": "en", "category": "Dictionaries, sets, Counter, and defaultdict data structures", "messages": [{"role": "system", "content": "You are an expert AI software engineer. You analyze problems inside <think>...</think> tags before writing clean, robust code."}, {"role": "user", "content": "You are given a list of usernames and a list of \"active\" status flags. Your task is to identify which users are unique, which users appear multiple times, and which users are strictly active, returning a summary of these counts. You must handle cases where users might have no activity flags, where the input list is empty, or where users appear in the active list but not in the original username list."}, {"role": "assistant", "content": "<think>\n### Problem Breakdown\n\n**Goal:**\nAnalyze two lists: `usernames` (list of strings) and `active_flags` (list of booleans/status indicators). We need to categorize users based on their frequency and their activity status.\n\n**Requirements:**\n1. **Unique Users:** Users who appear exactly once in the `usernames` list.\n2. **Duplicate Users:** Users who appear more than once in the `usernames` list.\n3. **Strictly Active Users:** Users who are marked as \"active\" (True) in the `active_flags` list.\n * *Constraint Check:* The problem implies a mapping between `usernames` and `active_flags`. However, since the lists might have different lengths or users might appear in one but not the other, I will interpret \"Strictly Active\" as: A user is considered active if they appear in the `usernames` list AND have a corresponding `True` in the `active_flags` list at the same index.\n * *Edge Case Handling:* If `active_flags` is shorter than `usernames`, the extra users are treated as inactive. If `active_flags` is longer, the extra flags are ignored (as they don't map to a user).\n\n**Edge Cases:**\n1. **Empty Inputs:** `usernames = []` or `active_flags = []`. Should return zeros.\n2. **Mismatching Lengths:** `len(usernames) != len(active_flags)`.\n3. **User in `active_flags` but not `usernames`:** These should be ignored because they don't represent a valid user entity in the context of the primary list.\n4. **All users are duplicates:** `unique_count` should be 0.\n5. **No active users:** `active_count` should be 0.\n\n**Algorithm:**\n1. Initialize a dictionary `user_counts` to store the frequency of each username.\n2. Initialize a set `active_users` to store unique names of users who were marked active.\n3. Iterate through `usernames` using `enumerate` to keep track of the index.\n4. For each user at index `i`:\n * Increment `user_counts[user]`.\n * If `i < len(active_flags)` and `active_flags[i]` is `True`, add the user to `active_users`.\n5. Calculate results:\n * `unique_count`: Count keys in `user_counts` where value is `1`.\n * `duplicate_count`: Count keys in `user_counts` where value is `> 1`.\n * `active_count`: The number of unique users who had at least one \"True\" flag associated with them.\n\n**Complexity Analysis:**\n* **Time Complexity:** $O(N)$, where $N$ is the length of the `usernames` list. We iterate through the list once.\n* **Space Complexity:** $O(U)$, where $U$ is the number of unique users, to store counts and the active set.\n</think>\n\n```python\nfrom typing import List, Dict, Any\n\ndef analyze_user_activity(usernames: List[str], active_flags: List[bool]) -> Dict[str, int]:\n \"\"\"\n Analyzes usernames and active status flags to return counts of \n unique, duplicate, and strictly active users.\n\n Args:\n usernames: A list of strings representing user identities.\n active_flags: A list of booleans representing the activity status \n of the user at the corresponding index.\n\n Returns:\n A dictionary containing:\n - 'unique_users': Count of users appearing exactly once.\n - 'duplicate_users': Count of users appearing more than once.\n - 'strictly_active_users': Count of unique users who have at least \n one 'True' flag in the active_flags list.\n \"\"\"\n # Handle empty input case\n if not usernames:\n return {\n \"unique_users\": 0,\n \"duplicate_users\": 0,\n \"strictly_active_users\": 0\n }\n\n user_frequency = {}\n # We use a set for active users to ensure we count a user once \n # even if they appear multiple times and are active multiple times.\n active_user_set = set()\n\n # Iterate through usernames and map them to their flags\n for i, user in enumerate(usernames):\n # Update frequency count\n user_frequency[user] = user_frequency.get(user, 0) + 1\n \n # Check if the user has an active flag at this index\n # We check bounds to handle cases where active_flags is shorter than usernames\n if i < len(active_flags) and active_flags[i] is True:\n active_user_set.add(user)\n\n unique_count = 0\n duplicate_count = 0\n\n # Calculate unique and duplicate counts based on frequency dictionary\n for count in user_frequency.values():\n if count == 1:\n unique_count += 1\n elif count > 1:\n duplicate_count += 1\n\n return {\n \"unique_users\": unique_count,\n \"duplicate_users\": duplicate_count,\n \"strictly_active_users\": len(active_user_set)\n }\n\n# --- Test Suite ---\n```"}]}
|
| {"language": "ru", "category": "Математические вычисления, простые числа, факториалы, НОД", "messages": [{"role": "system", "content": "Ты продвинутый AI разработчик. Перед написанием кода ты анализируешь задачу внутри тегов <think>...</think>, затем пишешь чистый рабочий код."}, {"role": "user", "content": "Напишите функцию, которая принимает целое число $N$ и возвращает произведение всех простых чисел, входящих в разложение числа $N$ на множители, но только если это произведение не делится на $N$ без остатка. Если $N$ не имеет простых делителей (например, $N \\le 1$) или условие делимости не выполняется, функция должна вернуть 0. Учтите, что в разложении могут встречаться кратные простые множители, которые должны учитываться в проверке условия только один раз."}, {"role": "assistant", "content": "<think>\n**Анализ задачи:**\n\n1. **Входные данные:** Целое число $N$.\n2. **Цель:** Найти произведение всех *уникальных* простых множителей числа $N$.\n3. **Условие:**\n * Пусть $P$ — произведение всех различных простых множителей $N$.\n * Если $P$ не делится на $N$ без остатка ($P \\pmod N \\neq 0$), вернуть $P$.\n * В противном случае (если $P$ делится на $N$ или $N \\le 1$), вернуть $0$.\n4. **Важное уточнение:** В условии сказано: \"произведение всех простых чисел, входящих в разложение... но только если это произведение не делится на $N$\". Также добавлено: \"кратные простые множители... должны учитываться в проверке условия только один раз\". Это означает, что мы ищем так называемое *радикал* числа $\\text{rad}(N)$, который является произведением всех его простых делителей в первой степени.\n\n**Алгоритм:**\n1. Если $N \\le 1$, вернуть $0$.\n2. Найти все уникальные простые делители числа $N$.\n * Используем классический алгоритм разложения: перебираем делители от 2 до $\\sqrt{N}$.\n * Если число делится на $d$, добавляем $d$ в список уникальных делителей и делим $N$ на $d$ до тех пор, пока оно делится.\n3. Вычислить произведение всех найденных уникальных простых делителей ($P$).\n4. Проверить условие: если $P \\% N \\neq 0$, вернуть $P$, иначе вернуть $0$.\n\n**Краевые случаи:**\n* $N \\le 1$: Должно вернуть $0$.\n* $N$ — простое число: $P = N$. $N \\% N == 0$, значит вернет $0$.\n* $N$ — произведение разных простых чисел (например, $6 = 2 \\times 3$): $P = 6$. $6 \\% 6 == 0$, вернет $0$.\n* $N$ — степень простого числа (например, $8 = 2^3$): $P = 2$. $2 \\% 8 \\neq 0$, вернет $2$.\n* $N$ — число с кратными множителями (например, $12 = 2^2 \\times 3$): $P = 2 \\times 3 = 6$. $6 \\% 12 \\neq 0$, вернет $6$.\n\n**Сложность:**\n* **Временная сложность:** $O(\\sqrt{N})$ для нахождения простых делителей.\n* **Пространственная сложность:** $O(k)$, где $k$ — количество уникальных простых делителей (очень мало для стандартных типов данных).\n</think>\n\n```python\ndef solve_prime_product(n: int) -> int:\n \"\"\"\n Вычисляет произведение всех уникальных простых делителей числа N,\n если это произведение не делится на N без остатка.\n \n Args:\n n (int): Входное целое число.\n \n Returns:\n int: Произведение уникальных простых делителей или 0.\n \"\"\"\n # Условие: если N <= 1, простых делителей нет\n if n <= 1:\n return 0\n\n original_n = n\n prime_factors = []\n d = 2\n temp_n = n\n\n # Алгоритм нахождения уникальных простых делителей\n # Идем до корня из temp_n\n while d * d <= temp_n:\n if temp_n % d == 0:\n prime_factors.append(d)\n # Делим temp_n на d до упора, чтобы убрать кратность\n while temp_n % d == 0:\n temp_n //= d\n d += 1\n \n # Если после цикла осталось число > 1, значит оно само является простым\n if temp_n > 1:\n prime_factors.append(temp_n)\n\n # Вычисляем произведение уникальных простых множителей (радикал числа)\n product = 1\n for p in prime_factors:\n product *= p\n\n # Проверка условия: произведение не должно делиться на N без остатка\n # (product % original_n != 0)\n # Примечание: если N - простое или произведение разных простых, \n # то product будет равен N, и условие (N % N != 0) даст False, вернется 0.\n if product % original_n != 0:\n return product\n else:\n return 0\n\n# Тестирование функции\nif __name__ == \"__main__\":\n test_cases = [\n (12, 6), # 12 = 2^2 * 3. Уникальные: 2, 3. Произведение = 6. 6 % 12 != 0. Ок.\n (8, 2), # 8 = 2^3. Уникальный: 2. Произведение = 2. 2 % 8 != 0. Ок.\n (6, 0), # 6 = 2 * 3. Уникальные: 2, 3. Произведение = 6. 6 % 6 == 0. Вернуть 0.\n (7, 0), # 7 - простое. Уникальный: 7. Произведение = 7. 7 % 7 == 0. Вернуть 0.\n (1, 0), # N <= 1. Вернуть 0.\n (30, 0), # 30 = 2 * 3 * 5. Произведение = 30. 30 % 30 == 0. Вернуть 0.\n (100, 10), # 100 = 2^2 * 5^2. Уникальные: 2, 5. Произведение = 10. 10 % 100 != 0. Ок.\n ]\n\n print(f\"{'N':<10} | {'Expected':<10} | {'Result':<10} | {'Status'}\")\n print(\"-\" * 50)\n```"}]}
|
| {"language": "ru", "category": "Алгоритмы поиска, сортировки и фильтрации в списках", "messages": [{"role": "system", "content": "Ты продвинутый AI разработчик. Перед написанием кода ты анализируешь задачу внутри тегов <think>...</think>, затем пишешь чистый рабочий код."}, {"role": "user", "content": "Дан список целых чисел, где некоторые элементы могут дублироваться или быть отрицательными. Вам необходимо отфильтровать только положительные числа, отсортировать их по убыванию и вернуть новый список, но если после фильтрации список оказался пустым или все числа в нем одинаковые, верните специальное значение `-1`. Учтите, что исходный список нельзя изменять."}, {"role": "assistant", "content": "<think>\n**Анализ задачи:**\n\n1. **Входные данные:** Список целых чисел (могут быть отрицательные, нули, дубликаты).\n2. **Шаги алгоритма:**\n * **Фильтрация:** Извлечь только числа $> 0$.\n * **Проверка на пустоту:** Если после фильтрации список пуст, вернуть `-1`.\n * **Проверка на однородность:** Если все элементы в отфильтрованном списке одинаковы, вернуть `-1`.\n * **Сортировка:** Отсортировать полученные положительные числа по убыванию.\n * **Иммутабельность:** Исходный список не должен изменяться (использование list comprehension или `filter` автоматически создает новый объект).\n3. **Краевые случаи:**\n * Пустой входной список $\\to$ `-1`.\n * Список только с отрицательными числами или нулями $\\to$ `-1`.\n * Список с одним положительным числом $\\to$ `-1` (так как по условию \"все числа в нем одинаковые\", а одно число технически делает все элементы в списке идентичными). *Примечание: В логике программирования \"все элементы одинаковы\" для списка из одного элемента истинно.*\n * Список с дубликатами положительных чисел (например, `[5, 5, 5]`) $\\to$ `-1`.\n * Список с разными положительными числами (например, `[5, 5, 2]`) $\\to$ `[5, 5, 2]`.\n4. **Сложность:**\n * **Временная сложность:** $O(N \\log N)$ из-за сортировки, где $N$ — количество положительных чисел. Фильтрация и проверка занимают $O(N)$.\n * **Пространственная сложность:** $O(N)$ для хранения нового отфильтрованного списка.\n</think>\n\n```python\nfrom typing import List, Union\n\ndef process_numbers(nums: List[int]) -> Union[List[int], int]:\n \"\"\"\n Фильтрует положительные числа, сортирует их по убыванию.\n Возвращает -1, если список пуст или все числа в нем одинаковы.\n Исходный список не изменяется.\n \"\"\"\n \n # 1. Фильтрация: создаем новый список только с положительными числами (> 0)\n # Это гарантирует, что исходный список nums остается нетронутым.\n positive_nums = [x for x in nums if x > 0]\n \n # 2. Проверка на пустоту\n if not positive_nums:\n return -1\n \n # 3. Проверка на однородность (все ли числа одинаковы)\n # Используем set(), так как если в множестве только один элемент, \n # значит все элементы исходного списка были идентичны.\n if len(set(positive_nums)) <= 1:\n return -1\n \n # 4. Сортировка по убыванию\n # sorted() возвращает новый список, не меняя positive_nums\n sorted_nums = sorted(positive_nums, reverse=True)\n \n return sorted_nums\n\n# --- Тестирование функции ---\n\ndef test_solution():\n test_cases = [\n ([1, -2, 3, 0, 5, -1, 3], [5, 3, 3, 1], \"Стандартный случай с дубликатами\"),\n ([10, 20, 30], [30, 20, 10], \"Все разные положительные\"),\n ([-1, -5, 0], -1, \"Только отрицательные и нули\"),\n ([5, 5, 5, 5], -1, \"Все положительные одинаковые\"),\n ([7], -1, \"Один положительный элемент (одинаковые)\"),\n ([], -1, \"Пустой входной список\"),\n ([1, 2, 2, 1], [2, 2, 1, 1], \"Дубликаты, но разные числа\"),\n ([10, -10, 10], -1, \"Дубликаты, но все положительные одинаковы\"),\n ]\n\n for i, (inp, expected, desc) in enumerate(test_cases):\n # Копируем вход для проверки иммутабельности\n original_copy = list(inp)\n result = process_numbers(inp)\n \n assert result == expected, f\"Ошибка в тесте {i} ({desc}): ожидалось {expected}, получили {result}\"\n assert inp == original_copy, f\"Ошибка в тесте {i} ({desc}): исходный список был изменен!\"\n \n print(f\"Тест {i+1} пройден: {desc} | Вход: {inp} -> Выход: {result}\")\n\nif __name__ == \"__main__\":\n test_solution()\n```"}]}
|
| {"language": "ru", "category": "Алгоритмы поиска, сортировки и фильтрации в списках", "messages": [{"role": "system", "content": "Ты продвинутый AI разработчик. Перед написанием кода ты анализируешь задачу внутри тегов <think>...</think>, затем пишешь чистый рабочий код."}, {"role": "user", "content": "Дан список целых чисел, где некоторые элементы могут дублироваться или быть отрицательными. Вам необходимо отфильтровать только положительные числа, отсортировать их по убыванию, а затем найти в полученном списке первое число, которое встречается в исходном списке строго менее двух раз. Учтите, что если подходящее число не найдено или список после фильтрации пуст, функция должна вернуть `None`."}, {"role": "assistant", "content": "<think>\n**Анализ задачи:**\n\n1. **Входные данные:** Список целых чисел (могут быть отрицательными, нулями, дубликатами).\n2. **Шаги алгоритма:**\n * **Фильтрация:** Оставить только числа $> 0$.\n * **Сортировка:** Отсортировать отфильтрованные числа по убыванию.\n * **Подсчет частоты:** Нужно знать, сколько раз каждое число встречается в *исходном* списке.\n * **Поиск:** Пройти по отсортированному списку и найти первое число, частота которого в исходном списке $< 2$ (т.е. встречается 1 раз).\n * **Краевые случаи:**\n * Пустой список на входе $\\rightarrow$ `None`.\n * После фильтрации список пуст $\\rightarrow$ `None`.\n * Все положительные числа встречаются $\\ge 2$ раз $\\rightarrow$ `None`.\n * Список содержит только отрицательные числа $\\rightarrow$ `None`.\n\n**Сложность:**\n* **Временная сложность:** $O(N \\log N)$ из-за сортировки, где $N$ — количество элементов. Подсчет частот через `collections.Counter` занимает $O(N)$. Проход по списку — $O(N)$. Итоговая сложность: $O(N \\log N)$.\n* **Пространственная сложность:** $O(N)$ для хранения словаря частот и отфильтрованного списка.\n\n**Алгоритм реализации:**\n1. Использовать `collections.Counter` для подсчета всех элементов в исходном списке.\n2. Создать новый список `positive_numbers`, содержащий только элементы $> 0$ из исходного списка.\n3. Отсортировать `positive_numbers` с помощью `sort(reverse=True)`.\n4. Итерироваться по `positive_numbers` и проверять `counts[num] < 2`.\n5. Вернуть первый найденный элемент или `None`.\n</think>\n\n```python\nfrom collections import Counter\nfrom typing import List, Optional\n\ndef find_unique_positive_descending(numbers: List[int]) -> Optional[int]:\n \"\"\"\n Фильтрует положительные числа, сортирует их по убыванию и находит \n первое число, которое встречается в исходном списке строго менее двух раз.\n \"\"\"\n \n # 1. Если список пуст, возвращаем None\n if not numbers:\n return None\n\n # 2. Считаем частоту каждого числа в исходном списке\n # Это необходимо для проверки условия \"встречается строго менее двух раз\"\n counts = Counter(numbers)\n\n # 3. Фильтруем только положительные числа (> 0)\n # Важно: используем исходный список для фильтрации\n positive_numbers = [x for x in numbers if x > 0]\n\n # 4. Если после фильтрации список пуст, возвращаем None\n if not positive_numbers:\n return None\n\n # 5. Сортируем отфильтрованные числа по убыванию\n positive_numbers.sort(reverse=True)\n\n # 6. Ищем первое число в отсортированном списке, \n # которое в исходном списке встретилось < 2 раз\n for num in positive_numbers:\n if counts[num] < 2:\n return num\n\n # 7. Если подходящее число не найдено\n return None\n\n# --- Тестовые сценарии ---\nif __name__ == \"__main__\":\n test_cases = [\n {\n \"input\": [10, -5, 3, 10, 2, 3, 8, 0, 1],\n \"expected\": 8, \n \"desc\": \"Стандартный случай: 8 - первое уникальное положительное при убывании\"\n },\n {\n \"input\": [5, 5, 4, 4, 3, 3, 2, 2],\n \"expected\": None,\n \"desc\": \"Все положительные числа дублируются\"\n },\n {\n \"input\": [-1, -2, 0, -5],\n \"expected\": None,\n \"desc\": \"Нет положительных чисел\"\n },\n {\n \"input\": [10, 20, 30, 10, 20, 30],\n \"expected\": None,\n \"desc\": \"Все числа в исходном списке дублируются\"\n },\n {\n \"input\": [1, 2, 2, 3, 3, 3, 4, 4, 5],\n \"expected\": 5,\n \"desc\": \"Первое уникальное при убывании - 5\"\n },\n {\n \"input\": [],\n \"expected\": None,\n \"desc\": \"Пустой входной список\"\n }\n ]\n\n for i, case in enumerate(test_cases):\n result = find_unique_positive_descending(case[\"input\"])\n status = \"PASSED\" if result == case[\"expected\"] else \"FAILED\"\n print(f\"Test {i+1} ({case['desc']}): {status}\")\n if status == \"FAILED\":\n print(f\" Expected: {case['expected']}, Got: {result}\")\n```"}]}
|
| {"language": "ru", "category": "Математические вычисления, простые числа, факториалы, НОД", "messages": [{"role": "system", "content": "Ты продвинутый AI разработчик. Перед написанием кода ты анализируешь задачу внутри тегов <think>...</think>, затем пишешь чистый рабочий код."}, {"role": "user", "content": "Напишите функцию, которая принимает на вход целое число $n$ и возвращает произведение всех простых чисел, не превышающих $n$, разделенное на их наибольший общий делитель (НОД). Учтите, что алгоритм должен корректно обрабатывать значения $n < 2$ и учитывать математические свойства НОД для последовательности чисел. Помните о поведении функции при пустом наборе данных."}, {"role": "assistant", "content": "<think>\n**Анализ задачи:**\n\n1. **Входные данные:** Целое число $n$.\n2. **Целевая операция:** Найти произведение всех простых чисел $p \\le n$, затем разделить это произведение на их наибольший общий делитель (НОД).\n3. **Математический анализ:**\n * Пусть $P = \\{p_1, p_2, \\dots, p_k\\}$ — множество всех простых чисел, таких что $p_i \\le n$.\n * Произведение этих чисел: $\\Pi = p_1 \\times p_2 \\times \\dots \\times p_k$.\n * Наибольший общий делитель (НОД) множества простых чисел:\n * Если в множестве есть хотя бы два различных простых числа (например, 2 и 3), то их НОД всегда равен 1, так как простые числа по определению не имеют общих делителей, кроме 1.\n * Если в множестве только одно простое число (например, $n=2$), то НОД этого единственного числа — само это число.\n * Если множество пусто ($n < 2$), нужно определить поведение функции. Согласно математической конвенции, произведение пустого множества равно 1, а НОД пустого множества часто не определен или принимается равным 0 (в контексте программирования важно обработать это как исключение или вернуть специфическое значение). Однако, исходя из логики \"произведение / НОД\", для $n < 2$ логичнее всего вернуть 0 или 1 в зависимости от интерпретации, но в программировании при пустом наборе для таких операций обычно возвращают 0 или обрабатывают как крайний случай.\n * **Случаи:**\n * $n < 2$: Множество пустое. Результат: 0 (или обработка ошибки).\n * $2 \\le n < 3$: Множество $\\{2\\}$. Произведение = 2, НОД = 2. Результат: $2 / 2 = 1$.\n * $3 \\le n$: Множество $\\{2, 3, \\dots\\}$. НОД всегда равен 1. Результат: $\\prod p_i / 1 = \\prod p_i$.\n\n4. **Алгоритм:**\n * Использовать \"Решето Эратосфена\" для эффективного поиска простых чисел до $n$.\n * Собрать список всех простых чисел $\\le n$.\n * Если список пуст $\\rightarrow$ вернуть 0.\n * Если в списке 1 элемент $\\rightarrow$ вернуть 1 (так как $p/p = 1$).\n * Если в списке $>1$ элементов $\\rightarrow$ вычислить произведение всех чисел (так как НОД будет 1).\n\n5. **Сложность:**\n * **Временная сложность:** $O(n \\log \\log n)$ для Решета Эратосфена.\n * **Пространственная сложность:** $O(n)$ для хранения массива решета.\n\n6. **Краевые случаи:**\n * $n < 2$: Пустое множество.\n * $n = 2$: Одно простое число.\n * $n$ очень большое: Число может стать огромным (Python обрабатывает длинную арифметику автоматически).\n</think>\n\n```python\nimport math\n\ndef solve_prime_product_divided_by_gcd(n: int) -> int:\n \"\"\"\n Вычисляет произведение всех простых чисел <= n, разделенное на их НОД.\n \n Математическая логика:\n 1. Если n < 2, простых чисел нет. Возвращаем 0.\n 2. Если есть только одно простое число (n=2), произведение = p, НОД = p. Результат = p/p = 1.\n 3. Если простых чисел >= 2, их НОД всегда равен 1 (так как это различные простые числа).\n Результат = произведение всех простых чисел / 1.\n \"\"\"\n if n < 2:\n return 0\n\n # Шаг 1: Нахождение простых чисел с помощью Решета Эратосфена\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 # Шаг 2: Обработка найденных чисел\n count = len(primes)\n \n if count == 0:\n return 0\n \n if count == 1:\n # Произведение p / НОД(p) = p / p = 1\n return 1\n \n # Если простых чисел больше одного, их НОД всегда равен 1\n # (так как простые числа взаимно просты)\n product = 1\n for p in primes:\n product *= p\n \n return product\n\n# Тестирование функции\nif __name__ == \"__main__\":\n test_cases = [\n (1, 0), # n < 2 (пустое множество)\n (2, 1), # {2} -> 2 / 2 = 1\n (3, 6), # {2, 3} -> (2*3) / НОД(2,3) = 6 / 1 = 6\n (5, 30), # {2, 3, 5} -> (2*3*5) / 1 = 30\n (10, 210), # {2, 3, 5, 7} -> 210 / 1 = 210\n (0, 0), # Отрицательное/ноль\n (-5, 0) # Отрицательное\n ]\n\n print(f\"{'n':>5} | {'Expected':>10} | {'Result':>10} | {'Status'}\")\n print(\"-\" * 45)\n for n, expected in test_cases:\n result = solve_prime_product_divided_by_gcd(n)\n status = \"✅ PASS\" if result == expected else \"❌ FAIL\"\n```"}]}
|
| {"language": "ru", "category": "Рекурсивные алгоритмы и мемоизация", "messages": [{"role": "system", "content": "Ты продвинутый AI разработчик. Перед написанием кода ты анализируешь задачу внутри тегов <think>...</think>, затем пишешь чистый рабочий код."}, {"role": "user", "content": "Реализуйте функцию для вычисления $n$-го числа в последовательности, где каждое следующее число равно сумме двух предыдущих, умноженной на индекс текущего шага, при этом для $n=0$ значение всегда равно 1. Ваша реализация должна использовать мемоизацию для оптимизации, но учитывайте, что при определенных отрицательных значениях $n$ или очень больших числах алгоритм может вести себя непредсказуемо. Найдите минимальное значение $n > 1$, при котором стандартная рекурсия без мемоизации перейдет в бесконечный цикл или вызовет переполнение стека из-за специфики логики шага."}, {"role": "assistant", "content": "<think>\n**Анализ задачи:**\n\n1. **Математическая модель:**\n Пусть $a_n$ — $n$-е число последовательности.\n Условия:\n - $a_0 = 1$\n - $a_1$ (не определено явно, но по логике \"сумма двух предыдущих\" для $n=1$ нам нужно $a_0$ и $a_{-1}$. Однако в стандартных задачах такого типа, если $a_0$ задано, $a_1$ либо задается отдельно, либо формула применяется с $n \\ge 2$. Перечитаем: \"каждое следующее число равно сумме двух предыдущих, умноженной на индекс текущего шага\".\n - Формула: $a_n = n \\cdot (a_{n-1} + a_{n-2})$ для $n \\ge 2$.\n - Что делать с $a_1$? Если $a_0=1$, а формула работает для $n \\ge 2$, нам нужно начальное значение для $a_1$. Обычно в таких задачах $a_1$ либо 1, либо 0. Исходя из контекста \"сумма двух предыдущих\", предположим, что для $n=1$ формула не применима или $a_1$ является базовым случаем. Если $a_1$ не задано, возьмем $a_1 = 1$ (как наиболее логичное продолжение для последовательностей типа факториала/субфакториала).\n\n2. **Алгоритм и мемоизация:**\n - Будем использовать словарь `memo` для хранения вычисленных значений.\n - Рекурсивная функция `get_sequence_value(n)`.\n - Базовые случаи: `if n == 0: return 1`, `if n == 1: return 1`.\n\n3. **Краевые случаи и ограничения:**\n - $n < 0$: Согласно условию, при отрицательных $n$ поведение непредсказуемо. Реализуем проверку и возврат ошибки или `None`.\n - Очень большие $n$: Числа будут расти быстрее, чем факториал (т.к. множитель $n$ растет). Это приведет к `OverflowError` при попытке преобразования в float или просто к огромным целым числам, потребляющим память.\n - Переполнение стека: Стандартная рекурсия в Python имеет лимит (обычно 1000).\n\n4. **Поиск минимального $n > 1$ для переполнения стека:**\n - Без мемоизации рекурсия для $a_n$ вызывает $a_{n-1}$ и $a_{n-2}$.\n - Глубина рекурсии при вызове `f(n)` составляет $n$.\n - Следовательно, переполнение стека (`RecursionError`) произойдет, когда $n$ превысит `sys.getrecursionlimit()`.\n\n5. **Сложность:**\n - С мемоизацией: $O(n)$ по времени и $O(n)$ по памяти.\n - Без мемоизации: $O(2^n)$ по времени (экспоненциальная сложность).\n\n**Алгоритм реализации:**\n1. Написать функцию с мемоизацией.\n2. Написать функцию без мемоизации.\n3. Написать функцию для определения порога `RecursionError`.\n</think>\n\n```python\nimport sys\n\ndef solve_sequence_with_memo(n, memo=None):\n \"\"\"\n Вычисляет n-е число последовательности с использованием мемоизации.\n Формула: a[n] = n * (a[n-1] + a[n-2])\n Базовые случаи: a[0] = 1, a[1] = 1\n \"\"\"\n if memo is None:\n memo = {0: 1, 1: 1}\n \n if n < 0:\n return None # Непредсказуемое поведение для отрицательных n\n \n if n in memo:\n return memo[n]\n \n # Рекурсивный шаг с сохранением в мемо\n memo[n] = n * (solve_sequence_with_memo(n - 1, memo) + solve_sequence_with_memo(n - 2, memo))\n return memo[n]\n\ndef solve_sequence_without_memo(n):\n \"\"\"\n Вычисляет n-е число последовательности без мемоизации.\n Используется для демонстрации переполнения стека.\n \"\"\"\n if n < 0:\n return None\n if n == 0 or n == 1:\n return 1\n return n * (solve_sequence_without_memo(n - 1) + solve_sequence_without_memo(n - 2))\n\ndef find_recursion_limit_n():\n \"\"\"\n Находит минимальное n, при котором возникнет RecursionError.\n \"\"\"\n limit = sys.getrecursionlimit()\n # В Python рекурсия падает чуть раньше, чем на самом лимите, \n # из-за внутренних вызовов интерпретатора.\n # Мы ищем n, при котором вызов solve_sequence_without_memo(n) упадет.\n \n # Попробуем найти n через бинарный поиск или линейный перебор в районе лимита\n # Но так как без мемоизации n=1000 будет считаться вечность (O(2^n)),\n # мы понимаем, что переполнение стека зависит от глубины, а не от сложности.\n # Глубина вызова f(n) -> f(n-1) -> f(n-2) ... составляет n.\n \n # Для чистого эксперимента с глубиной (игнорируя время выполнения):\n # Мы можем использовать итеративный подход для поиска границы, \n # но задача просит найти n для \"стандартной рекурсии\".\n \n # Важное замечание: без мемоизации при n ~ 40 программа зависнет на вычислениях,\n # но переполнение стека (RecursionError) произойдет только при n ~ sys.getrecursionlimit().\n \n return limit\n\ndef main():\n # 1. Тестирование мемоизации\n print(\"--- Тестирование мемоизации ---\")\n test_cases = [0, 1, 5, 10, 20]\n```"}]}
|
| {"language": "en", "category": "Asynchronous programming with asyncio coroutines and tasks", "messages": [{"role": "system", "content": "You are an expert AI software engineer. You analyze problems inside <think>...</think> tags before writing clean, robust code."}, {"role": "user", "content": "Design an asynchronous task scheduler that manages a pool of concurrent workers executing varying durations of simulated I/O tasks. Your implementation must handle a dynamic queue of tasks where some tasks may fail with specific exceptions, requiring a mechanism to distinguish between fatal errors that should halt the entire pool and recoverable errors that should only cancel the individual task. You must ensure that the scheduler gracefully handles \"zombie\" tasks by enforcing a strict timeout for every coroutine, ensuring no task exceeds the global execution limit even if it ignores cancellation signals."}, {"role": "assistant", "content": "<think>\n### Problem Breakdown\n\n1. **Core Requirements**:\n * **Asynchronous Task Scheduler**: Use `asyncio` to manage concurrent execution.\n * **Worker Pool**: A fixed number of workers consuming tasks from a queue.\n * **Dynamic Queue**: Tasks are added to a `asyncio.Queue`.\n * **Error Handling**:\n * *Recoverable Errors*: Task-specific exceptions that allow the worker to continue.\n * *Fatal Errors*: Exceptions that signal the scheduler to shut down all workers immediately.\n * **Zombie Task Prevention**: Use `asyncio.wait_for` to enforce a hard timeout on every task, ensuring that even if a task ignores a `CancelledError`, the scheduler can move on or clean up.\n * **Concurrency Control**: Manage a specific number of concurrent workers.\n\n2. **Algorithm & Design**:\n * **Task Structure**: A `TaskDefinition` class containing a coroutine function, its arguments, and a timeout.\n * **Exception Hierarchy**:\n * `RecoverableError`: Inherit from `Exception`.\n * `FatalError`: Inherit from `Exception`.\n * **Worker Loop**:\n * Wait for task from queue.\n * Wrap task execution in `asyncio.wait_for(task, timeout)`.\n * Catch `asyncio.TimeoutError` (Zombie mitigation).\n * Catch `RecoverableError` (Log and continue).\n * Catch `FatalError` (Signal shutdown via an `asyncio.Event`).\n * **Scheduler Logic**:\n * Initialize a queue and an `Event` for shutdown.\n * Spawn $N$ worker tasks.\n * Monitor the shutdown event.\n\n3. **Complexity Analysis**:\n * **Time Complexity**: \n * Task insertion: $O(1)$.\n * Task execution: $O(\\text{duration of task})$.\n * Overall: $O(T)$ where $T$ is the sum of task durations.\n * **Space Complexity**: $O(Q + W)$ where $Q$ is the number of tasks in the queue and $W$ is the number of workers.\n\n4. **Edge Cases**:\n * **Task exceeds timeout**: Handled by `asyncio.wait_for`.\n * **Fatal error in one worker**: Must trigger shutdown for all other workers.\n * **Queue empty but workers active**: Workers should wait for tasks or handle shutdown signal.\n * **Task ignores `CancelledError`**: The `wait_for` mechanism acts as a watchdog.\n</think>\n\n```python\nimport asyncio\nimport random\nimport logging\nfrom dataclasses import dataclass, field\nfrom typing import Any, Callable, Coroutine, Dict, List\n\n# Configure logging to see the execution flow clearly\nlogging.basicConfig(\n level=logging.INFO, \n format=\"%(asctime)s [%(levelname)s] %(message)s\",\n datefmt=\"%H:%M:%S\"\n)\nlogger = logging.getLogger(\"Scheduler\")\n\n# --- Custom Exceptions ---\n\nclass SchedulerError(Exception):\n \"\"\"Base class for scheduler-related errors.\"\"\"\n pass\n\nclass RecoverableError(SchedulerError):\n \"\"\"Errors that should only cancel the specific task.\"\"\"\n pass\n\nclass FatalError(SchedulerError):\n \"\"\"Errors that should halt the entire worker pool.\"\"\"\n pass\n\n# --- Data Structures ---\n\n@dataclass\nclass TaskDefinition:\n \"\"\"Represents a unit of work to be executed.\"\"\"\n name: str\n func: Callable[..., Coroutine[Any, Any, Any]]\n args: tuple = field(default_factory=tuple)\n timeout: float = 5.0 # Individual task timeout\n\n# --- The Scheduler ---\n\nclass AsyncScheduler:\n def __init__(self, worker_count: int):\n self.worker_count = worker_count\n self.queue: asyncio.Queue[TaskDefinition] = asyncio.Queue()\n self.shutdown_event = asyncio.Event()\n self.workers: List[asyncio.Task] = []\n self._running = False\n\n async def _worker_loop(self, worker_id: int):\n \"\"\"The lifecycle of a single worker.\"\"\"\n logger.info(f\"Worker-{worker_id} started.\")\n \n while not self.shutdown_event.is_set():\n # Check if shutdown was signaled while waiting for a task\n if self.shutdown_event.is_set():\n break\n\n try:\n # Wait for a task with a timeout to allow checking shutdown_event periodically\n # This prevents workers from hanging forever on an empty queue during shutdown\n task_def = await asyncio.wait_for(self.queue.get(), timeout=1.0)\n except asyncio.TimeoutError:\n continue\n except Exception as e:\n logger.error(f\"Worker-{worker_id} encountered unexpected error in queue retrieval: {e}\")\n break\n\n logger.info(f\"Worker-{worker_id} picked up task: {task_def.name}\")\n\n try:\n # Enforce strict timeout to handle \"zombie\" tasks that ignore cancellation\n await asyncio.wait_for(\n task_def.func(*task_def.args), \n timeout=task_def.timeout\n )\n logger.info(f\"Worker-{worker_id} completed task: {task_def.name}\")\n\n except asyncio.TimeoutError:\n logger.warning(f\"Worker-{worker_id} killed zombie task: {task_def.name} (Exceeded {task_def.timeout}s)\")\n \n except RecoverableError as e:\n logger.error(f\"Worker-{worker_id} caught recoverable error in {task_def.name}: {e}\")\n \n except FatalError as e:\n logger.critical(f\"Worker-{worker_id} caught FATAL error in {task_def.name}: {e}. Initiating shutdown...\")\n self.shutdown_event.set()\n break\n \n except Exception as e:\n logger.error(f\"Worker-{worker_id} caught unexpected error in {task_def.name}: {type(e).__name__}: {e}\")\n \n finally:\n self.queue.task_done()\n\n logger.info(f\"Worker-{worker_id} shutting down.\")\n\n async def submit_task(self, task: TaskDefinition):\n \"\"\"Add a task to the dynamic queue.\"\"\"\n if not self.shutdown_event.is_set():\n await self.queue.put(task)\n```"}]}
|
| {"language": "ru", "category": "ООП: классы, наследование, dunder-методы (__repr__, __add__)", "messages": [{"role": "system", "content": "Ты продвинутый AI разработчик. Перед написанием кода ты анализируешь задачу внутри тегов <think>...</think>, затем пишешь чистый рабочий код."}, {"role": "user", "content": "Реализуйте класс `SmartWallet`, который позволяет складывать объекты двух разных типов (например, `Wallet` и `Currency`) через оператор `+`, используя магический метод `__add__`. Подвох заключается в том, что при попытке сложить два объекта разных подклассов, которые не имеют явного общего предка, кроме `object`, программа должна корректно определить приоритет и тип результирующего объекта, не вызывая ошибку `TypeError`. Учтите краевой случай, когда один из объектов при сложении является «пустым» или имеет нулевое значение."}, {"role": "assistant", "content": "<think>\n**Анализ задачи:**\n\n1. **Цель:** Реализовать механизм сложения (`__add__`) для объектов разных классов (`Wallet` и `Currency`), которые не связаны иерархией наследования.\n2. **Ключевой механизм:** Использование магического метода `__add__` в одном классе и, для обеспечения симметрии (если левый операнд не знает, что делать с правым), метода `__radd__` (reflected add) во втором классе.\n3. **Логика определения типа:**\n * Если складываются `Wallet` и `Currency`, нужно решить, что получится в итоге. Логично, что `Wallet` (кошелек) — это контейнер, а `Currency` (валюта) — это значение. При сложении кошелька с валютой должен получиться новый кошелек с обновленным балансом.\n * Если складываются два `Wallet`, результат — `Wallet`.\n * Если складываются два `Currency`, результат — `Currency`.\n4. **Краевые случаи:**\n * Нулевое значение (пустой кошелек или нулевая валюта).\n * Сложение объектов разных типов, где порядок операндов меняется (`Wallet + Currency` vs `Currency + Wallet`).\n * Неподдерживаемые типы (вызов `TypeError`).\n5. **Алгоритм:**\n * Класс `Currency`: хранит `amount`. Метод `__add__` проверяет тип операнда. Если это `Currency`, возвращает новую `Currency`. Если `Wallet`, возвращает `TypeError` (потому что `Currency` не может поглотить `Wallet`).\n * Класс `Wallet`: хранит `balance`. Метод `__add__` проверяет тип. Если `Currency`, возвращает новый `Wallet`. Если `Wallet`, возвращает новый `Wallet`.\n * Метод `__radd__` в `Currency` должен обрабатывать случай `Wallet + Currency`, если `Wallet` не реализовал это в `__add__` (хотя в нашей реализации мы реализуем это в обоих направлениях для надежности).\n6. **Сложность:**\n * Временная сложность: $O(1)$ для операции сложения.\n * Пространственная сложность: $O(1)$ для создания нового объекта.\n</think>\n\n```python\nfrom typing import Union, Any\n\nclass Currency:\n \"\"\"Класс, представляющий денежную единицу.\"\"\"\n def __init__(self, amount: float):\n self.amount = float(amount)\n\n def __add__(self, other: Any) -> 'Currency':\n # Если складываем Currency + Currency, возвращаем новую Currency\n if isinstance(other, Currency):\n return Currency(self.amount + other.amount)\n # Если пытаемся сложить Currency + Wallet, Currency не знает как это сделать\n return NotImplemented\n\n def __radd__(self, other: Any) -> 'Wallet':\n # Это вызывается, когда Wallet + Currency, и Wallet не знает как работать с Currency\n # Но в нашей реализации Wallet сам обработает этот случай.\n # Однако, для полноты реализации:\n if isinstance(other, 'Wallet'):\n return other + self\n return NotImplemented\n\n def __repr__(self) -> str:\n return f\"Currency({self.amount})\"\n\n\nclass Wallet:\n \"\"\"Класс, представляющий кошелек с балансом.\"\"\"\n def __init__(self, balance: float):\n self.balance = float(balance)\n\n def __add__(self, other: Any) -> Union['Wallet', 'Currency']:\n # Случай 1: Wallet + Wallet\n if isinstance(other, Wallet):\n return Wallet(self.balance + other.balance)\n \n # Случай 2: Wallet + Currency\n if isinstance(other, Currency):\n return Wallet(self.balance + other.amount)\n \n return NotImplemented\n\n def __radd__(self, other: Any) -> Union['Wallet', 'Currency']:\n # Случай 3: Currency + Wallet (вызывается, если первый операнд не поддержал __add__)\n if isinstance(other, Currency):\n return Wallet(other.amount + self.balance)\n return NotImplemented\n\n def __repr__(self) -> str:\n return f\"Wallet({self.balance})\"\n\n\ndef test_smart_wallet():\n print(\"--- Запуск тестов SmartWallet ---\")\n\n # Инициализация объектов\n w1 = Wallet(100.0)\n w2 = Wallet(50.0)\n c1 = Currency(25.0)\n c2 = Currency(10.0)\n empty_c = Currency(0.0)\n empty_w = Wallet(0.0)\n\n # Тест 1: Wallet + Wallet\n res1 = w1 + w2\n print(f\"Test 1 (Wallet + Wallet): {w1} + {w2} = {res1} | OK: {isinstance(res1, Wallet) and res1.balance == 150.0}\")\n\n # Тест 2: Wallet + Currency\n res2 = w1 + c1\n print(f\"Test 2 (Wallet + Currency): {w1} + {c1} = {res2} | OK: {isinstance(res2, Wallet) and res2.balance == 125.0}\")\n\n # Тест 3: Currency + Wallet (проверка __radd__)\n res3 = c1 + w1\n print(f\"Test 3 (Currency + Wallet): {c1} + {w1} = {res3} | OK: {isinstance(res3, Wallet) and res3.balance == 125.0}\")\n\n # Тест 4: Currency + Currency\n res4 = c1 + c2\n print(f\"Test 4 (Currency + Currency): {c1} + {c2} = {res4} | OK: {isinstance(res4, Currency) and res4.amount == 35.0}\")\n\n # Тест 5: Краевой случай - нулевые значения\n res5 = w1 + empty_c\n res6 = empty_w + c1\n print(f\"Test 5a (Wallet + Zero Currency): {w1} + {empty_c} = {res5} | OK: {res5.balance == 100.0}\")\n```"}]}
|
| {"language": "en", "category": "Asynchronous programming with asyncio coroutines and tasks", "messages": [{"role": "system", "content": "You are an expert AI software engineer. You analyze problems inside <think>...</think> tags before writing clean, robust code."}, {"role": "user", "content": "Design a simulated \"Smart Home Hub\" that must trigger multiple device commands (lights, thermostat, security) concurrently using `asyncio`. Your system must ensure that if any critical device task fails with an exception, all other pending device tasks are immediately cancelled to prevent an unsafe state. You must also handle the edge case where a device task might finish successfully just as a cancellation signal is sent, ensuring no \"zombie\" tasks remain running in the background."}, {"role": "assistant", "content": "<think>\n* **Core Requirement**: Execute multiple asynchronous tasks (lights, thermostat, security) concurrently.\n* **Critical Failure Constraint**: If a *critical* task fails, all other pending tasks must be cancelled immediately to prevent an unsafe state (e.g., if the security system fails, we shouldn't leave the lights on or the thermostat running if the hub is compromised).\n* **Edge Case (Zombie Tasks)**: Ensure that if a task finishes just as a cancellation is sent, it is cleaned up properly.\n* **Mechanism**: `asyncio.gather` is often used for concurrency, but `asyncio.wait` or `asyncio.create_task` with a custom `try/except/finally` block is better for granular control over task cancellation upon a specific failure.\n* **Implementation Strategy**:\n 1. Define a `DeviceTask` class or a function that simulates a device action with a delay and a potential for failure.\n 2. Identify which tasks are \"critical\".\n 3. Use an `asyncio.TaskGroup` (Python 3.11+) or a manual `asyncio.gather` with a `try/except` wrapper to manage the lifecycle.\n 4. Since the prompt asks to cancel *all* others if a *critical* one fails, I will implement a supervisor pattern.\n\n**Algorithm/Complexity Analysis:**\n* **Algorithm**: \n 1. Initialize a list of tasks.\n 2. Wrap each task in a handler that catches exceptions.\n 3. If an exception is caught and the device is marked `is_critical=True`, trigger a cancellation of the entire group.\n 4. Use `asyncio.gather` with `return_exceptions=False` inside a `try/finally` block to ensure that if one task raises an exception, the rest are cancelled.\n* **Time Complexity**: $O(N)$ where $N$ is the number of devices, as we must initiate and wait for each.\n* **Space Complexity**: $O(N)$ to store the task handles.\n\n**Edge Cases handled**:\n1. **Critical Failure**: A critical task raises an error $\\rightarrow$ all others are cancelled.\n2. **Non-Critical Failure**: A non-critical task raises an error $\\rightarrow$ others continue (or we can decide if non-critical failure should also cancel; the prompt implies only *critical* failure triggers the \"unsafe state\" cancellation). *Correction*: Re-reading the prompt: \"if any critical device task fails... all other pending device tasks are immediately cancelled\". This implies non-critical failures might not trigger a full shutdown, but usually, in robust systems, we want to handle them. I will implement it such that only critical failures trigger the \"emergency stop\".\n3. **Race Condition**: Task finishes right as cancellation occurs. `asyncio` handles this via the `CancelledError` exception.\n\n**Refined Plan**:\n- Use `asyncio.gather` within a `try/except` block.\n- If a `CriticalDeviceError` occurs, catch it, and explicitly cancel all other tasks.\n- Use `asyncio.shield` or standard `Task` objects to ensure we can track them.\n- Actually, the simplest robust way is: `asyncio.gather(*tasks)` will raise the first exception it encounters. If we wrap our tasks to re-raise a specific `CriticalFailure` exception, `gather` will propagate it, and the `finally` block or the `except` block can ensure all tasks are cancelled.\n\n**Implementation Details**:\n- `Device` class: `name`, `is_critical`, `action_duration`.\n- `simulate_device_action`: An async function.\n- `SmartHomeHub`: The orchestrator.\n</think>\n\n```python\nimport asyncio\nimport random\nimport logging\n\n
|
| {"language": "en", "category": "Exception handling with try-except and custom Exceptions", "messages": [{"role": "system", "content": "You are an expert AI software engineer. You analyze problems inside <think>...</think> tags before writing clean, robust code."}, {"role": "user", "content": "**Problem Statement: The Multi-Tiered Transaction Processor**\n\nDesign a system that processes a sequence of financial transactions, where each transaction must pass through multiple validation layers (Type, Amount, and Account Status) represented by distinct custom exception classes. Your logic must handle nested failures where a single transaction might trigger multiple exceptions simultaneously, ensuring that the system correctly identifies the *most specific* error while preventing a \"swallowed\" exception from masking critical system failures. Pay close attention to edge cases involving empty transaction logs, zero-value transfers, and the behavior of exception chaining when a secondary error occurs during the `finally` cleanup block."}, {"role": "assistant", "content": "<think>\n### Problem Breakdown\n\n**1. Core Objective:**\nImplement a transaction processor that validates transactions against three criteria: `Type`, `Amount`, and `Account Status`. The system must handle multiple validation failures and ensure the most specific error is captured without masking critical failures.\n\n**2. Requirements & Constraints:**\n* **Custom Exceptions:**\n * `TransactionError` (Base)\n * `InvalidTypeError` (Inherits `TransactionError`)\n * `InvalidAmountError` (Inherits `TransactionError`)\n * `AccountStatusError` (Inherits `TransactionError`)\n* **Validation Logic:**\n * `Type`: Must be in `['DEPOSIT', 'WITHDRAWAL', 'TRANSFER']`.\n * `Amount`: Must be `> 0`.\n * `Account Status`: Must be `'ACTIVE'`.\n* **Multi-Failure Handling:** If a transaction fails multiple checks, we must collect all errors. However, the prompt asks for the \"most specific\" error. In a standard try-except, the first caught exception stops the block. To handle *multiple* errors, we must perform all checks and aggregate them.\n* **Exception Chaining:** If an error occurs during the `finally` block (cleanup), it must not swallow the original transaction error. Python's `raise ... from ...` or the default behavior of `__context__` should be respected.\n* **Edge Cases:**\n * Empty transaction log: Should return an empty list/report.\n * Zero-value transfers: Should trigger `InvalidAmountError`.\n * Cleanup failure: Simulate a database/log connection failure during `finally`.\n\n**3. Algorithm Design:**\n1. Iterate through a list of transaction dictionaries.\n2. For each transaction:\n * Initialize an `errors` list.\n * Run all three validation checks independently (don't return early, so we catch all).\n * If `errors` is not empty, raise a `CompositeTransactionError` (a custom container) or handle them sequentially. *Decision: To follow the \"most specific error\" requirement while handling \"multiple exceptions simultaneously\", I will implement a mechanism that collects all errors and raises a single exception containing the list.*\n * Use a `try...except...finally` block.\n * In `finally`, simulate a \"cleanup\" process. If cleanup fails, ensure the original error is preserved using exception chaining.\n\n**4. Complexity Analysis:**\n* **Time Complexity:** $O(N)$, where $N$ is the number of transactions. Each transaction is processed in constant time $O(1)$ relative to the number of validation rules.\n* **Space Complexity:** $O(1)$ if we process one by one, or $O(N)$ if we store the results of all transactions.\n\n**5. Edge Case Handling:**\n* `amount <= 0`: `InvalidAmountError`.\n* `type not in list`: `InvalidTypeError`.\n* `status != 'ACTIVE'`: `AccountStatusError`.\n* `cleanup_fails`: If `finally` raises an exception, Python's default behavior is to raise the new exception and attach the old one to `__context__`. I will explicitly demonstrate this.\n</think>\n\n```python\nfrom typing import List, Dict, Any, Union\n\n# --- Custom Exception Hierarchy ---\n\nclass TransactionError(Exception):\n \"\"\"Base class for all transaction-related errors.\"\"\"\n pass\n\nclass InvalidTypeError(TransactionError):\n \"\"\"Raised when the transaction type is unrecognized.\"\"\"\n pass\n\nclass InvalidAmountError(TransactionError):\n \"\"\"Raised when the transaction amount is zero or negative.\"\"\"\n pass\n\nclass AccountStatusError(TransactionError):\n \"\"\"Raised when the account is not in an ACTIVE state.\"\"\"\n pass\n\nclass MultiValidationError(TransactionError):\n \"\"\"\n A container exception used when a single transaction \n violates multiple validation rules simultaneously.\n \"\"\"\n def __init__(self, errors: List[TransactionError]):\n self.errors = errors\n super().__init__(f\"Multiple validation failures: {[str(e) for e in errors]}\")\n\nclass CleanupError(Exception):\n \"\"\"Simulates a critical system failure during the cleanup phase.\"\"\"\n pass\n\n# --- Processor Implementation ---\n\nclass MultiTieredProcessor:\n def __init__(self, valid_types: List[str], active_status: str):\n self.valid_types = valid_types\n self.active_status = active_status\n\n def validate_transaction(self, txn: Dict[str, Any]) -> None:\n \"\"\"\n Performs all validations. Instead of returning on the first error,\n it collects all errors to handle simultaneous failures.\n \"\"\"\n errors = []\n\n # 1. Type Validation\n if txn.get(\"type\") not in self.valid_types:\n errors.append(InvalidTypeError(f\"Invalid type: {txn.get('type')}\"))\n\n # 2. Amount Validation\n # Note: We use .get() to handle missing keys gracefully\n amount = txn.get(\"amount\", 0)\n if not isinstance(amount, (int, float)) or amount <= 0:\n errors.append(InvalidAmountError(f\"Invalid amount: {amount}\"))\n\n # 3. Account Status Validation\n if txn.get(\"status\") != self.active_status:\n errors.append(AccountStatusError(f\"Account status is {txn.get('status')}\"))\n\n # If any errors were collected, raise the composite error\n if errors:\n raise MultiValidationError(errors)\n\n def process_batch(self, transactions: List[Dict[str, Any]], simulate_cleanup_failure: bool = False) -> List[Dict[str, Any]]:\n \"\"\"\n Processes a sequence of transactions.\n Returns a list of results indicating success or failure.\n \"\"\"\n results = []\n\n for txn in transactions:\n txn_id = txn.get(\"id\", \"Unknown\")\n try:\n self.validate_transaction(txn)\n results.append({\"id\": txn_id, \"status\": \"SUCCESS\"})\n \n except MultiValidationError as e:\n # Handle the most specific errors contained within the composite error\n results.append({\"id\": txn_id, \"status\": \"FAILED\", \"errors\": [type(err).__name__ for err in e.errors]})\n \n except TransactionError as e:\n # Catch-all for any other single transaction errors\n results.append({\"id\": txn_id, \"status\": \"FAILED\", \"errors\": [type(e).__name__]})\n```"}]}
|
| {"language": "en", "category": "Dictionaries, sets, Counter, and defaultdict data structures", "messages": [{"role": "system", "content": "You are an expert AI software engineer. You analyze problems inside <think>...</think> tags before writing clean, robust code."}, {"role": "user", "content": "**Problem Statement: The Unique Event Log Analyzer**\n\nYou are given a list of strings representing a sequence of log entries, where each entry contains a timestamp and an event type. Your task is to determine the total number of unique event types that occurred, and for each unique event type, calculate how many times it appeared in the logs. You must also identify which event types appeared strictly more than once, while ensuring that any event types with zero occurrences (due to filtering) are not included in your final report."}, {"role": "assistant", "content": "<think>\n* Input: A list of strings. Each string represents a log entry.\n* Format of entry: \"timestamp event_type\" (e.g., \"10:00 LOGIN\", \"10:01 ERROR\").\n* Output Requirements:\n 1. Total number of unique event types.\n 2. A frequency map (dictionary) of event types and their counts.\n 3. A list of event types that appeared more than once.\n* Constraints:\n * Ignore zero occurrences (though in this specific problem, since we iterate over existing logs, counts will naturally be $\\ge 1$).\n * Handle potential whitespace or formatting issues.\n\n * Initialize an empty dictionary `event_counts` to store frequencies.\n * Iterate through each log entry in the input list.\n * Split the string by whitespace.\n * The second part (index 1) is the `event_type`.\n * Update the dictionary: `event_counts[event_type] = event_counts.get(event_type, 0) + 1`.\n * After the loop:\n * `total_unique = len(event_counts)`\n * `duplicates = [event for event, count in event_counts.items() if count > 1]`\n * Return/Print the results.\n\n * Input: `[\"10:00 LOGIN\", \"10:01 LOGOUT\", \"10:02 LOGIN\", \"10:03 ERROR\", \"10:04 ERROR\", \"10:05 ERROR\"]`\n * Processing:\n * \"LOGIN\" -> `{LOGIN: 1}`\n * \"LOGOUT\" -> `{LOGIN: 1, LOGOUT: 1}`\n * \"LOGIN\" -> `{LOGIN: 2, LOGOUT: 1}`\n * \"ERROR\" -> `{LOGIN: 2, LOGOUT: 1, ERROR: 1}`\n * \"ERROR\" -> `{LOGIN: 2, LOGOUT: 1, ERROR: 2}`\n * \"ERROR\" -> `{LOGIN: 2, LOGOUT: 1, ERROR: 3}`\n * Results:\n * Total Unique: 3\n * Counts: `{'LOGIN': 2, 'LOGOUT': 1, 'ERROR': 3}`\n * Duplicates: `['LOGIN', 'ERROR']`\n\n * Empty list: Should return 0 unique, empty dict, empty list.\n * Malformed strings: Assume the format is strictly \"timestamp event_type\" per problem description, but `split()` handles multiple spaces gracefully.\n * Case sensitivity: \"Login\" vs \"LOGIN\" are different. Standard practice is to treat them as unique unless specified otherwise. I will treat them as case-sensitive.\n\n * Time Complexity: $O(N)$, where $N$ is the number of log entries. We traverse the list once.\n * Space Complexity: $O(U)$, where $U$ is the number of unique event types, to store the dictionary.\n\n * Use `collections.Counter` for a more \"Senior Engineer\" approach to counting.\n * Ensure the function is robust and well-documented.\n</think>\n\n```python\nfrom typing import List, Dict, Any\n\ndef analyze_event_logs(logs: List[str]) -> Dict[str, Any]:\n \"\"\"\n Analyzes a list of log entries to extract unique event counts and duplicates.\n\n Args:\n logs: A list of strings, where each string is formatted as \"timestamp event_type\".\n\n Returns:\n A dictionary containing:\n - 'total_unique': int (Number of unique event types)\n - 'event_frequencies': dict (Mapping of event_type to its occurrence count)\n - 'repeated_events': list (List of event types that appeared > 1 time)\n \"\"\"\n
|
| {"language": "ru", "category": "Словари и множества (dict, set, Counter, defaultdict)", "messages": [{"role": "system", "content": "Ты продвинутый AI разработчик. Перед написанием кода ты анализируешь задачу внутри тегов <think>...</think>, затем пишешь чистый рабочий код."}, {"role": "user", "content": "Дан список слов, где некоторые элементы могут быть пустыми строками или содержать только пробелы. Необходимо найти все уникальные слова, которые встречаются в списке ровно один раз, но при этом игнорируйте слова, состоящие только из спецсимволов, если они не являются частью других слов. Учтите, что порядок слов в итоговом результате должен соответствовать их первому появлению в исходном списке."}, {"role": "assistant", "content": "<think>\n1. **Анализ задачи**:\n * **Вход**: Список строк (`List[str]`).\n * **Условие 1 (Очистка)**: Игнорировать пустые строки и строки, состоящие только из пробелов.\n * **Условие 2 (Спецсимволы)**: Игнорировать слова, состоящие *только* из спецсимволов. Под спецсимволами понимаются любые символы, не являющиеся буквами или цифрами (буквы/цифры определяются через `isalnum()`).\n * **Условие 3 (Уникальность)**: Найти слова, которые встречаются в списке ровно один раз.\n * **Условие 4 (Порядок)**: Сохранить порядок первого появления слов из исходного списка.\n * **Определение \"слова\"**: В данной задаче \"слово\" — это элемент списка (строка), а не подстрока внутри строки, так как в условии сказано \"элементы могут быть пустыми строками...\".\n\n2. **Алгоритм**:\n * Создать вспомогательную функцию `is_valid(word)`, которая проверяет:\n * Не является ли строка пустой или состоящей только из пробелов (`strip()`).\n * Содержит ли она хотя бы один буквенно-цифровой символ (`any(c.isalnum() for c in word)`).\n * Пройтись по списку и отфильтровать только валидные слова.\n * Использовать словарь (`dict`) или `collections.Counter` для подсчета частоты каждого валидного слова.\n * Второй проход по списку (или по ключам словаря, если порядок сохранен) для сбора слов, у которых `count == 1`.\n * В Python 3.7+ обычные словари сохраняют порядок вставки, что упрощает задачу.\n\n3. **Краевые случаи**:\n * Список пуст $\\rightarrow$ вернуть `[]`.\n * Все слова повторяются $\\rightarrow$ вернуть `[]`.\n * Слова состоят только из `!@#$%` $\\rightarrow$ игнорировать.\n * Слова с пробелами по краям `\" hello \"` $\\rightarrow$ нужно решить, считать ли их за `\"hello\"`. Обычно в таких задачах подразумевается нормализация (trim), чтобы `\"word\"` и `\" word \"` считались одним и тем же словом. Я добавлю `.strip()`.\n\n4. **Сложность**:\n * **Временная сложность**: $O(N \\cdot K)$, где $N$ — количество слов, $K$ — средняя длина слова (для проверки `isalnum` и подсчета).\n * **Пространственная сложность**: $O(N)$, для хранения словаря частот.\n</think>\n\n```python\nfrom collections import Counter\n\ndef find_unique_single_occurrence_words(word_list: list[str]) -> list[str]:\n \"\"\"\n Находит уникальные слова, встречающиеся ровно один раз, игнорируя пустые строки\n и строки, состоящие только из спецсимволов.\n \"\"\"\n \n def is_valid(word: str) -> bool:\n # Убираем пробелы по краям для корректной проверки\n stripped = word.strip()\n # 1. Проверка на пустоту (после strip)\n if not stripped:\n return False\n # 2. Проверка на наличие хотя бы одного буквенно-цифрового символа\n # Если в слове только спецсимволы (напр. \"@
|
| {"language": "en", "category": "Math computations, prime numbers, factorials, and GCD", "messages": [{"role": "system", "content": "You are an expert AI software engineer. You analyze problems inside <think>...</think> tags before writing clean, robust code."}, {"role": "user", "content": "**Problem Statement: The Primorial-Factorial GCD Challenge**\n\nGiven two non-negative integers $N$ and $M$, calculate the Greatest Common Divisor (GCD) of the $N$-th primorial ($P_N\\#$, the product of the first $N$ prime numbers) and the $M$-th factorial ($M!$). Your solution must efficiently handle cases where $N$ or $M$ are zero, or where one value is significantly larger than the other, ensuring you account for the mathematical definitions of $0!$ and the empty primorial."}, {"role": "assistant", "content": "<think>\n* **Goal:** Calculate $\\text{GCD}(P_N\\#, M!)$.\n* **Definitions:**\n * $P_N\\# = \\prod_{i=1}^{N} p_i$, where $p_i$ is the $i$-th prime number.\n * $M! = \\prod_{j=1}^{M} j$.\n * $P_0\\# = 1$ (empty product).\n * $0! = 1$.\n* **Mathematical Insight:**\n * The GCD of two numbers is the product of the common prime factors raised to the minimum exponent found in both numbers.\n * $P_N\\#$ is a square-free integer (each prime factor has an exponent of exactly 1).\n * Therefore, $\\text{GCD}(P_N\\#, M!)$ is simply the product of all prime numbers $p_i$ such that $p_i \\le M$ and $i \\le N$.\n * Wait, let's refine that:\n * A prime $p$ divides $P_N\\#$ if and only if $p \\in \\{p_1, p_2, \\dots, p_N\\}$.\n * A prime $p$ divides $M!$ if and only if $p \\le M$.\n * Therefore, $p$ divides $\\text{GCD}(P_N\\#, M!)$ if and only if $p$ is one of the first $N$ primes AND $p \\le M$.\n* **Algorithm:**\n 1. Handle edge cases: If $N=0$ or $M=0$, the result is 1 (since $P_0\\#=1$ and $0!=1$, $\\text{GCD}(1, 1)=1$).\n 2. Generate the first $N$ prime numbers.\n 3. For each prime $p$ in the set of the first $N$ primes:\n * If $p \\le M$, include $p$ in the product.\n 4. Return the product.\n* **Complexity Analysis:**\n * **Time Complexity:** Generating $N$ primes using a Sieve of Eratosthenes or a simple primality test. To find the $N$-th prime, we can estimate its value using the Prime Number Theorem: $p_n \\approx n \\ln n$. For $N=10^5$, $p_n \\approx 1.3 \\times 10^6$. Sieve complexity is $O(X \\log \\log X)$ where $X$ is the value of the $N$-th prime.\n * **Space Complexity:** $O(X)$ to store the sieve.\n* **Edge Cases:**\n * $N=0$: $P_0\\# = 1 \\implies \\text{GCD}(1, M!) = 1$.\n * $M=0$: $0! = 1 \\implies \\text{GCD}(P_N\\#, 1) = 1$.\n * $N=1, M=1$: $P_1\\#=2, 1!=1 \\implies \\text{GCD}(2, 1) = 1$.\n * $N=1, M=2$: $P_1\\#=2, 2!=2 \\implies \\text{GCD}(2, 2) = 2$.\n* **Constraints & Optimization:**\n * Since the result can be extremely large (product of many primes), Python's arbitrary-precision integers are necessary.\n * The core logic is: `result = product(p for p in first_N_primes if p <= M)`.\n</think>\n\n```python\nimport math\n\ndef solve_primorial_factorial_gcd(n: int, m: int) -> int:\n \"\"\"\n Calculates the GCD of the N-th primorial (Pn
|
| {"language": "ru", "category": "Математические вычисления, простые числа, факториалы, НОД", "messages": [{"role": "system", "content": "Ты продвинутый AI разработчик. Перед написанием кода ты анализируешь задачу внутри тегов <think>...</think>, затем пишешь чистый рабочий код."}, {"role": "user", "content": "Напишите программу, которая принимает на вход целое число $N$ и вычисляет произведение всех простых чисел, не превышающих $N$, но при этом возвращает 0, если среди этих чисел есть хотя бы одно, чья цифра суммы равна самому числу. Учтите, что для $N < 2$ результат должен быть строго определенным, а алгоритм должен корректно обрабатывать отрицательные значения. Помните о поведении функции при поиске НОД для последовательности таких чисел."}, {"role": "assistant", "content": "<think>\n### Анализ задачи\n\n1. **Входные данные**: Целое число $N$.\n2. **Цель**: Найти произведение всех простых чисел $p$, таких что $2 \\le p \\le N$.\n3. **Условие исключения (Short-circuit)**: Если среди найденных простых чисел есть хотя бы одно число $p$, у которого сумма его цифр равна самому числу $p$, программа должна вернуть $0$.\n * *Анализ условия*: Сумма цифр числа $x$ всегда меньше или равна самому числу $x$ для всех $x \\ge 1$. Равенство $\\text{sum\\_digits}(x) = x$ достигается только для однозначных чисел (от 0 до 9). \n * Следовательно, если среди простых чисел есть число в диапазоне $[2, 9]$, условие \"сумма цифр равна самому числу\" будет истинным.\n * Простые числа в диапазоне $[2, 9]$ — это $2, 3, 5, 7$.\n * **Вывод**: Если $N \\ge 2$, в последовательности простых чисел обязательно будут числа 2, 3, 5 или 7. Для всех этих чисел сумма цифр равна самому числу. Значит, для любого $N \\ge 2$ результат будет $0$.\n4. **Краевые случаи**:\n * $N < 2$: Простых чисел в диапазоне $[2, N]$ нет. Произведение пустого множества по математическому стандарту (empty product) равно $1$. Однако, если в задаче подразумевается, что при отсутствии чисел результат должен быть иным, стоит уточнить. Но обычно произведение пустых множеств — $1$.\n * $N < 0$: Простых чисел нет, результат $1$.\n * $N = 2$: Единственное простое число — $2$. Сумма цифр $2$ равна $2$. Результат $0$.\n5. **Алгоритм**:\n * Если $N < 2$, вернуть $1$ (произведение пустого множества).\n * Если $N \\ge 2$, проверить наличие простых чисел. Так как $2$ — первое простое число, и сумма его цифр ($2$) равна самому числу, то для любого $N \\ge 2$ условие \"сумма цифр равна числу\" будет выполнено для числа $2$. Следовательно, результат всегда $0$.\n6. **Сложность**: $O(1)$, так как логика сводится к проверке $N \\ge 2$.\n\n**Важное уточнение по логике**: \nПроверим: \n- $p=2 \\implies \\text{sum}(2) = 2$. (True)\n- $p=3 \\implies \\text{sum}(3) = 3$. (True)\n- $p=11 \\implies \\text{sum}(11) = 2 \\neq 11$. (False)\nТак как $2$ — это простое число и оно всегда входит в список, если $N \\ge 2$, то условие \"сумма цифр равна числу\" всегда сработает для $p=2$.\n\n**Сложность**:\n- Временная: $O(1)$.\n- Пространственная: $O(1)$.\n</think>\n\n```python\ndef solve_prime_product(n: int) -> int:\n \"\"\"\n Вычисляет произведение всех простых чисел, не превышающих N.\n Если среди них есть число, сумма цифр которого равна самому числу, возвращает 0.\n \"\"\"\n # 1. Обработка отрицательных значений и N < 2.\n # По математическому определению, произведение пустого множества равно 1.\n if n < 2:\n return 1\n\n # 2. Алгоритм поиска простых чисел и проверки условия.\n # Условие: \"сумма цифр числа равна самому числу\".\n # Это свойство выполняется для любого однозначного числа (0-9).\n # Первое простое число - это 2.\n # Сумма цифр числа 2 равна 2.\n # Таким образом, если N >= 2, то в последовательности простых чисел \n # обязательно будет число 2, которое удовлетворяет условию.\n \n # Проверим это формально через цикл, чтобы соответствовать \"алгоритму\", \n # хотя математически результат всегда будет 0 при N >= 2.\n \n def get_sum_of_digits(num: int) -> int:\n return sum(int(digit) for digit in str(abs(num)))\n\n def is_prime(k: int) -> bool:\n if k < 2:\n return False\n for i in range(2, int(k**0.5) + 1):\n if k % i == 0:\n return False\n return True\n\n primes = []\n for i in range(2, n + 1):\n if is_prime(i):\n # Проверяем условие: сумма цифр равна самому числу\n if get_sum_of_digits(i) == i:\n return 0\n primes.append(i)\n\n # Если мы дошли сюда, значит условие не сработало (что невозможно для N >= 2)\n product = 1\n for p in primes:\n product *= p\n \n return product\n\nif __name__ == \"__main__\":\n # Тестирование различных сценариев\n test_cases = [\n (-5, 1), # N < 2\n (0, 1), # N < 2\n (1, 1), # N < 2\n (2, 0), # N = 2, простое 2, сумма цифр 2 == 2 -> 0\n (10, 0), # N = 10, простые 2, 3, 5, 7. Все они удовлетворяют условию -> 0\n (15, 0), # N = 15, простые 2, 3, 5, 7, 11, 13. 2 удовлетворяет условию -> 0\n ]\n\n for n_val, expected in test_cases:\n result = solve_prime_product(n_val)\n```"}]}
|
| {"language": "ru", "category": "Алгоритмы поиска, сортировки и фильтрации в списках", "messages": [{"role": "system", "content": "Ты продвинутый AI разработчик. Перед написанием кода ты анализируешь задачу внутри тегов <think>...</think>, затем пишешь чистый рабочий код."}, {"role": "user", "content": "Дан список цен на товары, где некоторые значения могут быть отрицательными (ошибки системы) или нулевыми. Напишите функцию, которая возвращает новый список, состоящий только из уникальных положительных цен, отсортированных по убыванию. Учтите, что в исходном списке могут быть дубликаты, которые не должны попасть в итоговый результат."}, {"role": "assistant", "content": "<think>\n
|
| {"language": "ru", "category": "ООП: классы, наследование, dunder-методы (__repr__, __add__)", "messages": [{"role": "system", "content": "Ты продвинутый AI разработчик. Перед написанием кода ты анализируешь задачу внутри тегов <think>...</think>, затем пишешь чистый рабочий код."}, {"role": "user", "content": "Создайте класс `Vector`, представляющий точку в пространстве, с реализацией магических методов для сложения векторов и корректного строкового представления. Реализуйте наследование через класс `ScaledVector`, который при сложении с обычным вектором должен возвращать новый объект, а при попытке сложения двух `ScaledVector` с разными коэффициентами — корректно обрабатывать их веса. Подвох заключается в необходимости правильно настроить методы так, чтобы операции не приводили к потере точности или неверному типу возвращаемого объекта при взаимодействии разных подклассов."}, {"role": "assistant", "content": "<think>\n**Анализ задачи:**\n\n1. **Класс `Vector`**:\n * Должен хранить координаты (предположим, 2D или 3D, но сделаем универсальным через кортеж/список).\n * Метод `__add__`: Сложение двух векторов. Результат должен быть объектом `Vector`.\n * Метод `__repr__` или `__str__`: Строковое представление вида `Vector(x, y, ...)`.\n * Метод `__eq__`: Для корректного сравнения (полезно для тестов).\n\n2. **Класс `ScaledVector` (наследник `Vector`)**:\n * Должен хранить дополнительный атрибут `scale` (коэффициент).\n * Логика сложения (`__add__`):\n * `ScaledVector` + `Vector` $\\rightarrow$ `ScaledVector`. Математически: $s \\cdot \\vec{v} + \\vec{u} = \\text{новый вектор с масштабом } 1 \\text{ (или специфическим), но здесь логичнее трактовать это как суммирование весов}$.\n * *Уточнение логики*: Если мы складываем масштабированный вектор с обычным, результат должен учитывать масштаб. Если $S_1 \\cdot V_1 + S_2 \\cdot V_2$, то результат — это вектор с координатами $\\sum (scale_i \\cdot coord_i)$. \n * *Важный нюанс*: Чтобы избежать проблем с типами, нужно использовать `__radd__` (right add), если левый операнд — обычный `Vector`.\n * *Сценарий 1*: `ScaledVector(v, s) + Vector(u)` $\\rightarrow$ результат должен быть `ScaledVector` (или `Vector`, если масштаб считается примененным к координатам). Согласно условию: \"возвращать новый объект [ScaledVector]\".\n * *Сценарий 2*: `ScaledVector(v1, s1) + ScaledVector(v2, s2)` $\\rightarrow$ результат должен быть `ScaledVector`.\n\n3. **Алгоритм сложения**:\n * При сложении $A + B$:\n * Если $A$ — `ScaledVector` и $B$ — `Vector`: $Result = ScaledVector(A.coords \\cdot A.scale + B.coords, scale=1)$. Но по условию \"обрабатывать веса\", правильнее считать, что масштаб — это множитель самого вектора.\n * Математически: $\\vec{R} = (scale_A \\cdot \\vec{V}_A) + (scale_B \\cdot \\vec{V}_B)$. \n * Чтобы сохранить \"тип\" и \"вес\", при сложении двух `ScaledVector` с коэффициентами $s_1$ и $s_2$, мы можем либо возвращать вектор с координатами $\\sum s_i v_i$ и масштабом $1$, либо (что более архитектурно верно для \"весов\") возвращать новый `ScaledVector` с суммарным весом. Однако, в физике/линейной алгебре масштаб — это свойство вектора. \n * **Решение для реализации**: \n * `Vector + Vector = Vector`\n * `ScaledVector + Vector = ScaledVector` (где координаты уже умножены на scale, а новый scale = 1)\n * `Vector + ScaledVector = ScaledVector` (через `__radd__`)\n * `ScaledVector + ScaledVector = ScaledVector` (координаты = $s_1 v_1 + s_2 v_2$, scale = 1).\n\n4. **Краевые случаи**:\n * Разная размерность векторов (выбросить `ValueError`).\n * Сложение `Vector` и `ScaledVector` (порядок имеет значение).\n * Потеря точности (использовать float).\n\n5. **Сложность**:\n * Временная: $O(N)$, где $N$ — размерность вектора.\n * Пространственная: $O(N)$ для хранения нового объекта.\n</think>\n\n```python\nfrom typing import Union, Tuple\n\nclass Vector:\n \"\"\"Класс, представляющий вектор в N-мерном пространстве.\"\"\"\n\n def __init__(self, *coords: float):\n self.coords = tuple(float(c) for c in coords)\n\n def __len__(self) -> int:\n return len(self.coords)\n\n def __add__(self, other: 'Union[Vector, \"ScaledVector\"]') -> 'Vector':\n \"\"\"Реализация сложения векторов.\"\"\"\n if not isinstance(other, (Vector, ScaledVector)):\n return NotImplemented\n \n if len(self) != len(other):\n raise ValueError(\"Векторы должны иметь одинаковую размерность.\")\n\n # Если складываем ScaledVector с Vector, ScaledVector сам управляет процессом через свой __add__\n # Если складываем Vector с ScaledVector, сработает __radd__ у ScaledVector\n \n new_coords = tuple(a + b for a, b in zip(self.coords, other.coords))\n return Vector(*new_coords)\n\n def __radd__(self, other: 'Union[Vector, \"ScaledVector\"]') -> 'Vector':\n \"\"\"Обработка случая Vector + ScaledVector.\"\"\"\n return other.__add__(self)\n\n def __repr__(self) -> str:\n coords_str = \", \".join(map(str, self.coords))\n return f\"Vector({coords_str})\"\n\n def __eq__(self, other: object) -> bool:\n if not isinstance(other, Vector):\n return False\n return len(self) == len(other) and all(abs(a - b) < 1e-9 for a, b in zip(self.coords, other.coords))\n\n\nclass ScaledVector(Vector):\n \"\"\"Класс, представляющий масштабированный вектор (вес * вектор).\"\"\"\n\n def __init__(self, scale: float, *coords: float):\n super().__init__(*coords)\n self.scale = float(scale)\n\n def __add__(self, other: 'Union[Vector, \"ScaledVector\"]') -> 'ScaledVector':\n \"\"\"\n Реализация сложения с учетом весов.\n Результат всегда возвращает ScaledVector для сохранения возможности дальнейших операций.\n \"\"\"\n```"}]}
|
| {"language": "en", "category": "List searching, sorting, and advanced filtering algorithms", "messages": [{"role": "system", "content": "You are an expert AI software engineer. You analyze problems inside <think>...</think> tags before writing clean, robust code."}, {"role": "user", "content": "You are tasked with managing a digital inventory of product prices, where some entries may be duplicate, negative (representing discounts), or zero. Write a function that returns a sorted list of all unique prices that are strictly greater than a given threshold, excluding any non-positive values. Your solution must handle empty input lists and scenarios where no prices meet the specified criteria without raising errors."}, {"role": "assistant", "content": "<think>\n* Input: A list of numbers (`prices`) and a numeric `threshold`.\n * Constraints/Requirements:\n 1. Filter: Only keep prices $> 0$ (strictly positive).\n 2. Filter: Only keep prices $> threshold$.\n 3. Uniqueness: Remove duplicates.\n 4. Ordering: Return the result as a sorted list.\n 5. Edge Cases: Empty input list, no prices meeting criteria, all prices $\\le 0$, threshold $\\ge$ all prices.\n 6. Error Handling: Must not raise errors on empty or non-matching inputs.\n\n * Algorithm:\n 1. Initialize an empty set (to handle uniqueness efficiently).\n 2. Iterate through the `prices` list.\n 3. For each `price`, check if `price > 0` AND `price > threshold`.\n 4. If both conditions are met, add the price to the set.\n 5. Convert the set to a list.\n 6. Sort the list.\n 7. Return the list.\n\n * Complexity Analysis:\n * Time Complexity: $O(N \\log N)$ where $N$ is the number of unique elements meeting the criteria (due to sorting). The initial pass is $O(M)$ where $M$ is the length of the input list.\n * Space Complexity: $O(N)$ to store the unique elements in the set and the final list.\n\n * Edge Case Scenarios:\n * `prices = []`: Should return `[]`.\n * `prices = [-5, 0, 10, 10, 20]`, `threshold = 5`: Result should be `[10, 20]`.\n * `prices = [1, 2, 3]`, `threshold = 10`: Result should be `[]`.\n * `prices = [-1, -2, 0]`, `threshold = -5`: Result should be `[]` (because non-positives are excluded).\n\n * Implementation Detail:\n A single list comprehension or a generator expression passed to `set()` followed by `sorted()` is the most Pythonic and efficient way.\n</think>\n\n```python\nfrom typing import List, Union\n\ndef get_filtered_unique_prices(prices: List[Union[int, float]], threshold: Union[int, float]) -> List[Union[int, float]]:\n \"\"\"\n Returns a sorted list of unique prices that are strictly greater than \n the given threshold and strictly greater than zero.\n\n Args:\n prices: A list of numbers representing product prices.\n threshold: The minimum value threshold (exclusive).\n\n Returns:\n A sorted list of unique, positive prices exceeding the threshold.\n \"\"\"\n
|
| {"language": "ru", "category": "Словари и множества (dict, set, Counter, defaultdict)", "messages": [{"role": "system", "content": "Ты продвинутый AI разработчик. Перед написанием кода ты анализируешь задачу внутри тегов <think>...</think>, затем пишешь чистый рабочий код."}, {"role": "user", "content": "Напишите функцию, которая принимает список строк и возвращает словарь, где ключами являются уникальные слова, а значениями — количество их вхождений, но только для тех слов, которые встречаются в списке строго больше одного раза. При этом алгоритм должен игнорировать регистр символов и учитывать, что в исходных данных могут присутствовать пустые строки или строки, состоящие только из пробелов. Ваша задача — эффективно отфильтровать «одиночек» и лишние элементы, используя специализированные инструменты стандартной библиотеки."}, {"role": "assistant", "content": "<think>\n**Анализ задачи:**\n\n1. **Входные данные:** Список строк (`List[str]`).\n2. **Требования к обработке:**\n * **Регистр:** Игнорировать (привести к нижнему регистру).\n * **Пустые строки/пробелы:** Игнорировать (фильтрация пустых элементов).\n * **Уникальность:** Ключи — уникальные слова.\n * **Фильтрация:** В итоговый словарь должны попасть только те слова, частота которых $> 1$.\n * **Инструментарий:** Использовать специализированные инструменты стандартной библиотеки (идеально подходит `collections.Counter`).\n\n3. **Алгоритм:**\n * Создать генераторное выражение для обработки входного списка:\n * Пропустить строки, состоящие только из пробелов (`if s.strip()`).\n * Привести строку к нижнему регистру (`s.lower()`).\n * Передать этот генератор в `collections.Counter` для быстрого подсчета вхождений.\n * Использовать Dictionary Comprehension для фильтрации полученного словаря, оставляя только элементы с `count > 1`.\n\n4. **Краевые случаи:**\n * Пустой список на входе $\\rightarrow$ пустой словарь.\n * Список только из пустых строк $\\rightarrow$ пустой словарь.\n * Все слова встречаются по одному разу $\\rightarrow$ пустой словарь.\n * Смешанный регистр («Apple\", \"apple\", \"APPLE\") $\\rightarrow$ одно слово \"apple\" с count=3.\n\n5. **Сложность:**\n * **Временная сложность:** $O(N)$, где $N$ — суммарное количество символов во всех строках. Нам нужно один раз пройти по списку для подсчета.\n * **Пространственная сложность:** $O(U)$, где $U$ — количество уникальных слов в списке, для хранения словаря частот.\n</think>\n\n```python\nfrom collections import Counter\n\ndef count_duplicate_words(strings: list[str]) -> dict[str, int]:\n \"\"\"\n Возвращает словарь с частотой слов, которые встречаются более одного раза.\n Игнорирует регистр и пустые строки.\n \n :param strings: Список строк для обработки.\n :return: Словарь {слово: количество_вхождений} для дубликатов.\n \"\"\"\n \n
|
| {"language": "ru", "category": "Обработка исключений try-except и кастомные Exception", "messages": [{"role": "system", "content": "Ты продвинутый AI разработчик. Перед написанием кода ты анализируешь задачу внутри тегов <think>...</think>, затем пишешь чистый рабочий код."}, {"role": "user", "content": "Реализуйте систему обработки банковских транзакций, которая должна выбрасывать кастомное исключение `InsufficientFundsError`, если баланс пользователя становится отрицательным, и `InvalidAmountError`, если сумма перевода не является положительным числом. Логическая ловушка заключается в необходимости корректно обрабатывать ситуацию, когда ошибка недостаточности средств возникает одновременно с попыткой перевода некорректного типа данных (например, строки вместо числа). Ваша программа должна гарантировать, что при возникновении цепочки исключений (exception chaining) пользователь получит максимально информативное сообщение, не теряя контекста первоначальной ошибки."}, {"role": "assistant", "content": "<think>\n**Анализ задачи:**\n\n1. **Цель:** Реализовать систему банковских транзакций с кастомными исключениями и механизмом \"цепочки исключений\" (exception chaining) в Python.\n2. **Требуемые исключения:**\n * `InsufficientFundsError`: если баланс становится $\\le 0$ после операции.\n * `InvalidAmountError`: если сумма перевода $\\le 0$.\n3. **Логическая ловушка (Edge Cases):**\n * **Тип данных:** Если пользователь передает строку вместо числа, возникнет `TypeError`.\n * **Приоритетность:** Согласно условию, если передана некорректная сумма (например, строка), это ошибка типа/валидации, которая должна быть \"первичной\" или \"внешней\". Однако, если сумма — число, но она больше баланса, возникает `InsufficientFundsError`.\n * **Цепочка исключений:** В Python для этого используется ключевое слово `raise... from...`. Это позволяет связать текущее исключение с причиной (cause), сохраняя traceback.\n4. **Алгоритм работы метода `transfer`:**\n * Шаг 1: Проверка типа `amount` (если не число $\\rightarrow$ `raise InvalidAmountError from TypeError`).\n * Шаг 2: Проверка `amount > 0` (если $\\le 0 \\rightarrow$ `raise InvalidAmountError`).\n * Шаг 3: Проверка баланса (если `balance - amount < 0` $\\rightarrow$ `raise InsufficientFundsError from original_context`).\n * Шаг 4: Обновление баланса.\n5. **Сложность:**\n * Временная сложность: $O(1)$ для каждой транзакции.\n * Пространственная сложность: $O(1)$.\n\n**План реализации:**\n1. Определить базовый класс исключения `BankError`.\n2. Определить `InsufficientFundsError` и `InvalidAmountError`.\n3. Создать класс `BankAccount` с методом `transfer`.\n4. Реализовать обработку ошибок с использованием `raise... from...`.\n5. Написать тестовый сценарий, проверяющий все граничные условия.\n</think>\n\n```python\nimport sys\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\"Недостаточно средств. Текущий баланс: {balance}, попытка перевода: {amount}\")\n\nclass InvalidAmountError(BankError):\n \"\"\"Исключение, возникающее при некорректной сумме перевода (отрицательная или неверный тип).\"\"\"\n pass\n\nclass BankAccount:\n def __init__(self, owner: str, balance: float):\n self.owner = owner\n self.balance = balance\n\n def transfer(self, amount):\n \"\"\"\n Переводит указанную сумму со счета.\n Реализует цепочку исключений для сохранения контекста.\n \"\"\"\n try:\n # 1. Проверка на тип данных (Ловушка: некорректный тип)\n if not isinstance(amount, (int, float)):\n # Мы используем raise... from..., чтобы привязать TypeError к нашему бизнес-исключению\n raise TypeError(f\"Сумма должна быть числом, получено: {type(amount).__name__}\")\n \n # 2. Проверка на положительное число\n if amount <= 0:\n raise InvalidAmountError(f\"Сумма перевода должна быть положительным числом: {amount}\")\n\n # 3. Проверка баланса\n if self.balance - amount < 0:\n # Создаем исключение, которое \"знает\" о контексте текущего состояния\n raise InsufficientFundsError(self.balance, amount)\n\n # Если все проверки пройдены, списываем средства\n self.balance -= amount\n print(f\"Успешный перевод! Остаток на счету {self.owner}: {self.balance}\")\n\n except TypeError as te:\n # Связываем TypeError с бизнес-ошибкой InvalidAmountError\n # Это гарантирует, что пользователь увидит: \"InvalidAmountError:... caused by TypeError:...\"\n raise InvalidAmountError(\"Попытка совершить операцию с неверным типом данных\") from te\n \n except InsufficientFundsError as ife:\n # В данном случае контекст уже содержится в ife, но мы можем перевыбросить его\n # для демонстрации возможности перехвата в более глубоких слоях системы\n raise ife\n\n except Exception as e:\n # Защита от непредвиденных ошибок\n raise BankError(f\"Произошла системная ошибка: {str(e)}\") from e\n\n# --- Тестирование системы ---\n\ndef run_test_case(account, amount, description):\n print(f\"\\n--- Тест: {description} (Сумма: {amount}, Баланс: {account.balance}) ---\")\n try:\n account.transfer(amount)\n except BankError as e:\n print(f\"ПОЙМАНА ОШИБКА: {type(e).__name__}: {e}\")\n if e.__cause__:\n print(f\"КОНТЕКСТ ПЕРВИЧНОЙ ОШИБКИ: {type(e.__cause__).__name__}: {e.__cause__}\")\n except Exception as e:\n print(f\"Критическая ошибка: {e}\")\n\nif __name__ == \"__main__\":\n # Инициализация счета\n my_account = BankAccount(\"Александр\", 1000.0)\n\n # Тест 1: Успешный перевод\n run_test_case(my_account, 400.0, \"Успешный перевод\")\n\n # Тест 2: Недостаточно средств (число)\n run_test_case(my_account, 1500.0, \"Недостаточно средств\")\n\n # Тест 3: Отрицательная сумма\n run_test_case(my_account, -50.0, \"Отрицательная сумма\")\n\n # Тест 4: Логическая ловушка (некорректный тип данных\n```"}]}
|
| {"language": "en", "category": "Math computations, prime numbers, factorials, and GCD", "messages": [{"role": "system", "content": "You are an expert AI software engineer. You analyze problems inside <think>...</think> tags before writing clean, robust code."}, {"role": "user", "content": "**Problem Statement: The Primorial-Factorial Resonance**\n\nGiven two positive integers $N$ and $M$, determine if the Greatest Common Divisor (GCD) of $N!$ (N factorial) and the $M$-th primorial $P_M\\
|
| {"language": "en", "category": "Math computations, prime numbers, factorials, and GCD", "messages": [{"role": "system", "content": "You are an expert AI software engineer. You analyze problems inside <think>...</think> tags before writing clean, robust code."}, {"role": "user", "content": "**Problem Statement: The Primorial-Factorial GCD Challenge**\n\nGiven two integers $N$ and $M$, calculate the Greatest Common Divisor (GCD) of the $N$-th primorial (the product of the first $N$ prime numbers) and the $M$-th factorial ($M!$). Your solution must efficiently handle extremely large inputs and account for edge cases where $N$ or $M$ are zero or one, as well as scenarios where the prime factors of the primorial are entirely contained within the factorial."}, {"role": "assistant", "content": "<think>\n### Problem Breakdown\n\n**1. Definitions:**\n* **$N$-th Primorial ($P_N$):** The product of the first $N$ prime numbers. $P_N = p_1 \\times p_2 \\times \\dots \\times p_N$.\n* **$M$-th Factorial ($M!$):** The product of all integers from 1 to $M$. $M! = 1 \\times 2 \\times \\dots \\times M$.\n* **GCD($P_N, M!$):** The largest integer that divides both $P_N$ and $M!$.\n\n**2. Mathematical Insight:**\n* The prime factors of $P_N$ are exactly the first $N$ prime numbers $\\{p_1, p_2, \\dots, p_N\\}$.\n* Since $P_N$ is a product of *distinct* primes, its prime factorization is $p_1^1 \\cdot p_2^1 \\cdot \\dots \\cdot p_N^1$.\n* The GCD of two numbers is the product of the common prime factors, each raised to the minimum exponent found in both numbers.\n* Since the exponent of every prime in $P_N$ is exactly $1$, the GCD will be the product of all primes $p_i$ (where $1 \\le i \\le N$) such that $p_i$ is also a factor of $M!$.\n* A prime $p$ is a factor of $M!$ if and only if $p \\le M$.\n\n**3. Algorithm:**\n1. Handle edge cases: If $N=0$ or $M=0$, $P_0=1$ and $0!=1$, so $GCD(1, 1) = 1$. (Note: In many contexts, $0! = 1$ and the 0-th primorial is the empty product, which is 1).\n2. Generate the first $N$ prime numbers using a Sieve of Eratosthenes or a primality test.\n3. Iterate through the first $N$ primes.\n4. For each prime $p_i$, check if $p_i \\le M$.\n5. If $p_i \\le M$, multiply the running GCD product by $p_i$.\n6. Return the product.\n\n**4. Complexity Analysis:**\n* **Time Complexity:**\n * Finding $N$ primes: Using a sieve up to an estimated $N \\ln N$ range. The $N$-th prime is approximately $N \\ln N$. Sieve complexity is $O(K \\log \\log K)$ where $K \\approx N \\ln N$.\n * Iterating through $N$ primes: $O(N)$.\n * Total: $O(N \\log \\log N)$, which is very efficient for large $N$ (e.g., $N=10^6$).\n* **Space Complexity:** $O(N \\log N)$ to store the sieve/primes.\n\n**5. Edge Cases:**\n* $N=0$ or $M=0$: GCD is 1.\n* $N=1, M=1$: $P_1=2, 1!=1 \\implies GCD=1$.\n* $M$ is very small relative to $p_N$: Only primes $\\le M$ contribute.\n* $M$ is very large: All $N$ primes contribute.\n\n**6. Implementation Details:**\n* To find the first $N$ primes, we need an upper bound. By the Prime Number Theorem, $p_n \\approx n \\ln n$. A safe upper bound for $n \\ge 6$ is $n(\\ln n + \\ln \\ln n)$.\n* We use a sieve to find primes up to the bound.\n</think>\n\n```python\nimport math\n\ndef solve_primorial_factorial_gcd(n: int, m: int) -> int:\n \"\"\"\n Calculates the GCD of the N-th primorial and the M-th factorial.\n \n The N-th primorial is the product of the first N primes.\n The M-th factorial is M!.\n \n Logic:\n The N-th primorial is P = p1 * p2 * ... * pN.\n The M-th factorial is M! = 1 * 2 * ... * M.\n The GCD will be the product of all primes p_i such that \n p_i is one of the first N primes AND p_i <= M.\n \"\"\"\n \n # Edge cases: 0-th primorial is 1, 0! is 1.\n if n <= 0 or m <= 0:\n return 1\n\n # Step 1: Find the first N primes.\n # To find the N-th prime, we use the approximation p_n < n(ln n + ln ln n) for n >= 6.\n if n < 6:\n limit = 15 # Sufficient for small n\n else:\n # Using a slightly larger buffer for safety\n limit = int(n * (math.log(n) + math.log(math.log(n)))) + 10\n \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 if len(primes) == n:\n break\n for i in range(p * p, limit + 1, p):\n is_prime[i] = False\n \n # If for some reason we didn't reach N primes (due to limit estimation), \n # we would need a more robust prime generator, but the formula is mathematically sound.\n if len(primes) < n:\n # Fallback for extremely small or edge cases\n primes = []\n curr = 2\n while len(primes) < n:\n is_p = True\n for i in range(2, int(curr**0.5) + 1):\n if curr % i == 0:\n is_p = False\n break\n if is_p:\n primes.append(curr)\n curr += 1\n\n # Step 2: Calculate GCD\n # The GCD is the product of primes in the first N primes that are <= M.\n gcd_result = 1\n for p in primes:\n if p <= m:\n gcd_result *= p\n```"}]}
|
| {"language": "ru", "category": "Работа с файлами, чтение и запись JSON, CSV, модуль pathlib", "messages": [{"role": "system", "content": "Ты продвинутый AI разработчик. Перед написанием кода ты анализируешь задачу внутри тегов <think>...</think>, затем пишешь чистый рабочий код."}, {"role": "user", "content": "Напишите программу, которая считывает CSV-файл со списком пользователей и переносит данные о тех, кто не указал email, в отдельный JSON-файл, используя `pathlib` для проверки существования файлов. Учтите, что в исходном CSV могут встречаться пустые строки, а целевой JSON-файл должен не перезаписываться, а дополняться новыми записями без дублирования имен. Программа должна корректно обрабатывать случай, если файл с данными отсутствует или имеет неверную кодировку."}, {"role": "assistant", "content": "<think>\n**Анализ задачи:**\n\n1. **Входные данные:** CSV-файл со списком пользователей. Предположим, структура: `name,email`.\n2. **Условия фильтрации:** Пользователи без email (пустая строка или пробелы в поле email).\n3. **Выходные данные:** JSON-файл, содержащий список объектов.\n4. **Требования к реализации:**\n * Использование `pathlib` для проверки файлов.\n * Обработка пустых строк в CSV.\n * **Дозапись в JSON:** Если файл существует, нужно прочитать старые данные, добавить новые, исключив дубликаты по полю `name`.\n * **Обработка ошибок:** Отсутствие файла, неверная кодировка (нужно пробовать `utf-8` и, возможно, `latin-1` или `cp1251`, но для универсальности реализуем обработку исключений).\n * **Сложность:** \n * Чтение CSV: $O(N)$, где $N$ — число строк.\n * Чтение/Запись JSON: $O(M)$, где $M$ — число записей в JSON.\n * Итоговая сложность: $O(N + M)$.\n * **Краевые случаи:**\n * CSV пуст.\n * JSON файл пуст или содержит невалидный JSON.\n * Все пользователи имеют email.\n * Файл занят другим процессом (обработка через `try-except`).\n\n**Алгоритм:**\n1. Проверить существование CSV через `pathlib.Path.exists()`.\n2. Попробовать прочитать CSV. Если ошибка кодировки — вывести сообщение.\n3. Итерироваться по строкам, пропуская пустые.\n4. Если email пуст, добавить пользователя в список `new_users`.\n5. Проверить существование JSON.\n6. Если JSON существует:\n * Прочитать текущий список.\n * Создать словарь `{name: data}` для быстрого поиска дубликатов.\n * Добавить только тех, кого нет в словаре.\n7. Если JSON не существует или пуст:\n * Использовать `new_users`.\n8. Записать результат в JSON.\n</think>\n\n```python\nimport csv\nimport json\nfrom pathlib import Path\n\ndef process_users(csv_path_str: str, json_path_str: str):\n \"\"\"\n Читает CSV, находит пользователей без email и добавляет их в JSON,\n избегая дубликатов по имени.\n \"\"\"\n csv_path = Path(csv_path_str)\n json_path = Path(json_path_str)\n\n
|
|
|
