Merge pull request #106 from romankurnovskii/problems-1925-3100-3133-3164-3197-3228-3260-3291-3320-3351-3380-3413-3444-3471

romankurnovskii · web-flow · commit 2645c5bb7dad · 2025-12-08T10:48:38.000+02:00
Add solutions for problems 1925, 3100, 3133, 3164, 3197, 3228, 3260, …
diff --git a/solutions/1925/01.py b/solutions/1925/01.py
@@ -0,0 +1,16 @@
+class Solution:
+    def countTriples(self, n: int) -> int:
+        res = 0
+
+        # Iterate over all possible pairs (a, b)
+        for a in range(1, n + 1):
+            for b in range(1, n + 1):
+                # Calculate c^2 = a^2 + b^2
+                c_squared = a * a + b * b
+                c = int(c_squared**0.5)
+
+                # Check if c is a perfect square and within range
+                if c * c == c_squared and 1 <= c <= n:
+                    res += 1
+
+        return res
diff --git a/solutions/3100/01.py b/solutions/3100/01.py
@@ -0,0 +1,19 @@
+class Solution:
+    def maxBottlesDrunk(self, numBottles: int, numExchange: int) -> int:
+        res = 0
+        empty = 0
+        exchange = numExchange
+
+        # Drink all initial bottles
+        res += numBottles
+        empty = numBottles
+
+        # Continue exchanging while possible
+        while empty >= exchange:
+            # Exchange empty bottles for one full bottle
+            empty -= exchange
+            exchange += 1
+            res += 1
+            empty += 1
+
+        return res
diff --git a/solutions/3133/01.py b/solutions/3133/01.py
@@ -0,0 +1,25 @@
+class Solution:
+    def minEnd(self, n: int, x: int) -> int:
+        # We need to construct an array where:
+        # 1. nums[i+1] > nums[i]
+        # 2. AND of all elements = x
+        # 3. Minimize nums[n-1]
+
+        # The idea: merge x with (n-1) by keeping x's bits and filling others with (n-1)'s bits
+        res = x
+        v = n - 1
+        bit_pos = 0
+
+        while v > 0:
+            # Find a position where x has 0
+            while (res >> bit_pos) & 1:
+                bit_pos += 1
+
+            # Set that bit if v has 1
+            if v & 1:
+                res |= 1 << bit_pos
+
+            v >>= 1
+            bit_pos += 1
+
+        return res
diff --git a/solutions/3164/01.py b/solutions/3164/01.py
@@ -0,0 +1,28 @@
+class Solution:
+    def countMatchingSubarrays(self, nums: List[int], pattern: List[int]) -> int:
+        n = len(nums)
+        m = len(pattern)
+        res = 0
+
+        # Check each possible starting position
+        for i in range(n - m):
+            match = True
+            # Check if subarray starting at i matches pattern
+            for k in range(m):
+                if pattern[k] == 1:
+                    if nums[i + k + 1] <= nums[i + k]:
+                        match = False
+                        break
+                elif pattern[k] == 0:
+                    if nums[i + k + 1] != nums[i + k]:
+                        match = False
+                        break
+                else:  # pattern[k] == -1
+                    if nums[i + k + 1] >= nums[i + k]:
+                        match = False
+                        break
+
+            if match:
+                res += 1
+
+        return res
diff --git a/solutions/3197/01.py b/solutions/3197/01.py
@@ -0,0 +1,11 @@
+class Solution:
+    def minOperations(self, nums: List[int], k: int) -> int:
+        # Calculate XOR of all elements
+        xor_all = 0
+        for num in nums:
+            xor_all ^= num
+
+        # Count different bits between xor_all and k
+        diff = xor_all ^ k
+        res = bin(diff).count("1")
+        return res
diff --git a/solutions/3228/01.py b/solutions/3228/01.py
@@ -0,0 +1,41 @@
+class Solution:
+    def maxOperations(self, nums: List[int]) -> int:
+        n = len(nums)
+
+        # Try all possible first operation scores
+        possible_scores = [
+            nums[0] + nums[1],  # first two
+            nums[-1] + nums[-2],  # last two
+            nums[0] + nums[-1],  # first and last
+        ]
+
+        res = 0
+
+        for target_score in possible_scores:
+            # DP: dp[l][r] = max operations on subarray nums[l:r+1]
+            from functools import lru_cache
+
+            @lru_cache(maxsize=None)
+            def dp(l, r):
+                if r - l < 1:  # Need at least 2 elements
+                    return 0
+
+                max_ops = 0
+
+                # Try first two
+                if l + 1 <= r and nums[l] + nums[l + 1] == target_score:
+                    max_ops = max(max_ops, 1 + dp(l + 2, r))
+
+                # Try last two
+                if l <= r - 1 and nums[r - 1] + nums[r] == target_score:
+                    max_ops = max(max_ops, 1 + dp(l, r - 2))
+
+                # Try first and last
+                if l < r and nums[l] + nums[r] == target_score:
+                    max_ops = max(max_ops, 1 + dp(l + 1, r - 1))
+
+                return max_ops
+
+            res = max(res, dp(0, n - 1))
+
+        return res
diff --git a/solutions/3260/01.py b/solutions/3260/01.py
@@ -0,0 +1,16 @@
+class Solution:
+    def largestPalindrome(self, n: int, k: int) -> str:
+        # Generate largest n-digit number
+        max_num = 10**n - 1
+        min_num = 10 ** (n - 1)
+
+        # Try from largest to smallest
+        for num in range(max_num, min_num - 1, -1):
+            num_str = str(num)
+            # Check if it's a palindrome
+            if num_str == num_str[::-1]:
+                # Check if divisible by k
+                if num % k == 0:
+                    return num_str
+
+        return ""
diff --git a/solutions/3291/01.py b/solutions/3291/01.py
@@ -0,0 +1,24 @@
+class Solution:
+    def minValidStrings(self, words: List[str], target: str) -> int:
+        n = len(target)
+        # dp[i] = minimum valid strings to form target[0:i]
+        dp = [float("inf")] * (n + 1)
+        dp[0] = 0
+
+        # Build set of all possible prefixes from words
+        prefixes = set()
+        for word in words:
+            for i in range(1, len(word) + 1):
+                prefixes.add(word[:i])
+
+        # DP: for each position, try all matching prefixes
+        for i in range(n):
+            if dp[i] == float("inf"):
+                continue
+
+            for j in range(i + 1, n + 1):
+                substr = target[i:j]
+                if substr in prefixes:
+                    dp[j] = min(dp[j], dp[i] + 1)
+
+        return dp[n] if dp[n] != float("inf") else -1
diff --git a/solutions/3320/01.py b/solutions/3320/01.py
@@ -0,0 +1,50 @@
+class Solution:
+    def maximumLength(self, nums: List[int]) -> int:
+        n = len(nums)
+        res = 0
+
+        # Try all 4 parity patterns: all even, all odd, even-odd, odd-even
+        patterns = [
+            lambda x: x % 2 == 0,  # all even
+            lambda x: x % 2 == 1,  # all odd
+            lambda x, i: (x % 2 == 0) if i % 2 == 0 else (x % 2 == 1),  # even-odd
+            lambda x, i: (x % 2 == 1) if i % 2 == 0 else (x % 2 == 0),  # odd-even
+        ]
+
+        # For simple patterns (all even, all odd)
+        for pattern in patterns[:2]:
+            count = sum(1 for num in nums if pattern(num))
+            res = max(res, count)
+
+        # For alternating patterns
+        # Try even-odd pattern
+        count_even_odd = 0
+        last_parity = None
+        for num in nums:
+            if last_parity is None:
+                if num % 2 == 0:
+                    count_even_odd = 1
+                    last_parity = 0
+            else:
+                expected = 1 - last_parity
+                if num % 2 == expected:
+                    count_even_odd += 1
+                    last_parity = expected
+        res = max(res, count_even_odd)
+
+        # Try odd-even pattern
+        count_odd_even = 0
+        last_parity = None
+        for num in nums:
+            if last_parity is None:
+                if num % 2 == 1:
+                    count_odd_even = 1
+                    last_parity = 1
+            else:
+                expected = 1 - last_parity
+                if num % 2 == expected:
+                    count_odd_even += 1
+                    last_parity = expected
+        res = max(res, count_odd_even)
+
+        return res
diff --git a/solutions/3351/01.py b/solutions/3351/01.py
@@ -0,0 +1,22 @@
+class Solution:
+    def lastNonEmptyString(self, s: str) -> str:
+        from collections import Counter
+
+        # Count frequency of each character
+        count = Counter(s)
+        max_freq = max(count.values())
+
+        # Find characters with maximum frequency
+        max_chars = [char for char, freq in count.items() if freq == max_freq]
+
+        # Find last occurrence of each max frequency character
+        last_positions = {}
+        for i, char in enumerate(s):
+            if char in max_chars:
+                last_positions[char] = i
+
+        # Sort by last position and build result
+        sorted_chars = sorted(max_chars, key=lambda x: last_positions[x])
+        res = "".join(sorted_chars)
+
+        return res
diff --git a/solutions/3380/01.py b/solutions/3380/01.py
@@ -0,0 +1,49 @@
+class Solution:
+    def maxRectangleArea(self, points: List[List[int]]) -> int:
+        n = len(points)
+        res = -1
+
+        # Try all combinations of 4 points
+        for i in range(n):
+            for j in range(i + 1, n):
+                x1, y1 = points[i]
+                x2, y2 = points[j]
+
+                # Check if they can form opposite corners
+                # The other two corners would be (x1, y2) and (x2, y1)
+                corner3 = [x1, y2]
+                corner4 = [x2, y1]
+
+                # Check if corner3 and corner4 exist in points
+                if corner3 in points and corner4 in points:
+                    # Check if rectangle doesn't contain other points
+                    min_x, max_x = min(x1, x2), max(x1, x2)
+                    min_y, max_y = min(y1, y2), max(y1, y2)
+
+                    valid = True
+                    for point in points:
+                        px, py = point
+                        # Check if point is inside or on border (but not a corner)
+                        if (
+                            (min_x < px < max_x and min_y < py < max_y)
+                            or (
+                                min_x < px < max_x
+                                and min_y <= py <= max_y
+                                and point
+                                not in [points[i], points[j], corner3, corner4]
+                            )
+                            or (
+                                min_x <= px <= max_x
+                                and min_y < py < max_y
+                                and point
+                                not in [points[i], points[j], corner3, corner4]
+                            )
+                        ):
+                            valid = False
+                            break
+
+                    if valid:
+                        area = abs(x2 - x1) * abs(y2 - y1)
+                        res = max(res, area)
+
+        return res
diff --git a/solutions/3413/01.py b/solutions/3413/01.py
@@ -0,0 +1,30 @@
+class Solution:
+    def minimumTimeToInitialState(self, word: str, k: int) -> int:
+        n = len(word)
+
+        # Use Z-algorithm to find longest suffix which is also a prefix
+        def z_function(s):
+            n = len(s)
+            z = [0] * n
+            l, r = 0, 0
+            for i in range(1, n):
+                if i <= r:
+                    z[i] = min(r - i + 1, z[i - l])
+                while i + z[i] < n and s[z[i]] == s[i + z[i]]:
+                    z[i] += 1
+                if i + z[i] - 1 > r:
+                    l, r = i, i + z[i] - 1
+            return z
+
+        z = z_function(word)
+
+        # Find the minimum time
+        for i in range(1, n):
+            # Check if word[i:] is a prefix of word
+            if z[i] == n - i:
+                # Check if length is multiple of k
+                if (n - i) % k == 0:
+                    return (n - i) // k
+
+        # If no suffix-prefix match, return ceil(n/k)
+        return (n + k - 1) // k
diff --git a/solutions/3444/01.py b/solutions/3444/01.py
@@ -0,0 +1,22 @@
+class Solution:
+    def maximumLength(self, nums: List[int], k: int) -> int:
+        n = len(nums)
+        res = 0
+
+        # Try each possible value for (sub[0] + sub[1]) % k
+        for val in range(k):
+            # dp[i] = max length of subsequence ending with element x where x % k == i
+            dp = [0] * k
+
+            for num in nums:
+                r = num % k
+                # The previous element should satisfy: (prev + num) % k == val
+                # So: prev % k == (val - r + k) % k
+                prev_r = (val - r + k) % k
+
+                # Update dp[r] with dp[prev_r] + 1
+                new_len = dp[prev_r] + 1
+                dp[r] = max(dp[r], new_len)
+                res = max(res, new_len)
+
+        return res
diff --git a/solutions/3471/01.py b/solutions/3471/01.py
@@ -0,0 +1,26 @@
+class Solution:
+    def minOperations(self, nums: List[int]) -> int:
+        n = len(nums)
+        res = 0
+        i = 0
+
+        # Greedy: flip from left to right
+        while i < n:
+            if nums[i] == 0:
+                # Need to flip this position
+                if i + 2 < n:
+                    # Flip 3 consecutive elements
+                    nums[i] ^= 1
+                    nums[i + 1] ^= 1
+                    nums[i + 2] ^= 1
+                    res += 1
+                else:
+                    # Cannot flip, impossible
+                    return -1
+            i += 1
+
+        # Check if all are 1
+        if all(num == 1 for num in nums):
+            return res
+        else:
+            return -1
