Leetcode submissions on Alwaldend

2026-04-11 20:57:04 +0300 MSK

Sat, 11 Apr 2026 20:57:04 +0300

Code

class Solution:
    def minimumDistance(self, nums: List[int]) -> int:
        n = len(nums)
        nxt = [-1] * n
        occur = {}
        ans = n + 1

        for i in range(n - 1, -1, -1):
            if nums[i] in occur:
                nxt[i] = occur[nums[i]]
            occur[nums[i]] = i

        for i in range(n):
            second_pos = nxt[i]
            if second_pos != -1:
                third_pos = nxt[second_pos]
                if third_pos != -1:
                    ans = min(ans, third_pos - i)

        return -1 if ans == n + 1 else ans * 2

2026-04-10 21:12:54 +0300 MSK

Fri, 10 Apr 2026 21:12:54 +0300

Code

class Solution:
    def minimumDistance(self, nums: List[int]) -> int:
        n = len(nums)
        ans = n + 1

        for i in range(n - 2):
            for j in range(i + 1, n - 1):
                if nums[i] != nums[j]:
                    continue
                for k in range(j + 1, n):
                    if nums[j] == nums[k]:
                        ans = min(ans, k - i)
                        break

        return -1 if ans == n + 1 else ans * 2

2026-04-09 22:31:40 +0300 MSK

Thu, 09 Apr 2026 22:31:40 +0300

Code

class Solution:
    def xorAfterQueries(self, nums: List[int], queries: List[List[int]]) -> int:
        mod = 10**9 + 7
        n = len(nums)
        T = int(n**0.5)

        groups = [[] for _ in range(T)]
        for l, r, k, v in queries:
            if k < T:
                groups[k].append((l, r, v))
            else:
                for i in range(l, r + 1, k):
                    nums[i] = nums[i] * v % mod

        dif = [1] * (n + T)
        for k in range(1, T):
            if not groups[k]:
                continue
            dif[:] = [1] * len(dif)
            for l, r, v in groups[k]:
                dif[l] = dif[l] * v % mod
                R = ((r - l) // k + 1) * k + l
                dif[R] = dif[R] * pow(v, mod - 2, mod) % mod

            for i in range(k, n):
                dif[i] = dif[i] * dif[i - k] % mod
            for i in range(n):
                nums[i] = nums[i] * dif[i] % mod

        res = 0
        for x in nums:
            res ^= x
        return res

2026-04-08 20:09:31 +0300 MSK

Wed, 08 Apr 2026 20:09:31 +0300

Code

class Solution:
    MOD = 10**9 + 7

    def xorAfterQueries(self, nums: List[int], queries: List[List[int]]) -> int:
        for l, r, k, v in queries:
            for i in range(l, r + 1, k):
                nums[i] = (nums[i] * v) % self.MOD

        res = 0
        for x in nums:
            res ^= x

        return res

2026-04-07 20:43:50 +0300 MSK

Tue, 07 Apr 2026 20:43:50 +0300

Code

class Robot:

    TO_DIR = {
        0: "East",
        1: "North",
        2: "West",
        3: "South",
    }

    def __init__(self, width: int, height: int):
        self.moved = False
        self.idx = 0
        self.pos = list()
        self.dirs = list()

        pos_, dirs_ = self.pos, self.dirs

        for i in range(width):
            pos_.append((i, 0))
            dirs_.append(0)
        for i in range(1, height):
            pos_.append((width - 1, i))
            dirs_.append(1)
        for i in range(width - 2, -1, -1):
            pos_.append((i, height - 1))
            dirs_.append(2)
        for i in range(height - 2, 0, -1):
            pos_.append((0, i))
            dirs_.append(3)

        dirs_[0] = 3

    def step(self, num: int) -> None:
        self.moved = True
        self.idx = (self.idx + num) % len(self.pos)

    def getPos(self) -> List[int]:
        return list(self.pos[self.idx])

    def getDir(self) -> str:
        if not self.moved:
            return "East"
        return Robot.TO_DIR[self.dirs[self.idx]]

2026-04-06 20:15:21 +0300 MSK

Mon, 06 Apr 2026 20:15:21 +0300

Code

class Solution:
    def __init__(self):
        self.HASH_MULTIPLIER = (
            60013  # Slightly larger than 2 * max coordinate value
        )

    def robotSim(self, commands: List[int], obstacles: List[List[int]]) -> int:
        # Store obstacles in an set for efficient lookup
        obstacle_set = {self._hash_coordinates(x, y) for x, y in obstacles}

        # Define direction vectors: North, East, South, West
        directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]

        x, y = 0, 0
        max_distance_squared = 0
        current_direction = 0  # 0: North, 1: East, 2: South, 3: West

        for command in commands:
            if command == -1:  # Turn right
                current_direction = (current_direction + 1) % 4
                continue

            if command == -2:  # Turn left
                current_direction = (current_direction + 3) % 4
                continue

            # Move forward
            dx, dy = directions[current_direction]
            for _ in range(command):
                next_x, next_y = x + dx, y + dy
                if self._hash_coordinates(next_x, next_y) in obstacle_set:
                    break
                x, y = next_x, next_y

            max_distance_squared = max(max_distance_squared, x * x + y * y)

        return max_distance_squared

    # Hash function to convert (x, y) coordinates to a unique integer value
    def _hash_coordinates(self, x: int, y: int) -> int:
        return x + self.HASH_MULTIPLIER * y

2026-04-06 20:14:55 +0300 MSK

Mon, 06 Apr 2026 20:14:55 +0300

Code

class Solution(object):
    def judgeCircle(self, moves):
        x = y = 0
        for move in moves:
            if move == 'U': y -= 1
            elif move == 'D': y += 1
            elif move == 'L': x -= 1
            elif move == 'R': x += 1

        return x == y == 0

2026-04-04 20:41:56 +0300 MSK

Sat, 04 Apr 2026 20:41:56 +0300

Code

class Solution:
    def decodeCiphertext(self, encodedText: str, rows: int) -> str:
        if rows == 1:
            return encodedText

        n = len(encodedText)
        cols = n // rows
        res = []

        for c in range(cols):
            r, j = 0, c
            while r < rows and j < cols:
                res.append(encodedText[r * cols + j])
                r += 1
                j += 1

        return "".join(res).rstrip()

2026-04-03 22:48:45 +0300 MSK

Fri, 03 Apr 2026 22:48:45 +0300

Code

class Solution:
    def maxWalls(
        self, robots: List[int], distance: List[int], walls: List[int]
    ) -> int:
        n = len(robots)
        robot_dist = list(zip(robots, distance))
        robot_dist.sort(key=lambda x: x[0])
        walls.sort()

        m = len(walls)
        right_ptr = left_ptr = cur_ptr = robot_ptr = 0

        prev_left = prev_right = prev_num = 0
        sub_left = sub_right = 0

        for i in range(n):
            robot_pos, robot_dist_val = robot_dist[i]

            while right_ptr < m and walls[right_ptr] <= robot_pos:
                right_ptr += 1
            pos1 = right_ptr

            while cur_ptr < m and walls[cur_ptr] < robot_pos:
                cur_ptr += 1
            pos2 = cur_ptr

            if i >= 1:
                left_bound = max(
                    robot_pos - robot_dist_val, robot_dist[i - 1][0] + 1
                )
            else:
                left_bound = robot_pos - robot_dist_val

            while left_ptr < m and walls[left_ptr] < left_bound:
                left_ptr += 1
            left_pos = left_ptr
            current_left = pos1 - left_pos

            if i < n - 1:
                right_bound = min(
                    robot_pos + robot_dist_val, robot_dist[i + 1][0] - 1
                )
            else:
                right_bound = robot_pos + robot_dist_val

            while right_ptr < m and walls[right_ptr] <= right_bound:
                right_ptr += 1
            right_pos = right_ptr
            current_right = right_pos - pos2

            current_num = 0
            if i > 0:
                while robot_ptr < m and walls[robot_ptr] < robot_dist[i - 1][0]:
                    robot_ptr += 1
                pos3 = robot_ptr
                current_num = pos1 - pos3

            if i == 0:
                sub_left = current_left
                sub_right = current_right
            else:
                new_sub_left = max(
                    sub_left + current_left,
                    sub_right
                    - prev_right
                    + min(current_left + prev_right, current_num),
                )
                new_sub_right = max(
                    sub_left + current_right, sub_right + current_right
                )
                sub_left = new_sub_left
                sub_right = new_sub_right

            prev_left = current_left
            prev_right = current_right
            prev_num = current_num

        return max(sub_left, sub_right)

2026-04-02 19:46:57 +0300 MSK

Thu, 02 Apr 2026 19:46:57 +0300

Code

class Solution:
    def maximumAmount(self, coins: List[List[int]]) -> int:
        n = len(coins[0])
        dp = [[-inf] * 3 for _ in range(n + 1)]

        dp[1] = [0] * 3
        for row in coins:
            for j, x in enumerate(row):
                dp[j + 1][2] = max(
                    dp[j][2] + x, dp[j + 1][2] + x, dp[j][1], dp[j + 1][1]
                )
                dp[j + 1][1] = max(
                    dp[j][1] + x, dp[j + 1][1] + x, dp[j][0], dp[j + 1][0]
                )
                dp[j + 1][0] = max(dp[j][0], dp[j + 1][0]) + x

        return dp[n][2]

2026-04-01 20:54:07 +0300 MSK

Wed, 01 Apr 2026 20:54:07 +0300

Code

class Solution:
    def survivedRobotsHealths(
        self, positions: List[int], healths: List[int], directions: str
    ) -> List[int]:
        n = len(positions)
        indices = list(range(n))
        result = []
        stack = deque()

        # Sort indices based on their positions
        indices.sort(key=lambda x: positions[x])

        for current_index in indices:
            # Add right-moving robots to the stack
            if directions[current_index] == "R":
                stack.append(current_index)
            else:
                while stack and healths[current_index] > 0:
                    # Pop the top robot from the stack for collision check
                    top_index = stack.pop()

                    if healths[top_index] > healths[current_index]:
                        # Top robot survives, current robot is destroyed
                        healths[top_index] -= 1
                        healths[current_index] = 0
                        stack.append(top_index)
                    elif healths[top_index] < healths[current_index]:
                        # Current robot survives, top robot is destroyed
                        healths[current_index] -= 1
                        healths[top_index] = 0
                    else:
                        # Both robots are destroyed
                        healths[current_index] = 0
                        healths[top_index] = 0

        # Collect surviving robots
        for index in range(n):
            if healths[index] > 0:
                result.append(healths[index])

        return result

2026-03-31 23:43:31 +0300 MSK

Tue, 31 Mar 2026 23:43:31 +0300

Code

class Solution:
    def generateString(self, str1: str, str2: str) -> str:
        n, m = len(str1), len(str2)
        s = ["a"] * (n + m - 1)
        fixed = [False] * (n + m - 1)

        # process the case of 'T'
        for i, ch in enumerate(str1):
            if ch == "T":
                for j, c in enumerate(str2, i):
                    if fixed[j] and s[j] != c:
                        return ""
                    s[j], fixed[j] = c, True

        # process the case of 'F'
        for i, ch in enumerate(str1):
            if ch == "F":
                # check if there are already different characters
                if any(str2[j - i] != s[j] for j in range(i, i + m)):
                    continue

                # find the first modifiable position
                for j in range(i + m - 1, i - 1, -1):
                    if not fixed[j]:
                        s[j] = "b"
                        break
                else:
                    return ""

        return "".join(s)

2026-03-30 19:50:10 +0300 MSK

Mon, 30 Mar 2026 19:50:10 +0300

Code

class Solution:
    def checkStrings(self, s1: str, s2: str) -> bool:
        return Counter(s1[::2]) == Counter(s2[::2]) and Counter(
            s1[1::2]
        ) == Counter(s2[1::2])

2026-03-29 23:45:59 +0300 MSK

Sun, 29 Mar 2026 23:45:59 +0300

Code

class Solution:
    def canBeEqual(self, s1: str, s2: str) -> bool:
        a = sorted([s1[0], s1[2]])
        b = sorted([s1[1], s1[3]])
        c = sorted([s2[0], s2[2]])
        d = sorted([s2[1], s2[3]])
        return a == c and b == d

2026-03-28 19:49:17 +0300 MSK

Sat, 28 Mar 2026 19:49:17 +0300

Code

class Solution:
    def findTheString(self, lcp: List[List[int]]) -> str:
        n = len(lcp)
        word = [""] * n
        current = ord("a")

        # construct the string starting from 'a' to 'z' sequentially
        for i in range(n):
            if not word[i]:
                if current > ord("z"):
                    return ""
                word[i] = chr(current)
                for j in range(i + 1, n):
                    if lcp[i][j]:
                        word[j] = word[i]
                current += 1

        # verify if the constructed string meets the LCP matrix requirements
        for i in range(n - 1, -1, -1):
            for j in range(n - 1, -1, -1):
                if word[i] != word[j]:
                    if lcp[i][j]:
                        return ""
                else:
                    if i == n - 1 or j == n - 1:
                        if lcp[i][j] != 1:
                            return ""
                    else:
                        if lcp[i][j] != lcp[i + 1][j + 1] + 1:
                            return ""

        return "".join(word)

2026-03-27 09:35:17 +0300 MSK

Fri, 27 Mar 2026 09:35:17 +0300

Code

class Solution:
    def areSimilar(self, mat: List[List[int]], k: int) -> bool:
        m, n = len(mat), len(mat[0])
        for i in range(m):
            is_even = i % 2 == 0
            for j in range(n):
                if is_even:
                    new_j = (j - k) % n    
                else:
                    new_j = (j + k) % n
                if mat[i][j] != mat[i][new_j]:
                    return False
        return True

2026-03-26 21:00:59 +0300 MSK

Thu, 26 Mar 2026 21:00:59 +0300

Code

class Solution:
    def canPartitionGrid(self, grid: List[List[int]]) -> bool:
        total = 0
        m = len(grid)
        n = len(grid[0])
        for i in range(m):
            for j in range(n):
                total += grid[i][j]
        for _ in range(4):
            exist = set()
            exist.add(0)
            sum_val = 0
            m = len(grid)
            n = len(grid[0])
            if m < 2:
                grid = self.rotation(grid)
                continue
            if n == 1:
                for i in range(m - 1):
                    sum_val += grid[i][0]
                    tag = sum_val * 2 - total
                    if tag == 0 or tag == grid[0][0] or tag == grid[i][0]:
                        return True
                grid = self.rotation(grid)
                continue
            for i in range(m - 1):
                for j in range(n):
                    exist.add(grid[i][j])
                    sum_val += grid[i][j]
                tag = sum_val * 2 - total
                if i == 0:
                    if tag == 0 or tag == grid[0][0] or tag == grid[0][n - 1]:
                        return True
                    continue
                if tag in exist:
                    return True
            grid = self.rotation(grid)
        return False

    def rotation(self, grid: List[List[int]]) -> List[List[int]]:
        m = len(grid)
        n = len(grid[0])
        tmp = [[0] * m for _ in range(n)]
        for i in range(m):
            for j in range(n):
                tmp[j][m - 1 - i] = grid[i][j]
        return tmp

2026-03-25 23:26:40 +0300 MSK

Wed, 25 Mar 2026 23:26:40 +0300

Code

class Solution:
    def constructProductMatrix(self, grid: List[List[int]]) -> List[List[int]]:
        MOD = 12345
        n, m = len(grid), len(grid[0])
        p = [[0] * m for _ in range(n)]

        suffix = 1
        for i in range(n - 1, -1, -1):
            for j in range(m - 1, -1, -1):
                p[i][j] = suffix
                suffix = (suffix * grid[i][j]) % MOD

        prefix = 1
        for i in range(n):
            for j in range(m):
                p[i][j] = (p[i][j] * prefix) % MOD
                prefix = (prefix * grid[i][j]) % MOD

        return p

2026-03-25 23:26:14 +0300 MSK

Wed, 25 Mar 2026 23:26:14 +0300

Code

class Solution:
    def canPartitionGrid(self, grid: List[List[int]]) -> bool:
        m, n = len(grid), len(grid[0])
        total = sum(sum(row) for row in grid)
        
        if total % 2:
            return False
        
        target = total // 2
        s = 0
        
        for i in range(m - 1):
            s += sum(grid[i])
            if s == target:
                return True
        
        s = 0
        
        for j in range(n - 1):
            for i in range(m):
                s += grid[i][j]
            if s == target:
                return True
        
        return False

2026-03-23 21:09:09 +0300 MSK

Mon, 23 Mar 2026 21:09:09 +0300

Code

class Solution:
    def maxProductPath(self, grid: List[List[int]]) -> int:
        mod = 10**9 + 7
        m, n = len(grid), len(grid[0])
        maxgt = [[0] * n for _ in range(m)]
        minlt = [[0] * n for _ in range(m)]

        maxgt[0][0] = minlt[0][0] = grid[0][0]
        for i in range(1, n):
            maxgt[0][i] = minlt[0][i] = maxgt[0][i - 1] * grid[0][i]
        for i in range(1, m):
            maxgt[i][0] = minlt[i][0] = maxgt[i - 1][0] * grid[i][0]

        for i in range(1, m):
            for j in range(1, n):
                if grid[i][j] >= 0:
                    maxgt[i][j] = (
                        max(maxgt[i][j - 1], maxgt[i - 1][j]) * grid[i][j]
                    )
                    minlt[i][j] = (
                        min(minlt[i][j - 1], minlt[i - 1][j]) * grid[i][j]
                    )
                else:
                    maxgt[i][j] = (
                        min(minlt[i][j - 1], minlt[i - 1][j]) * grid[i][j]
                    )
                    minlt[i][j] = (
                        max(maxgt[i][j - 1], maxgt[i - 1][j]) * grid[i][j]
                    )

        if maxgt[m - 1][n - 1] < 0:
            return -1
        return maxgt[m - 1][n - 1] % mod

2026-03-22 15:36:46 +0300 MSK

Sun, 22 Mar 2026 15:36:46 +0300

Code

class Solution:
    def findRotation(
        self, mat: List[List[int]], target: List[List[int]]
    ) -> bool:
        n = len(mat)
        # at most 4 rotations
        for k in range(4):
            # rotation operation
            for i in range(n // 2):
                for j in range((n + 1) // 2):
                    (
                        mat[i][j],
                        mat[n - 1 - j][i],
                        mat[n - 1 - i][n - 1 - j],
                        mat[j][n - 1 - i],
                    ) = (
                        mat[n - 1 - j][i],
                        mat[n - 1 - i][n - 1 - j],
                        mat[j][n - 1 - i],
                        mat[i][j],
                    )

            if mat == target:
                return True
        return False

2026-03-21 19:43:30 +0300 MSK

Sat, 21 Mar 2026 19:43:30 +0300

Code

class Solution:
    def reverseSubmatrix(
        self, grid: List[List[int]], x: int, y: int, k: int
    ) -> List[List[int]]:
        i0, i1 = x, x + k - 1
        while i0 < i1:
            for j in range(y, y + k):
                grid[i0][j], grid[i1][j] = grid[i1][j], grid[i0][j]
            i0, i1 = i0 + 1, i1 - 1
        return grid

2026-03-20 19:36:10 +0300 MSK

Fri, 20 Mar 2026 19:36:10 +0300

Code

class Solution:
    def minAbsDiff(self, grid: List[List[int]], k: int) -> List[List[int]]:
        m, n = len(grid), len(grid[0])
        res = [[0] * (n - k + 1) for _ in range(m - k + 1)]
        for i in range(m - k + 1):
            for j in range(n - k + 1):
                kgrid = []
                for x in range(i, i + k):
                    for y in range(j, j + k):
                        kgrid.append(grid[x][y])
                kmin = float("inf")
                kgrid.sort()
                for t in range(1, len(kgrid)):
                    if kgrid[t] == kgrid[t - 1]:
                        continue
                    kmin = min(kmin, kgrid[t] - kgrid[t - 1])
                if kmin != float("inf"):
                    res[i][j] = kmin
        return res

2026-03-19 23:36:34 +0300 MSK

Thu, 19 Mar 2026 23:36:34 +0300

Code

class Solution:
    def numberOfSubmatrices(self, grid: List[List[str]]) -> int:
        n, m = len(grid), len(grid[0])
        ans = 0
        sum = [[[0, 0] for _ in range(m + 1)] for _ in range(n + 1)]

        for i in range(n):
            for j in range(m):
                if grid[i][j] == "X":
                    sum[i + 1][j + 1][0] = (
                        sum[i + 1][j][0] + sum[i][j + 1][0] - sum[i][j][0] + 1
                    )
                    sum[i + 1][j + 1][1] = 1
                elif grid[i][j] == "Y":
                    sum[i + 1][j + 1][0] = (
                        sum[i + 1][j][0] + sum[i][j + 1][0] - sum[i][j][0] - 1
                    )
                    sum[i + 1][j + 1][1] = sum[i + 1][j][1] | sum[i][j + 1][1]
                else:
                    sum[i + 1][j + 1][0] = (
                        sum[i + 1][j][0] + sum[i][j + 1][0] - sum[i][j][0]
                    )
                    sum[i + 1][j + 1][1] = sum[i + 1][j][1] | sum[i][j + 1][1]
                if sum[i + 1][j + 1][0] == 0 and sum[i + 1][j + 1][1] == 1:
                    ans += 1

        return ans

2026-03-18 20:01:58 +0300 MSK

Wed, 18 Mar 2026 20:01:58 +0300

Code

class Solution:
    def countSubmatrices(self, grid: List[List[int]], k: int) -> int:
        n, m = len(grid), len(grid[0])
        cols = [0] * m
        res = 0

        for i in range(n):
            row_sum = 0
            for j in range(m):
                cols[j] += grid[i][j]
                row_sum += cols[j]
                if row_sum <= k:
                    res += 1

        return res

2026-03-17 21:22:16 +0300 MSK

Tue, 17 Mar 2026 21:22:16 +0300

Code

class Solution:
    def largestSubmatrix(self, matrix: List[List[int]]) -> int:
        m = len(matrix)
        n = len(matrix[0])
        prev_heights = []
        ans = 0

        for row in range(m):
            heights = []
            seen = [False] * n
            
            for height, col in prev_heights:
                if matrix[row][col] == 1:
                    heights.append((height + 1, col))
                    seen[col] = True

            for col in range(n):
                if seen[col] == False and matrix[row][col] == 1:
                    heights.append((1, col))
            
            for i in range(len(heights)):
                ans = max(ans, heights[i][0] * (i + 1))
                
            prev_heights = heights

        return ans

2026-03-16 21:13:19 +0300 MSK

Mon, 16 Mar 2026 21:13:19 +0300

Code

class Answer:
    def __init__(self):
        self.ans = [0, 0, 0]

    def put(self, x: int):
        _ans = self.ans

        if x > _ans[0]:
            _ans[0], _ans[1], _ans[2] = x, _ans[0], _ans[1]
        elif x != _ans[0] and x > _ans[1]:
            _ans[1], _ans[2] = x, _ans[1]
        elif x != _ans[0] and x != _ans[1] and x > _ans[2]:
            _ans[2] = x

    def get(self) -> List[int]:
        _ans = self.ans

        return [num for num in _ans if num != 0]


class Solution:
    def getBiggestThree(self, grid: List[List[int]]) -> List[int]:
        m, n = len(grid), len(grid[0])
        sum1 = [[0] * (n + 2) for _ in range(m + 1)]
        sum2 = [[0] * (n + 2) for _ in range(m + 1)]

        for i in range(1, m + 1):
            for j in range(1, n + 1):
                sum1[i][j] = sum1[i - 1][j - 1] + grid[i - 1][j - 1]
                sum2[i][j] = sum2[i - 1][j + 1] + grid[i - 1][j - 1]

        ans = Answer()
        for i in range(m):
            for j in range(n):
                # a single cell is also a rhombus
                ans.put(grid[i][j])
                for k in range(i + 2, m, 2):
                    ux, uy = i, j
                    dx, dy = k, j
                    lx, ly = (i + k) // 2, j - (k - i) // 2
                    rx, ry = (i + k) // 2, j + (k - i) // 2

                    if ly < 0 or ry >= n:
                        break

                    ans.put(
                        (sum2[lx + 1][ly + 1] - sum2[ux][uy + 2])
                        + (sum1[rx + 1][ry + 1] - sum1[ux][uy])
                        + (sum1[dx + 1][dy + 1] - sum1[lx][ly])
                        + (sum2[dx + 1][dy + 1] - sum2[rx][ry + 2])
                        - (
                            grid[ux][uy]
                            + grid[dx][dy]
                            + grid[lx][ly]
                            + grid[rx][ry]
                        )
                    )

        return ans.get()

2026-03-15 16:53:42 +0300 MSK

Sun, 15 Mar 2026 16:53:42 +0300

Code

class Fancy:

    def __init__(self):
        self.mod = 10**9 + 7
        self.v = list()
        self.a = 1
        self.b = 0

    # fast exponentiation
    def quickmul(self, x: int, y: int) -> int:
        return pow(x, y, self.mod)

    # multiplicative inverse
    def inv(self, x: int) -> int:
        return self.quickmul(x, self.mod - 2)

    def append(self, val: int) -> None:
        self.v.append((val - self.b) * self.inv(self.a) % self.mod)

    def addAll(self, inc: int) -> None:
        self.b = (self.b + inc) % self.mod

    def multAll(self, m: int) -> None:
        self.a = self.a * m % self.mod
        self.b = self.b * m % self.mod

    def getIndex(self, idx: int) -> int:
        if idx >= len(self.v):
            return -1
        return (self.a * self.v[idx] + self.b) % self.mod

2026-03-14 21:37:31 +0300 MSK

Sat, 14 Mar 2026 21:37:31 +0300

Code

class Solution:
    def getHappyString(self, n: int, k: int) -> str:
        # Calculate the total number of happy strings of length n
        total = 3 * (1 << (n - 1))

        # If k is greater than the total number of happy strings, return an empty string
        if k > total:
            return ""

        result = ["a"] * n  # Initialize result with 'a' characters

        # Define mappings for the next smallest and greatest valid characters
        next_smallest = {"a": "b", "b": "a", "c": "a"}
        next_greatest = {"a": "c", "b": "c", "c": "b"}

        # Calculate the starting indices for strings beginning with 'a', 'b', and 'c'
        start_a = 1
        start_b = start_a + (1 << (n - 1))
        start_c = start_b + (1 << (n - 1))

        # Determine the first character based on the value of k
        if k < start_b:
            result[0] = "a"
            k -= start_a
        elif k < start_c:
            result[0] = "b"
            k -= start_b
        else:
            result[0] = "c"
            k -= start_c

        # Iterate through the remaining positions in the result string
        for char_index in range(1, n):
            # Calculate the midpoint of the group for the current character position
            midpoint = 1 << (n - char_index - 1)

            # Determine the next character based on the value of k
            if k < midpoint:
                result[char_index] = next_smallest[result[char_index - 1]]
            else:
                result[char_index] = next_greatest[result[char_index - 1]]
                k -= midpoint

        return "".join(result)

2026-03-13 20:46:12 +0300 MSK

Fri, 13 Mar 2026 20:46:12 +0300

Code

class Solution:
    def minNumberOfSeconds(
        self, mountainHeight: int, workerTimes: List[int]
    ) -> int:
        maxWorkerTimes = max(workerTimes)
        l, r, ans = (
            1,
            maxWorkerTimes * mountainHeight * (mountainHeight + 1) // 2,
            0,
        )
        eps = 1e-7

        while l <= r:
            mid = (l + r) // 2
            cnt = 0
            for t in workerTimes:
                work = mid // t
                # find the largest k such that 1+2+...+k <= work
                k = int((-1 + ((1 + work * 8) ** 0.5)) / 2 + eps)
                cnt += k
            if cnt >= mountainHeight:
                ans = mid
                r = mid - 1
            else:
                l = mid + 1

        return ans

2026-03-12 19:11:46 +0300 MSK

Thu, 12 Mar 2026 19:11:46 +0300

Code

class DSU:
    def __init__(self, parent):
        self.parent = parent

    def find(self, x):
        if self.parent[x] == x:
            return x
        self.parent[x] = self.find(self.parent[x])
        return self.parent[x]

    def join(self, x, y):
        px = self.find(x)
        py = self.find(y)
        self.parent[px] = py


MAX_STABILITY = 200000


class Solution:
    def maxStability(self, n: int, edges: List[List[int]], k: int) -> int:
        ans = -1

        if len(edges) < n - 1:
            return -1

        mustEdges = [e for e in edges if e[3] == 1]
        optionalEdges = [e for e in edges if e[3] != 1]

        if len(mustEdges) > n - 1:
            return -1

        optionalEdges.sort(key=lambda x: x[2], reverse=True)

        selectedInit = 0
        mustMinStability = MAX_STABILITY
        dsuInit = DSU(list(range(n)))

        for u, v, s, must in mustEdges:
            if dsuInit.find(u) == dsuInit.find(v) or selectedInit == n - 1:
                return -1
            dsuInit.join(u, v)
            selectedInit += 1
            mustMinStability = min(mustMinStability, s)

        l = 0
        r = mustMinStability

        while l < r:
            mid = l + ((r - l + 1) >> 1)
            dsu = DSU(dsuInit.parent[:])
            selected = selectedInit
            doubledCount = 0

            for u, v, s, must in optionalEdges:
                if dsu.find(u) == dsu.find(v):
                    continue

                if s >= mid:
                    dsu.join(u, v)
                    selected += 1
                elif doubledCount < k and s * 2 >= mid:
                    doubledCount += 1
                    dsu.join(u, v)
                    selected += 1
                else:
                    break

                if selected == n - 1:
                    break

            if selected != n - 1:
                r = mid - 1
            else:
                ans = l = mid

        return ans

2026-03-11 21:48:29 +0300 MSK

Wed, 11 Mar 2026 21:48:29 +0300

Code

class Solution:
    def bitwiseComplement(self, n: int) -> int:
        if n == 0: return 1
        mask = n
        for i in (1, 2, 4, 8, 16):
            mask |= mask >> i
        return ~n & mask

2026-03-10 21:15:05 +0300 MSK

Tue, 10 Mar 2026 21:15:05 +0300

Code

class Solution:
    def numberOfStableArrays(self, zero: int, one: int, limit: int) -> int:
        mod = 10**9 + 7

        dp = [[[0, 0] for _ in range(one + 1)] for _ in range(zero + 1)]
        for i in range(zero + 1):
            for j in range(one + 1):
                for lastBit in range(2):
                    if i == 0:
                        if lastBit == 0 or j > limit:
                            dp[i][j][lastBit] = 0
                        else:
                            dp[i][j][lastBit] = 1
                    elif j == 0:
                        if lastBit == 1 or i > limit:
                            dp[i][j][lastBit] = 0
                        else:
                            dp[i][j][lastBit] = 1
                    elif lastBit == 0:
                        dp[i][j][lastBit] = dp[i - 1][j][0] + dp[i - 1][j][1]
                        if i > limit:
                            dp[i][j][lastBit] -= dp[i - limit - 1][j][1]
                    else:
                        dp[i][j][lastBit] = dp[i][j - 1][0] + dp[i][j - 1][1]
                        if j > limit:
                            dp[i][j][lastBit] -= dp[i][j - limit - 1][0]
                    dp[i][j][lastBit] %= mod
        return (dp[-1][-1][0] + dp[-1][-1][1]) % mod

2026-03-09 19:32:26 +0300 MSK

Mon, 09 Mar 2026 19:32:26 +0300

Code

class Solution:
    def numberOfStableArrays(self, zero: int, one: int, limit: int) -> int:
        dp = [[[0, 0] for _ in range(one + 1)] for _ in range(zero + 1)]
        mod = int(1e9 + 7)
        for i in range(min(zero, limit) + 1):
            dp[i][0][0] = 1
        for j in range(min(one, limit) + 1):
            dp[0][j][1] = 1
        for i in range(1, zero + 1):
            for j in range(1, one + 1):
                if i > limit:
                    dp[i][j][0] = (
                        dp[i - 1][j][0]
                        + dp[i - 1][j][1]
                        - dp[i - limit - 1][j][1]
                    )
                else:
                    dp[i][j][0] = dp[i - 1][j][0] + dp[i - 1][j][1]
                dp[i][j][0] = (dp[i][j][0] % mod + mod) % mod
                if j > limit:
                    dp[i][j][1] = (
                        dp[i][j - 1][1]
                        + dp[i][j - 1][0]
                        - dp[i][j - limit - 1][0]
                    )
                else:
                    dp[i][j][1] = dp[i][j - 1][1] + dp[i][j - 1][0]
                dp[i][j][1] = (dp[i][j][1] % mod + mod) % mod
        return (dp[zero][one][0] + dp[zero][one][1]) % mod

2026-03-08 19:12:47 +0300 MSK

Sun, 08 Mar 2026 19:12:47 +0300

Code

class Solution:
    def findDifferentBinaryString(self, nums: List[str]) -> str:
        ans = []
        for i in range(len(nums)):
            curr = nums[i][i]
            ans.append("1" if curr == "0" else "0")
        
        return "".join(ans)

2026-03-07 13:13:17 +0300 MSK

Sat, 07 Mar 2026 13:13:17 +0300

Code

class Solution:
    def minFlips(self, s: str) -> int:
        # Characteristic function
        I = lambda ch, x: int(ord(ch) - ord("0") == x)

        n = len(s)
        pre = [[0, 0] for _ in range(n)]
        # Note the boundary case when i=0
        for i in range(n):
            pre[i][0] = (0 if i == 0 else pre[i - 1][1]) + I(s[i], 1)
            pre[i][1] = (0 if i == 0 else pre[i - 1][0]) + I(s[i], 0)

        ans = min(pre[n - 1][0], pre[n - 1][1])
        if n % 2 == 1:
            # If n is an odd number, it is also necessary to calculate suf
            suf = [[0, 0] for _ in range(n)]
            # Note the boundary case when i = n - 1
            for i in range(n - 1, -1, -1):
                suf[i][0] = (0 if i == n - 1 else suf[i + 1][1]) + I(s[i], 1)
                suf[i][1] = (0 if i == n - 1 else suf[i + 1][0]) + I(s[i], 0)

            for i in range(n - 1):
                ans = min(ans, pre[i][0] + suf[i + 1][0])
                ans = min(ans, pre[i][1] + suf[i + 1][1])

        return ans

2026-03-06 19:47:33 +0300 MSK

Fri, 06 Mar 2026 19:47:33 +0300

Code

class Solution:
    def checkOnesSegment(self, s: str) -> bool:
        found_1, cur_1 = False, False
        for char in s:
            if char == "1":
                if found_1 and not cur_1:
                    return False
                elif not found_1:
                    found_1 = True
                    cur_1 = True
            elif cur_1:
                cur_1 = False
        return True

2026-03-05 21:05:59 +0300 MSK

Thu, 05 Mar 2026 21:05:59 +0300

Code

class Solution:
    def minOperations(self, s: str) -> int:
        if len(s) < 2:
            return 0
        prev1 = int(s[0])
        prev2 = prev1 ^ 1
        count1, count2 = 0, 1
        for char in s[1:]:
            cur = int(char)
            if cur == prev1:
                count1 += 1
                prev1 = cur ^ 1
            else:
                prev1 = cur
            if cur == prev2:
                count2 += 1
                prev2 = cur ^ 1
            else:
                prev2 = cur
        return min(count1, count2)

2026-03-04 20:10:10 +0300 MSK

Wed, 04 Mar 2026 20:10:10 +0300

Code

class Solution:
    def numSpecial(self, mat: List[List[int]]) -> int:
        m = len(mat)
        n = len(mat[0])
        row_count = [0] * m
        col_count = [0] * n
        ones = []
        for row in range(m):
            for col in range(n):
                if mat[row][col] == 1:
                    row_count[row] += 1
                    col_count[col] += 1
                    ones.append((row, col))
        res = 0
        while ones:
            row, col = ones.pop()
            if row_count[row] == 1 and col_count[col] == 1:
                res += 1
        return res

2026-03-03 20:16:05 +0300 MSK

Tue, 03 Mar 2026 20:16:05 +0300

Code

class Solution:
    def findKthBit(self, n: int, k: int) -> str:
        # Find the position of the rightmost set bit in k
        # This helps determine which "section" of the string we're in
        position_in_section = k & -k

        # Determine if k is in the inverted part of the string
        # This checks if the bit to the left of the rightmost set bit is 1
        is_in_inverted_part = ((k // position_in_section) >> 1 & 1) == 1

        # Determine if the original bit (before any inversion) would be 1
        # This is true if k is even (i.e., its least significant bit is 0)
        original_bit_is_one = (k & 1) == 0

        if is_in_inverted_part:
            # If we're in the inverted part, we need to flip the bit
            return "0" if original_bit_is_one else "1"
        else:
            # If we're not in the inverted part, return the original bit
            return "1" if original_bit_is_one else "0"

2026-03-03 09:50:42 +0300 MSK

Tue, 03 Mar 2026 09:50:42 +0300

Code

class Solution:
    def minSwaps(self, grid: List[List[int]]) -> int:
        n = len(grid)
        pos = [-1] * n
        for i in range(n):
            for j in range(n - 1, -1, -1):
                if grid[i][j] == 1:
                    pos[i] = j
                    break

        ans = 0
        for i in range(n):
            k = -1
            for j in range(i, n):
                if pos[j] <= i:
                    ans += j - i
                    k = j
                    break

            if k != -1:
                for j in range(k, i, -1):
                    pos[j], pos[j - 1] = pos[j - 1], pos[j]
            else:
                return -1

        return ans

2026-03-03 09:49:36 +0300 MSK

Tue, 03 Mar 2026 09:49:36 +0300

Code

class Solution:
    def minSwaps(self, grid: List[List[int]]) -> int:
        n = len(grid)
        pos = [-1] * n
        for i in range(n):
            for j in range(n - 1, -1, -1):
                if grid[i][j] == 1:
                    pos[i] = j
                    break

        ans = 0
        for i in range(n):
            k = -1
            for j in range(i, n):
                if pos[j] <= i:
                    ans += j - i
                    k = j
                    break

            if k != -1:
                for j in range(k, i, -1):
                    pos[j], pos[j - 1] = pos[j - 1], pos[j]
            else:
                return -1

        return ans

2026-03-03 09:49:19 +0300 MSK

Tue, 03 Mar 2026 09:49:19 +0300

Code

class Solution:
    def minSwaps(self, grid: List[List[int]]) -> int:
        n = len(grid)
        pos = [-1] * n
        for i in range(n):
            for j in range(n - 1, -1, -1):
                if grid[i][j] == 1:
                    pos[i] = j
                    break

        ans = 0
        for i in range(n):
            k = -1
            for j in range(i, n):
                if pos[j] <= i:
                    ans += j - i
                    k = j
                    break

            if k != -1:
                for j in range(k, i, -1):
                    pos[j], pos[j - 1] = pos[j - 1], pos[j]
            else:
                return -1

        return ans

2026-03-01 18:20:27 +0300 MSK

Sun, 01 Mar 2026 18:20:27 +0300

Code

class Solution:
    def minPartitions(self, n: str) -> int:
        return int(max(n))

2026-03-01 18:20:02 +0300 MSK

Sun, 01 Mar 2026 18:20:02 +0300

Code

class Solution:
    def minPartitions(self, n: str) -> int:
        res = 0
        for num in n:
            res = max(res, int(num))
        return res

2026-02-28 10:54:54 +0300 MSK

Sat, 28 Feb 2026 10:54:54 +0300

Code

class Solution:
    def concatenatedBinary(self, n: int) -> int:
        cur = 0
        mod = (10 ** 9) + 7
        for i in range(1, n + 1):
            cur_i = i
            while cur_i > 0:
                cur = (cur << 1)
                cur_i //= 2
            cur = (cur + i) % mod
        return cur

2026-02-27 21:53:34 +0300 MSK

Fri, 27 Feb 2026 21:53:34 +0300

Code

class Solution:
    def minOperations(self, s: str, k: int) -> int:
        n, m = len(s), s.count("0")
        dist = [math.inf] * (n + 1)
        nodeSets = [
            SortedList(range(0, n + 1, 2)),
            SortedList(range(1, n + 1, 2)),
        ]
        q = deque([m])
        dist[m] = 0
        nodeSets[m % 2].remove(m)
        while q:
            m = q.popleft()
            c1, c2 = max(k - n + m, 0), min(m, k)
            lnode, rnode = m + k - 2 * c2, m + k - 2 * c1
            nodeSet = nodeSets[lnode % 2]
            idx = nodeSet.bisect_left(lnode)
            while idx < len(nodeSet) and nodeSet[idx] <= rnode:
                m2 = nodeSet[idx]
                dist[m2] = dist[m] + 1
                q.append(m2)
                nodeSet.pop(idx)
        return -1 if dist[0] == math.inf else dist[0]

2026-02-26 20:44:53 +0300 MSK

Thu, 26 Feb 2026 20:44:53 +0300

Code

class Solution:
    def numSteps(self, s: str) -> int:
        N = len(s)

        operations = 0
        carry = 0
        for i in range(N - 1, 0, -1):
            digit = int(s[i]) + carry
            if digit % 2 == 1:
                operations += 2
                carry = 1
            else:
                operations += 1

        return operations + carry

2026-02-25 21:05:52 +0300 MSK

Wed, 25 Feb 2026 21:05:52 +0300

Code

class Solution:
    def sortByBits(self, arr: List[int]) -> List[int]:
        def find_weight(num):
            weight = 0
            
            while num:
                weight += 1
                num &= (num - 1)
            
            return weight
        
        arr.sort(key = lambda num: (find_weight(num), num))
        return arr

2026-02-24 19:51:26 +0300 MSK

Tue, 24 Feb 2026 19:51:26 +0300

Code

class Solution:
    def sumRootToLeaf(self, root: TreeNode) -> int:

        def dfs(node: TreeNode, n = 0)-> None:
            if not node: return

            n = 2 * n + node.val
            if not node.left and not node.right:
                self.ans+= n
                return
                
            dfs(node.left , n)
            dfs(node.right, n)
            return
            

        self.ans = 0
        dfs(root)
        return self.ans

2026-02-23 18:14:19 +0300 MSK

Mon, 23 Feb 2026 18:14:19 +0300

Code

class Solution:
    def hasAllCodes(self, s: str, k: int) -> bool:
        req = 1 << k
        seen = [False] * req
        mask = req - 1
        h = 0

        for i, ch in enumerate(s):
            h = ((h << 1) & mask) | (ord(ch) & 1)

            if i >= k - 1 and not seen[h]:
                seen[h] = True
                req -= 1
                if req == 0:
                    return True

        return False

2026-02-22 17:40:07 +0300 MSK

Sun, 22 Feb 2026 17:40:07 +0300

Code

class Solution(object):
    def binaryGap(self, N):
        last = None
        ans = 0
        for i in range(32):
            if (N >> i) & 1:
                if last is not None:
                    ans = max(ans, i - last)
                last = i
        return ans

2026-02-21 18:56:25 +0300 MSK

Sat, 21 Feb 2026 18:56:25 +0300

Code

class Solution(object):
    def countPrimeSetBits(self, L, R):
        primes = {2, 3, 5, 7, 11, 13, 17, 19}
        return sum(bin(x).count('1') in primes
                   for x in range(L, R+1))

2026-02-21 18:55:40 +0300 MSK

Sat, 21 Feb 2026 18:55:40 +0300

Code

class Solution:
    def makeLargestSpecial(self, s: str) -> str:
        count = 0
        i = 0
        res = []
        
        for j in range(len(s)):
            # Track balance: +1 for '1', -1 for '0'
            count += 1 if s[j] == '1' else -1
            
            # Found a balanced chunk when count returns to 0
            if count == 0:
                # Recursively maximize inner part, wrap with 1...0
                res.append('1' + self.makeLargestSpecial(s[i + 1:j]) + '0')
                i = j + 1  # Move to next potential chunk
        
        # Sort chunks in descending order for largest arrangement
        res.sort(reverse=True)
        return ''.join(res)

2026-02-19 20:42:48 +0300 MSK

Thu, 19 Feb 2026 20:42:48 +0300

Code

class Solution:
    def countBinarySubstrings(self, s):
        ans, prev, cur = 0, 0, 1
        for i in range(1, len(s)):
            if s[i-1] != s[i]:
                ans += min(prev, cur)
                prev, cur = cur, 1
            else:
                cur += 1

        return ans + min(prev, cur)

2026-02-18 20:35:40 +0300 MSK

Wed, 18 Feb 2026 20:35:40 +0300

Code

class Solution(object):
    def hasAlternatingBits(self, n):
        n, cur = divmod(n, 2)
        while n:
            if cur == n % 2: return False
            n, cur = divmod(n, 2)
        return True

2026-02-17 20:18:33 +0300 MSK

Tue, 17 Feb 2026 20:18:33 +0300

Code

class Solution:
    def readBinaryWatch(self, turnedOn: int) -> List[str]:
        ans = list()
        for h in range(12):
            for m in range(60):
                if bin(h).count("1") + bin(m).count("1") == turnedOn:
                    ans.append(f"{h}:{m:02d}")
        return ans

2026-02-16 19:40:12 +0300 MSK

Mon, 16 Feb 2026 19:40:12 +0300

Code

class Solution:
    def reverseBits(self, n: int) -> int:
        res = 0
        count = 32
        while n > 0 or count > 0:
            res = (res << 1) | (n & 1)
            n >>= 1
            count -= 1
        return res

2026-02-15 20:58:12 +0300 MSK

Sun, 15 Feb 2026 20:58:12 +0300

Code

class Solution:
    def addBinary(self, a, b) -> str:
        x, y = int(a, 2), int(b, 2)
        while y:
            x, y = x ^ y, (x & y) << 1
        return bin(x)[2:]

2026-02-14 12:54:19 +0300 MSK

Sat, 14 Feb 2026 12:54:19 +0300

Code

class Solution:
    def champagneTower(self, poured, query_row, query_glass):
        A = [[0] * k for k in range(1, 102)]
        A[0][0] = poured
        for r in range(query_row + 1):
            for c in range(r+1):
                q = (A[r][c] - 1.0) / 2.0
                if q > 0:
                    A[r+1][c] += q
                    A[r+1][c+1] += q

        return min(1, A[query_row][query_glass])

2026-02-13 09:19:20 +0300 MSK

Fri, 13 Feb 2026 09:19:20 +0300

Code

class Solution:
    def longestBalanced(self, s: str) -> int:
        n=len(s)
        # Deal with 1-letter balance
        ans, Len=1, 1
        for c0, c1 in pairwise(s):
            if c0==c1: Len+=1
            else:
                ans=max(ans, Len)
                Len=1
        ans=max(ans, Len)

        ab, bc, ca, abc={},{},{},{}
        abc[(0, 0)]=ab[(0, 0)]=bc[(0, 0)]=ca[(0, 0)]=-1

        cnt=[0, 0, 0]
        for i, c in enumerate(s):
            cnt[ord(c)-97]+=1
            A, B, C=cnt

            # 3-letter balance: A=B=C
            key=(B-A, C-A)
            if  key in abc: ans=max(ans, i-abc[key])
            else: abc[key]=i

            # 2-letter balance:
            key=(A-B, C)
            if  key in ab: ans=max(ans, i-ab[key])
            else: ab[key]=i

            key=(B-C, A)
            if  key in bc: ans=max(ans, i-bc[key])
            else: bc[key]=i

            key=(C-A, B)
            if  key in ca: ans=max(ans, i-ca[key])
            else: ca[key]=i
        return ans

2026-02-12 19:02:27 +0300 MSK

Thu, 12 Feb 2026 19:02:27 +0300

Code

class Solution:
    def longestBalanced(self, s: str) -> int:
        n = len(s)
        res = 0
        for i in range(n):
            cnt = defaultdict(int)
            for j in range(i, n):
                cnt[s[j]] += 1
                if len(set(cnt.values())) == 1:
                    res = max(res, j - i + 1)
        return res

2026-02-11 20:12:38 +0300 MSK

Wed, 11 Feb 2026 20:12:38 +0300

Code

class LazyTag:
    def __init__(self):
        self.to_add = 0

    def add(self, other):
        self.to_add += other.to_add
        return self

    def has_tag(self):
        return self.to_add != 0

    def clear(self):
        self.to_add = 0


class SegmentTreeNode:
    def __init__(self):
        self.min_value = 0
        self.max_value = 0
        self.lazy_tag = LazyTag()


class SegmentTree:
    def __init__(self, data):
        self.n = len(data)
        self.tree = [SegmentTreeNode() for _ in range(self.n * 4 + 1)]
        self._build(data, 1, self.n, 1)

    def add(self, l, r, val):
        tag = LazyTag()
        tag.to_add = val
        self._update(l, r, tag, 1, self.n, 1)

    def find_last(self, start, val):
        if start > self.n:
            return -1
        return self._find(start, self.n, val, 1, self.n, 1)

    def _apply_tag(self, i, tag):
        self.tree[i].min_value += tag.to_add
        self.tree[i].max_value += tag.to_add
        self.tree[i].lazy_tag.add(tag)

    def _pushdown(self, i):
        if self.tree[i].lazy_tag.has_tag():
            tag = LazyTag()
            tag.to_add = self.tree[i].lazy_tag.to_add
            self._apply_tag(i << 1, tag)
            self._apply_tag((i << 1) | 1, tag)
            self.tree[i].lazy_tag.clear()

    def _pushup(self, i):
        self.tree[i].min_value = min(
            self.tree[i << 1].min_value, self.tree[(i << 1) | 1].min_value
        )
        self.tree[i].max_value = max(
            self.tree[i << 1].max_value, self.tree[(i << 1) | 1].max_value
        )

    def _build(self, data, l, r, i):
        if l == r:
            self.tree[i].min_value = data[l - 1]
            self.tree[i].max_value = data[l - 1]
            return

        mid = l + ((r - l) >> 1)
        self._build(data, l, mid, i << 1)
        self._build(data, mid + 1, r, (i << 1) | 1)
        self._pushup(i)

    def _update(self, target_l, target_r, tag, l, r, i):
        if target_l <= l and r <= target_r:
            self._apply_tag(i, tag)
            return

        self._pushdown(i)
        mid = l + ((r - l) >> 1)
        if target_l <= mid:
            self._update(target_l, target_r, tag, l, mid, i << 1)
        if target_r > mid:
            self._update(target_l, target_r, tag, mid + 1, r, (i << 1) | 1)
        self._pushup(i)

    def _find(self, target_l, target_r, val, l, r, i):
        if self.tree[i].min_value > val or self.tree[i].max_value < val:
            return -1

        if l == r:
            return l

        self._pushdown(i)
        mid = l + ((r - l) >> 1)

        if target_r >= mid + 1:
            res = self._find(target_l, target_r, val, mid + 1, r, (i << 1) | 1)
            if res != -1:
                return res

        if l <= target_r and mid >= target_l:
            return self._find(target_l, target_r, val, l, mid, i << 1)

        return -1


class Solution:
    def longestBalanced(self, nums: List[int]) -> int:
        occurrences = defaultdict(deque)

        def sgn(x):
            return 1 if x % 2 == 0 else -1

        length = 0
        prefix_sum = [0] * len(nums)
        prefix_sum[0] = sgn(nums[0])
        occurrences[nums[0]].append(1)

        for i in range(1, len(nums)):
            prefix_sum[i] = prefix_sum[i - 1]
            occ = occurrences[nums[i]]
            if not occ:
                prefix_sum[i] += sgn(nums[i])
            occ.append(i + 1)

        seg = SegmentTree(prefix_sum)
        for i in range(len(nums)):
            length = max(length, seg.find_last(i + length, 0) - i)
            next_pos = len(nums) + 1
            occurrences[nums[i]].popleft()
            if occurrences[nums[i]]:
                next_pos = occurrences[nums[i]][0]

            seg.add(i + 1, next_pos - 1, -sgn(nums[i]))

        return length

2026-02-10 13:02:01 +0300 MSK

Tue, 10 Feb 2026 13:02:01 +0300

Code

import collections

class Solution:
    def longestBalanced(self, nums: List[int]) -> int:
        count_even, count_odd = 0, 0
        res = 0
        freqs = collections.defaultdict(int)
        for i in range(len(nums)):
            num_i = nums[i]
            for j in range(i, len(nums)):
                num = nums[j]
                freqs[num] += 1
                if freqs[num] == 1:
                    if num % 2 == 0:
                        count_even += 1
                    else:
                        count_odd += 1
                if count_even == count_odd:
                    res = max(res, j - i + 1)
            freqs.clear()
            count_even, count_odd = 0, 0
        return res

2026-02-09 20:09:17 +0300 MSK

Mon, 09 Feb 2026 20:09:17 +0300

Code

class Solution:
    def balanceBST(self, root: TreeNode) -> TreeNode:
        if not root:
            return None

        # Step 1: Create the backbone (vine)
        # Temporary dummy node
        vine_head = TreeNode(0)
        vine_head.right = root
        current = vine_head
        while current.right:
            if current.right.left:
                self.right_rotate(current, current.right)
            else:
                current = current.right

        # Step 2: Count the nodes
        node_count = 0
        current = vine_head.right
        while current:
            node_count += 1
            current = current.right

        # Step 3: Create a balanced BST
        m = 2 ** math.floor(math.log2(node_count + 1)) - 1
        self.make_rotations(vine_head, node_count - m)
        while m > 1:
            m //= 2
            self.make_rotations(vine_head, m)

        balanced_root = vine_head.right
        # Delete the temporary dummy node
        vine_head = None
        return balanced_root

    # Function to perform a right rotation
    def right_rotate(self, parent: TreeNode, node: TreeNode):
        tmp = node.left
        node.left = tmp.right
        tmp.right = node
        parent.right = tmp

    # Function to perform a left rotation
    def left_rotate(self, parent: TreeNode, node: TreeNode):
        tmp = node.right
        node.right = tmp.left
        tmp.left = node
        parent.right = tmp

    # Function to perform a series of left rotations to balance the vine
    def make_rotations(self, vine_head: TreeNode, count: int):
        current = vine_head
        for _ in range(count):
            tmp = current.right
            self.left_rotate(current, tmp)
            current = current.right

2026-02-08 13:23:59 +0300 MSK

Sun, 08 Feb 2026 13:23:59 +0300

Code

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def isBalanced(self, root: Optional[TreeNode]) -> bool:
        return self.dfs(root) != -1

    def dfs(self, node: Optional[TreeNode]) -> int:
        if node is None:
            return 0
        depth1, depth2 = self.dfs(node.left), self.dfs(node.right)
        if depth1 == -1 or depth2 == -1 or abs(depth2 - depth1) > 1:
            return -1
        return 1 + max(depth1, depth2)

2026-02-07 18:17:37 +0300 MSK

Sat, 07 Feb 2026 18:17:37 +0300

Code

class Solution:
    def minimumDeletions(self, s: str) -> int:
        left_a, right_a = 0, s.count("a")
        left_b, right_b = 0, len(s) - right_a
        res = min(right_a, right_b)
        for char in s:
            if char == "a":
                left_a += 1
                right_a -= 1
            else:
                left_b += 1
                right_b -= 1
            res = min(res, left_b + right_a)
        return res

2026-02-06 20:36:14 +0300 MSK

Fri, 06 Feb 2026 20:36:14 +0300

Code

class Solution:
    def minRemoval(self, nums: List[int], k: int) -> int:
        n = len(nums)
        nums.sort()

        ans = n
        right = 0
        for left in range(n):
            while right < n and nums[right] <= nums[left] * k:
                right += 1
            ans = min(ans, n - (right - left))

        return ans

2026-02-05 15:26:43 +0300 MSK

Thu, 05 Feb 2026 15:26:43 +0300

Code

class Solution:
    def constructTransformedArray(self, nums: List[int]) -> List[int]:
        res = [0] * len(nums)
        for i, num in enumerate(nums):
            res[i] = nums[(i + num) % len(nums)]
        return res

2026-02-04 18:39:04 +0300 MSK

Wed, 04 Feb 2026 18:39:04 +0300

Code

class Solution:
    def maxSumTrionic(self, nums: List[int]) -> int:
        n = len(nums)
        ans = float("-inf")
        i = 0

        while i < n:
            j = i + 1
            res = 0

            # first segment: increasing segment
            while j < n and nums[j - 1] < nums[j]:
                j += 1
            p = j - 1

            if p == i:  # 没有有效的increasing segment
                i += 1
                continue

            # second segment: decreasing segment
            res += nums[p] + nums[p - 1]
            while j < n and nums[j - 1] > nums[j]:
                res += nums[j]
                j += 1
            q = j - 1

            if q == p or q == n - 1 or (j < n and nums[j] <= nums[q]):
                i = q
                continue

            # third segment: increasing segment
            res += nums[q + 1]

            # find the maximum sum of the third segment
            max_sum = 0
            curr_sum = 0
            k = q + 2
            while k < n and nums[k] > nums[k - 1]:
                curr_sum += nums[k]
                max_sum = max(max_sum, curr_sum)
                k += 1
            res += max_sum

            # find the maximum sum of the first segment
            max_sum = 0
            curr_sum = 0
            for k in range(p - 2, i - 1, -1):
                curr_sum += nums[k]
                max_sum = max(max_sum, curr_sum)
            res += max_sum

            # update answer
            ans = max(ans, res)
            i = q

        return ans

2026-02-03 21:24:01 +0300 MSK

Tue, 03 Feb 2026 21:24:01 +0300

Code

class Solution:
    def isTrionic(self, nums: List[int]) -> bool:
        if nums[0] >= nums[1] or nums[-2] >= nums[-1] :
            return False
        seg = 1
        for i in range(2, len(nums)):
            cur, prev = nums[i], nums[i - 1]
            if cur == prev:
                return False
            if cur > prev:
                if seg == 2:
                    seg = 3
            else:
                if seg == 1:
                    seg = 2
                elif seg == 3:
                    return False
        return seg == 3

2026-02-03 14:14:39 +0300 MSK

Tue, 03 Feb 2026 14:14:39 +0300

Code

class Solution:
    def countMonobit(self, n: int) -> int:
        res = 0
        cur = 0
        while cur <= n:
            res += 1
            cur = (cur << 1) | 1
        return res

2026-02-03 14:11:12 +0300 MSK

Tue, 03 Feb 2026 14:11:12 +0300

Code

class Solution:
    def reverseByType(self, s: str) -> str:
        res = list(s)
        length = len(s)
        alpha, spec = length - 1, length - 1
        for i, char in enumerate(s):
            if char.isalpha():
                while not s[alpha].isalpha():
                    alpha -= 1
                target = alpha
                alpha -= 1
            else:
                while s[spec].isalpha():
                    spec -= 1
                target = spec
                spec -= 1
            res[i], res[target] = s[target], char
        return "".join(res)

2026-02-03 14:06:32 +0300 MSK

Tue, 03 Feb 2026 14:06:32 +0300

Code

class Solution:
    def reverseByType(self, s: str) -> str:
        alpha, spec, res = [], [], []
        for char in s:
            if char.isalpha():
                alpha.append(char)
            else:
                spec.append(char)
        for char in s:
            if char.isalpha():
                res.append(alpha.pop())
            else:
                res.append(spec.pop())
        return "".join(res)

2026-02-03 13:54:07 +0300 MSK

Tue, 03 Feb 2026 13:54:07 +0300

Code

class Solution:
    def vowelConsonantScore(self, s: str) -> int:
        length = len(s)
        vow = {"a", "e", "i", "o", "u"}
        vows = 0
        cons = 0
        for char in s:
            if char in vow:
                vows += 1
            elif char.isalpha():
                cons += 1
        if cons == 0:
            return 0
        return vows // cons

2026-02-03 12:24:12 +0300 MSK

Tue, 03 Feb 2026 12:24:12 +0300

Code

class Solution:
    def residuePrefixes(self, s: str) -> int:
        freqs = [0] * 26
        dist = 0
        res = 0
        for i in range(len(s)):
            target = (i + 1) % 3
            chr = ord(s[i]) - 97
            freqs[chr] += 1
            if freqs[chr] == 1:
                dist += 1
            if dist == target:
                res += 1
        return res

2026-02-02 18:52:16 +0300 MSK

Mon, 02 Feb 2026 18:52:16 +0300

Code

class Container:
    def __init__(self, k: int):
        self.k = k
        self.st1 = SortedList()
        self.st2 = SortedList()
        self.sm = 0

    def adjust(self):
        while len(self.st1) < self.k and len(self.st2) > 0:
            x = self.st2[0]
            self.st1.add(x)
            self.st2.remove(x)
            self.sm += x

        while len(self.st1) > self.k:
            x = self.st1[-1]
            self.st2.add(x)
            self.st1.remove(x)
            self.sm -= x

    # insert element x
    def add(self, x: int):
        if len(self.st2) > 0 and x >= self.st2[0]:
            self.st2.add(x)
        else:
            self.st1.add(x)
            self.sm += x
        self.adjust()

    # delete element x
    def erase(self, x: int):
        if x in self.st1:
            self.st1.remove(x)
            self.sm -= x
        elif x in self.st2:
            self.st2.remove(x)
        self.adjust()

    # sum of the first k smallest elements
    def sum(self) -> int:
        return self.sm


class Solution:
    def minimumCost(self, nums: List[int], k: int, dist: int) -> int:
        n = len(nums)
        cnt = Container(k - 2)
        for i in range(1, k - 1):
            cnt.add(nums[i])

        ans = cnt.sum() + nums[k - 1]
        for i in range(k, n):
            j = i - dist - 1
            if j > 0:
                cnt.erase(nums[j])
            cnt.add(nums[i - 1])
            ans = min(ans, cnt.sum() + nums[i])

        return ans + nums[0]

2026-02-01 19:46:21 +0300 MSK

Sun, 01 Feb 2026 19:46:21 +0300

Code

class Solution:
    def minimumCost(self, nums: List[int]) -> int:
        num1, num2 = float("inf"), float("inf")
        heap = []
        for i in range(1, len(nums)):
            heapq.heappush(heap, nums[i])
        return nums[0] + heapq.heappop(heap) + heapq.heappop(heap)

2026-02-01 19:45:22 +0300 MSK

Sun, 01 Feb 2026 19:45:22 +0300

Code

class Solution:
    def minimumCost(self, nums: List[int]) -> int:
        num1, num2 = float("inf"), float("inf")
        for i in range(1, len(nums)):
            num = nums[i]
            if num <= num1:
                num1, num2 = num, min(num1, num2)
            elif num <= num2:
                num1, num2 = min(num1, num2), num
        return nums[0] + num1 + num2

2026-01-31 21:17:17 +0300 MSK

Sat, 31 Jan 2026 21:17:17 +0300

Code

class Solution:
    def nextGreatestLetter(self, letters: List[str], target: str) -> str:
        for ch in letters:
            if ch > target:
                return ch
        return letters[0]

2026-01-30 20:30:09 +0300 MSK

Fri, 30 Jan 2026 20:30:09 +0300

Code

INF = 10**18
INF_INT = 10**9


class Solution:
    def minimumCost(
        self,
        source: str,
        target: str,
        original: List[str],
        changed: List[str],
        cost: List[int],
    ) -> int:
        n = len(source)
        m = len(original)

        child = [[-1] * 26]
        tid = [-1]

        def new_node() -> int:
            child.append([-1] * 26)
            tid.append(-1)
            return len(child) - 1

        idx = -1

        def add(word: str) -> int:
            nonlocal idx
            node = 0
            for ch in word:
                c = ord(ch) - 97
                nxt = child[node][c]
                if nxt == -1:
                    nxt = new_node()
                    child[node][c] = nxt
                node = nxt
            if tid[node] == -1:
                idx += 1
                tid[node] = idx
            return tid[node]

        edges = []
        for i in range(m):
            x = add(original[i])
            y = add(changed[i])
            edges.append((x, y, cost[i]))

        P = idx + 1
        if P == 0:
            return 0 if source == target else -1

        dist = [[INF_INT] * P for _ in range(P)]
        for i in range(P):
            dist[i][i] = 0
        for x, y, w in edges:
            if w < dist[x][y]:
                dist[x][y] = w

        for k in range(P):
            dk = dist[k]
            for i in range(P):
                di = dist[i]
                dik = di[k]
                if dik == INF_INT:
                    continue
                base = dik
                for j in range(P):
                    nd = base + dk[j]
                    if nd < di[j]:
                        di[j] = nd

        dp = [INF] * (n + 1)
        dp[0] = 0

        s_arr = [ord(c) - 97 for c in source]
        t_arr = [ord(c) - 97 for c in target]

        for j in range(n):
            if dp[j] >= INF:
                continue

            base = dp[j]

            if source[j] == target[j] and base < dp[j + 1]:
                dp[j + 1] = base

            u = 0
            v = 0
            for i in range(j, n):
                u = child[u][s_arr[i]]
                v = child[v][t_arr[i]]
                if u == -1 or v == -1:
                    break
                uid = tid[u]
                vid = tid[v]
                if uid != -1 and vid != -1:
                    w = dist[uid][vid]
                    if w != INF_INT:
                        ni = i + 1
                        cand = base + w
                        if cand < dp[ni]:
                            dp[ni] = cand

        ans = dp[n]
        return -1 if ans >= INF else ans

2026-01-29 22:21:59 +0300 MSK

Thu, 29 Jan 2026 22:21:59 +0300

Code

class Solution:
    def minimumCost(
        self,
        source: str,
        target: str,
        original: List[str],
        changed: List[str],
        cost: List[int],
    ) -> int:
        # Initialize result to store the total minimum cost
        total_cost = 0

        # Initialize a 2D list to store the minimum transformation cost
        # between any two characters
        min_cost = [[float("inf")] * 26 for _ in range(26)]

        # Fill the initial transformation costs from the given original,
        # changed, and cost arrays
        for orig, chg, cst in zip(original, changed, cost):
            start_char = ord(orig) - ord("a")
            end_char = ord(chg) - ord("a")
            min_cost[start_char][end_char] = min(
                min_cost[start_char][end_char], cst
            )

        # Use Floyd-Warshall algorithm to find the shortest path between any
        # two characters
        for k in range(26):
            for i in range(26):
                for j in range(26):
                    min_cost[i][j] = min(
                        min_cost[i][j], min_cost[i][k] + min_cost[k][j]
                    )

        # Calculate the total minimum cost to transform the source string to
        # the target string
        for src, tgt in zip(source, target):
            if src == tgt:
                continue
            source_char = ord(src) - ord("a")
            target_char = ord(tgt) - ord("a")

            # If the transformation is not possible, return -1
            if min_cost[source_char][target_char] == float("inf"):
                return -1
            total_cost += min_cost[source_char][target_char]

        return total_cost

2026-01-28 20:51:42 +0300 MSK

Wed, 28 Jan 2026 20:51:42 +0300

Code

class Solution:
    def minCost(self, grid: list[list[int]], k: int) -> int:
        m, n = len(grid), len(grid[0])
        points = [(i, j) for i in range(m) for j in range(n)]
        points.sort(key=lambda p: grid[p[0]][p[1]])
        costs = [[float("inf")] * n for _ in range(m)]
        for t in range(k + 1):
            minCost = float("inf")
            j = 0
            for i in range(len(points)):
                minCost = min(minCost, costs[points[i][0]][points[i][1]])
                if (
                    i + 1 < len(points)
                    and grid[points[i][0]][points[i][1]]
                    == grid[points[i + 1][0]][points[i + 1][1]]
                ):
                    i += 1
                    continue
                for r in range(j, i + 1):
                    costs[points[r][0]][points[r][1]] = minCost
                j = i + 1
            for i in range(m - 1, -1, -1):
                for j in range(n - 1, -1, -1):
                    if i == m - 1 and j == n - 1:
                        costs[i][j] = 0
                        continue
                    if i != m - 1:
                        costs[i][j] = min(
                            costs[i][j], costs[i + 1][j] + grid[i + 1][j]
                        )
                    if j != n - 1:
                        costs[i][j] = min(
                            costs[i][j], costs[i][j + 1] + grid[i][j + 1]
                        )
        return costs[0][0]

2026-01-27 22:11:38 +0300 MSK

Tue, 27 Jan 2026 22:11:38 +0300

Code

class Solution:
    def dijkstra(self, n: int) -> int:
        INF  = 10**9
        vis  = [False] * n
        dist = [INF] * n

        pq: List[Tuple[int, int]] = [(0, 0)]
        dist[0] = 0

        while pq:
            du, u = heapq.heappop(pq)
            if vis[u]:
                continue
            vis[u] = True

            for v, w in self.G[u]:
                nd = du + w
                if nd < dist[v]:
                    dist[v] = nd
                    heapq.heappush(pq, (nd, v))

        return -1 if dist[n - 1] == INF else dist[n - 1]

    def minCost(self, n: int, edges: List[List[int]]) -> int:
        self.G = [[] for _ in range(n)]

        for u, v, w in edges:
            self.G[u].append((v, w))
            self.G[v].append((u, 2 * w))

        return self.dijkstra(n)

2026-01-26 20:02:52 +0300 MSK

Mon, 26 Jan 2026 20:02:52 +0300

Code

class Solution:
    def minimumAbsDifference(self, arr: List[int]) -> List[List[int]]:
        arr.sort()
        res = []
        min_diff = float("inf")
        for i in range(len(arr) - 1):
            cur, nxt = arr[i], arr[i + 1]
            diff = nxt - cur
            if diff < min_diff:
                min_diff = diff
                res.clear()
            if diff == min_diff:
                res.append((cur, nxt))
        return res

2026-01-25 21:10:14 +0300 MSK

Sun, 25 Jan 2026 21:10:14 +0300

Code

class Solution:
    def minimumDifference(self, nums: List[int], k: int) -> int:
        nums.sort()
        return min(nums[i + k - 1] - nums[i] for i in range(len(nums) - k + 1))

2026-01-24 19:43:56 +0300 MSK

Sat, 24 Jan 2026 19:43:56 +0300

Code

class Solution:
    def minPairSum(self, nums: List[int]) -> int:
        nums.sort()
        res = float("-inf")
        for i in range((len(nums) // 2) + 1):
            res = max(res, nums[i] + nums[-i - 1])
        return res

2026-01-23 20:09:20 +0300 MSK

Fri, 23 Jan 2026 20:09:20 +0300

Code

class Node:
    def __init__(self, value, left):
        self.value = value
        self.left = left
        self.prev = None
        self.next = None


class Solution:
    def minimumPairRemoval(self, nums: List[int]) -> int:
        class PQItem:
            def __init__(self, first, second, cost):
                self.first = first
                self.second = second
                self.cost = cost

            def __lt__(self, other):
                if self.cost == other.cost:
                    return self.first.left < other.first.left
                return self.cost < other.cost

        pq = []
        head = Node(nums[0], 0)
        current = head
        merged = [False] * len(nums)
        decrease_count = 0
        count = 0

        for i in range(1, len(nums)):
            new_node = Node(nums[i], i)
            current.next = new_node
            new_node.prev = current
            heapq.heappush(
                pq, PQItem(current, new_node, current.value + new_node.value)
            )

            if nums[i - 1] > nums[i]:
                decrease_count += 1

            current = new_node

        while decrease_count > 0:
            item = heapq.heappop(pq)
            first, second, cost = item.first, item.second, item.cost

            if (
                merged[first.left]
                or merged[second.left]
                or first.value + second.value != cost
            ):
                continue
            count += 1

            if first.value > second.value:
                decrease_count -= 1

            prev_node = first.prev
            next_node = second.next
            first.next = next_node
            if next_node:
                next_node.prev = first

            if prev_node:
                if prev_node.value > first.value and prev_node.value <= cost:
                    decrease_count -= 1
                elif prev_node.value <= first.value and prev_node.value > cost:
                    decrease_count += 1

                heapq.heappush(
                    pq, PQItem(prev_node, first, prev_node.value + cost)
                )

            if next_node:
                if second.value > next_node.value and cost <= next_node.value:
                    decrease_count -= 1
                elif second.value <= next_node.value and cost > next_node.value:
                    decrease_count += 1
                heapq.heappush(
                    pq, PQItem(first, next_node, cost + next_node.value)
                )

            first.value = cost
            merged[second.left] = True

        return count

2026-01-22 19:21:03 +0300 MSK

Thu, 22 Jan 2026 19:21:03 +0300

Code

class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        length = len(nums)
        if length < 2:
            return length - nums.count(val)
        left, right = 0, length - 1
        res = 0
        while left <= right:
            if nums[left] != val:
                res += 1
                left += 1
                continue
            if left == right:
                break
            while right > left:
                if nums[right] == val:
                    right -= 1
                else:
                    nums[left] = nums[right]
                    right -= 1
                    left += 1
                    res += 1
                    break
            
        return res

2026-01-22 18:45:34 +0300 MSK

Thu, 22 Jan 2026 18:45:34 +0300

Code

class Solution:
    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
        """
        Do not return anything, modify nums1 in-place instead.
        """
        target, idx1, idx2 = m + n - 1, m - 1, n - 1
        neg_inf = float("-inf")
        while target >= 0:
            if idx1 >= 0:
                num1 = nums1[idx1]
            else:
                num1 = neg_inf
            if idx2 >= 0:
                num2 = nums2[idx2]
            else:
                num2 = neg_inf
            if num1 >= num2:
                nums1[target] = num1
                idx1 -= 1
                target -= 1
            else:
                nums1[target] = num2
                idx2 -= 1
                target -= 1

2026-01-22 18:41:51 +0300 MSK

Thu, 22 Jan 2026 18:41:51 +0300

Code

class Solution:
    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
        """
        Do not return anything, modify nums1 in-place instead.
        """
        if not nums2:
            return nums1
        for i in reversed(range(m)):
            nums1[i + n] = nums1[i]
        target, idx1, idx2 = 0, 0, 0
        inf = float("inf")
        while target < m + n:
            if idx1 < m:
                num1 = nums1[idx1 + n]
            else:
                num1 = inf
            if idx2 < n:
                num2 = nums2[idx2]
            else:
                num2 = inf
            if num1 < num2:
                nums1[target] = num1
                target += 1
                idx1 += 1
            else:
                nums1[target] = num2
                target += 1
                idx2 += 1

2026-01-22 18:07:41 +0300 MSK

Thu, 22 Jan 2026 18:07:41 +0300

Code

class Solution:
    def minimumPairRemoval(self, nums: List[int]) -> int:
        count = 0

        while len(nums) > 1:
            isAscending = True
            minSum = float("inf")
            targetIndex = -1

            for i in range(len(nums) - 1):
                pair_sum = nums[i] + nums[i + 1]

                if nums[i] > nums[i + 1]:
                    isAscending = False

                if pair_sum < minSum:
                    minSum = pair_sum
                    targetIndex = i

            if isAscending:
                break

            count += 1
            nums[targetIndex] = minSum
            nums.pop(targetIndex + 1)

        return count

2026-01-22 10:20:58 +0300 MSK

Thu, 22 Jan 2026 10:20:58 +0300

Code

class Solution:
    def minBitwiseArray(self, nums: List[int]) -> List[int]:
        for i in range(len(nums)):
            res = -1
            d = 1
            while (nums[i] & d) != 0:
                res = nums[i] - d
                d <<= 1
            nums[i] = res
        return nums

2026-01-20 11:39:04 +0300 MSK

Tue, 20 Jan 2026 11:39:04 +0300

Code

class Solution:
    def minBitwiseArray(self, nums: List[int]) -> List[int]:
        for i in range(len(nums)):
            res = -1
            d = 1
            while (nums[i] & d) != 0:
                res = nums[i] - d
                d <<= 1
            nums[i] = res
        return nums

2026-01-19 12:02:06 +0300 MSK

Mon, 19 Jan 2026 12:02:06 +0300

Code

class Solution:
    def maxSideLength(self, mat: List[List[int]], threshold: int) -> int:
        m, n = len(mat), len(mat[0])
        P = [[0] * (n + 1) for _ in range(m + 1)]
        for i in range(1, m + 1):
            for j in range(1, n + 1):
                P[i][j] = (
                    P[i - 1][j]
                    + P[i][j - 1]
                    - P[i - 1][j - 1]
                    + mat[i - 1][j - 1]
                )

        def getRect(x1, y1, x2, y2):
            return P[x2][y2] - P[x1 - 1][y2] - P[x2][y1 - 1] + P[x1 - 1][y1 - 1]

        r, ans = min(m, n), 0
        for i in range(1, m + 1):
            for j in range(1, n + 1):
                for c in range(ans + 1, r + 1):
                    if (
                        i + c - 1 <= m
                        and j + c - 1 <= n
                        and getRect(i, j, i + c - 1, j + c - 1) <= threshold
                    ):
                        ans += 1
                    else:
                        break
        return ans

2026-01-18 17:30:31 +0300 MSK

Sun, 18 Jan 2026 17:30:31 +0300

Code

class Solution:
    def largestMagicSquare(self, grid: List[List[int]]) -> int:
        m, n = len(grid), len(grid[0])

        rowsum = [[0] * n for _ in range(m)]
        for i in range(m):
            rowsum[i][0] = grid[i][0]
            for j in range(1, n):
                rowsum[i][j] = rowsum[i][j - 1] + grid[i][j]

        colsum = [[0] * n for _ in range(m)]
        for j in range(n):
            colsum[0][j] = grid[0][j]
            for i in range(1, m):
                colsum[i][j] = colsum[i - 1][j] + grid[i][j]

        for edge in range(min(m, n), 1, -1):
            for i in range(m - edge + 1):
                for j in range(n - edge + 1):
                    stdsum = rowsum[i][j + edge - 1] - (
                        0 if j == 0 else rowsum[i][j - 1]
                    )
                    check = True
                    
                    for ii in range(i + 1, i + edge):
                        if (
                            rowsum[ii][j + edge - 1]
                            - (0 if j == 0 else rowsum[ii][j - 1])
                            != stdsum
                        ):
                            check = False
                            break
                    if not check:
                        continue
                    
                    for jj in range(j, j + edge):
                        if (
                            colsum[i + edge - 1][jj]
                            - (0 if i == 0 else colsum[i - 1][jj])
                            != stdsum
                        ):
                            check = False
                            break
                    if not check:
                        continue

                    d1 = d2 = 0
                    for k in range(edge):
                        d1 += grid[i + k][j + k]
                        d2 += grid[i + k][j + edge - 1 - k]
                    if d1 == stdsum and d2 == stdsum:
                        return edge

        return 1

2026-01-18 16:48:45 +0300 MSK

Sun, 18 Jan 2026 16:48:45 +0300

Code

class Solution:
    def largestSquareArea(
        self, bottomLeft: List[List[int]], topRight: List[List[int]]
    ) -> int:
        max_size = 0
        for (bottom_left_i, top_right_i), (
            bottom_left_j,
            top_right_j,
        ) in combinations(zip(bottomLeft, topRight), 2):
            w = min(top_right_i[0], top_right_j[0]) - max(
                bottom_left_i[0], bottom_left_j[0]
            )
            h = min(top_right_i[1], top_right_j[1]) - max(
                bottom_left_i[1], bottom_left_j[1]
            )

            max_size = max(max_size, min(w, h))

        return max_size * max_size

2026-01-16 19:37:40 +0300 MSK

Fri, 16 Jan 2026 19:37:40 +0300

Code

class Solution:
    def get_edges(self, fences: List[int], border: int) -> set:
        points = sorted([1] + fences + [border])
        return {
            points[j] - points[i]
            for i in range(len(points))
            for j in range(i + 1, len(points))
        }

    def maximizeSquareArea(
        self, m: int, n: int, hFences: List[int], vFences: List[int]
    ) -> int:
        MOD = 10**9 + 7
        h_edges = self.get_edges(hFences, m)
        v_edges = self.get_edges(vFences, n)

        max_edge = max(h_edges & v_edges, default=0)
        return (max_edge * max_edge) % MOD if max_edge else -1

2026-01-15 17:40:29 +0300 MSK

Thu, 15 Jan 2026 17:40:29 +0300

Code

class Solution:
    def maximizeSquareHoleArea(
        self, n: int, m: int, hBars: List[int], vBars: List[int]
    ) -> int:
        hBars.sort()
        vBars.sort()
        hmax, vmax = 1, 1
        hcur, vcur = 1, 1
        for i in range(1, len(hBars)):
            if hBars[i] == hBars[i - 1] + 1:
                hcur += 1
            else:
                hcur = 1
            hmax = max(hmax, hcur)
        for i in range(1, len(vBars)):
            if vBars[i] == vBars[i - 1] + 1:
                vcur += 1
            else:
                vcur = 1
            vmax = max(vmax, vcur)
        side = min(hmax, vmax) + 1
        return side * side

2026-01-14 22:52:51 +0300 MSK

Wed, 14 Jan 2026 22:52:51 +0300

Code

from typing import List
import bisect


class SegmentTree:
    def __init__(self, xs: List[int]):
        self.xs = xs
        self.n = len(xs) - 1
        self.count = [0] * (4 * self.n)
        self.covered = [0] * (4 * self.n)

    def update(self, qleft, qright, qval, left, right, pos):
        if self.xs[right + 1] <= qleft or self.xs[left] >= qright:
            return
        if qleft <= self.xs[left] and self.xs[right + 1] <= qright:
            self.count[pos] += qval
        else:
            mid = (left + right) // 2
            self.update(qleft, qright, qval, left, mid, pos * 2 + 1)
            self.update(qleft, qright, qval, mid + 1, right, pos * 2 + 2)

        if self.count[pos] > 0:
            self.covered[pos] = self.xs[right + 1] - self.xs[left]
        else:
            if left == right:
                self.covered[pos] = 0
            else:
                self.covered[pos] = (
                    self.covered[pos * 2 + 1] + self.covered[pos * 2 + 2]
                )

    def query(self):
        return self.covered[0]


class Solution:
    def separateSquares(self, squares: List[List[int]]) -> float:
        events = []
        xs_set = set()
        for x, y, l in squares:
            events.append((y, 1, x, x + l))
            events.append((y + l, -1, x, x + l))
            xs_set.update([x, x + l])
        xs = sorted(xs_set)

        seg_tree = SegmentTree(xs)
        events.sort()

        psum = []
        widths = []
        total_area = 0.0
        prev_y = events[0][0]

        # scan: calculate total area and record intermediate states
        for y, delta, xl, xr in events:
            length = seg_tree.query()
            total_area += length * (y - prev_y)
            seg_tree.update(xl, xr, delta, 0, seg_tree.n - 1, 0)
            # record prefix sums and widths
            psum.append(total_area)
            widths.append(seg_tree.query())
            prev_y = y

        # calculate the target area (half rounded up)
        target = (total_area + 1) // 2
        # find the first position greater than or equal to target using binary search
        i = bisect.bisect_left(psum, target) - 1
        # get the corresponding area, width, and height
        area = psum[i]
        width = widths[i]
        height = events[i][0]

        return height + (total_area - area * 2) / (width * 2.0)

2026-01-13 19:03:15 +0300 MSK

Tue, 13 Jan 2026 19:03:15 +0300

Code

class Solution:
    def separateSquares(self, squares: List[List[int]]) -> float:
        total_area = 0
        events = []

        for sq in squares:
            y, l = sq[1], sq[2]
            total_area += l * l
            events.append((y, l, 1))
            events.append((y + l, l, -1))

        # sort by y-coordinate
        events.sort(key=lambda x: x[0])

        covered_width = (
            0.0  # sum of all bottom edges under the current scanning line
        )
        curr_area = 0.0  # current cumulative area
        prev_height = 0.0  # height of the previous scanning line

        for y, l, delta in events:
            diff = y - prev_height
            # additional area between two scanning lines
            area = covered_width * diff
            # if this part of the area exceeds more than half of the total area
            if 2 * (curr_area + area) >= total_area:
                return prev_height + (total_area - 2 * curr_area) / (
                    2 * covered_width
                )
            # update width: add width at the start event, subtract width at the end event
            covered_width += delta * l
            curr_area += area
            prev_height = y

        return 0.0

2026-01-12 10:11:59 +0300 MSK

Mon, 12 Jan 2026 10:11:59 +0300

Code

class Solution:
    def minTimeToVisitAllPoints(self, points: List[List[int]]) -> int:
        pos_x, pos_y = points[0]
        res = 0
        for x, y in points[1:]:
            diff_x, diff_y = abs(pos_x - x), abs(pos_y - y)
            diff_min, diff_max = min(diff_x, diff_y), max(diff_x, diff_y)
            res += diff_min + (diff_max - diff_min)
            pos_x, pos_y = x, y
        return res

2026-01-11 13:52:04 +0300 MSK

Sun, 11 Jan 2026 13:52:04 +0300

Code

class Solution:
    def maximalRectangle(self, matrix: List[List[str]]) -> int:
        m, n = len(matrix), len(matrix[0])
        dp = [[0] * (n + 1)  for _ in range(m + 1)]
        max_area = 0

        for i in range(m):
            for j in range(n):
                if matrix[i][j] == "0":
                    continue
                dp_i, dp_j = i + 1, j + 1
                width = dp[dp_i][dp_j - 1] + 1
                dp[dp_i][dp_j] = width
                max_area = max(max_area, width)
                for cur_dp_i in reversed(range(1, dp_i)):
                    height = dp_i - cur_dp_i + 1
                    width = min(width, dp[cur_dp_i][dp_j])
                    if width == 0:
                        break
                    max_area = max(max_area, height * width)
        
        return max_area

2026-01-11 08:25:47 +0300 MSK

Sun, 11 Jan 2026 08:25:47 +0300

Code

class Solution:
    def shortestPalindrome(self, s: str) -> str:
        length = len(s)
        reversed_string = s[::-1]  # Reverse the string
        for i in range(length):
            if s[: length - i] == reversed_string[i:]:
                return reversed_string[:i] + s
        return ""

2026-01-10 14:26:29 +0300 MSK

Sat, 10 Jan 2026 14:26:29 +0300

Code

class Solution:
    def shortestPalindrome(self, s: str) -> str:
        reversed_string = s[::-1]
        combined_string = "#".join((s, reversed_string))
        prefix_table = self._kmp_table(combined_string)
        palindrome_length = prefix_table[-1]
        suffix = reversed_string[: len(s) - palindrome_length]
        return suffix + s

    def _kmp_table(self, s: str) -> list[int]:
        prefix_table = [0] * len(s)
        length = 0
        for i in range(1, len(s)):
            while length > 0 and s[i] != s[length]:
                length = prefix_table[length - 1]
            if s[i] == s[length]:
                length += 1
            prefix_table[i] = length
        return prefix_table

2026-01-10 14:23:41 +0300 MSK

Sat, 10 Jan 2026 14:23:41 +0300

Code

class Solution:
    def shortestPalindrome(self, s: str) -> str:
        length = len(s)
        if length == 0:
            return s
        left = 0
        for right in range(length - 1, -1, -1):
            if s[right] == s[left]:
                left += 1
        if left == length:
            return s
        non_palindrome_suffix = s[left:]
        reverse_suffix = non_palindrome_suffix[::-1]
        return (
            reverse_suffix
            + self.shortestPalindrome(s[:left])
            + non_palindrome_suffix
        )

2026-01-10 14:04:15 +0300 MSK

Sat, 10 Jan 2026 14:04:15 +0300

Code

class Solution:
    def shortestPalindrome(self, s: str) -> str:
        length = len(s)
        if length < 2:
            return s
        left = 0
        for right in reversed(range(length)):
            if s[left] == s[right]:
                left += 1
        if left == length:
            return s
        non_palindrome_suffix = s[left:]
        reverse_suffix = non_palindrome_suffix[::-1]
        return (
            reverse_suffix
            + self.shortestPalindrome(s[:left])
            + non_palindrome_suffix
        )

2026-01-10 12:50:38 +0300 MSK

Sat, 10 Jan 2026 12:50:38 +0300

Code

class Solution:
    def minimumDeleteSum(self, s1: str, s2: str) -> int:
        length1, length2 = len(s1), len(s2)
        dp = [[-1] * (length2 + 1) for _ in range(length1 + 1)]
        inf = float("inf")

        def dfs(i: int, j: int) -> int:
            if dp[i][j] != -1:
                return dp[i][j]
            elif i == length1:
                res = sum(ord(char) for char in s2[j:])
            elif j == length2:
                res = sum(ord(char) for char in s1[i:])
            else:
                char1, char2 = ord(s1[i]), ord(s2[j]) 
                res = min(char1 + dfs(i + 1, j), char2 + dfs(i, j + 1))
                if char1 == char2:
                    res = min(res, dfs(i + 1, j + 1))
            dp[i][j] = res
            return res
    
        return dfs(0, 0)

2026-01-10 12:34:56 +0300 MSK

Sat, 10 Jan 2026 12:34:56 +0300

Code

class Solution:
    def largestEven(self, s: str) -> str:
        last = len(s) - 1
        while last >= 0 and s[last] == "1":
            last -= 1
        return s[:last + 1]

2026-01-10 12:32:09 +0300 MSK

Sat, 10 Jan 2026 12:32:09 +0300

Code

class Solution:
    def reversePrefix(self, s: str, k: int) -> str:
        return s[k - 1::-1] + s[k:]

2026-01-10 12:31:07 +0300 MSK

Sat, 10 Jan 2026 12:31:07 +0300

Code

class Solution:
    def reversePrefix(self, s: str, k: int) -> str:
        return s[:k][::-1] + s[k:]

2026-01-10 12:28:57 +0300 MSK

Sat, 10 Jan 2026 12:28:57 +0300

Code

SELECT 
    user_id, 
    COUNT(prompt) AS "prompt_count", 
    ROUND(AVG(tokens),2) AS "avg_tokens"
FROM 
    prompts
GROUP BY 
    user_id
HAVING 
    COUNT(prompt) > 2 
    AND MAX(tokens) > AVG(tokens)
ORDER BY 
    avg_tokens DESC, 
    user_id;

2026-01-09 15:34:38 +0300 MSK

Fri, 09 Jan 2026 15:34:38 +0300

Code

def solve(i: int, j: int, dungeon: list[list[int]], dp: list[list[int]]) -> int:
    m, n = len(dungeon), len(dungeon[0])
    if i == m - 1 and j == n - 1:
        return max(1, 1 - dungeon[i][j])
    if i >= m or j >= n:
        return float("inf")
    if dp[i][j] != -1:
        return dp[i][j]
    right = solve(i, j + 1, dungeon, dp)
    down = solve(i + 1, j, dungeon, dp)
    min_health = min(right, down) - dungeon[i][j]
    dp[i][j] = max(1, min_health)
    return dp[i][j]

class Solution:

    def calculateMinimumHP(self, dungeon):
        m, n = len(dungeon), len(dungeon[0])
        dp = [[-1] * n for _ in range(m)]
        return solve(0, 0, dungeon, dp)

2026-01-09 13:31:31 +0300 MSK

Fri, 09 Jan 2026 13:31:31 +0300

Code

import functools

class Solution:
    def findMin(self, nums: List[int]) -> int:
        length = len(nums)
        if length < 3:
            return min(nums)
        inf = float("inf")

        @functools.cache
        def check(i: int) -> int:
            if i == 0:
                prev, nxt = length - 1, 1
            elif i == length - 1:
                prev, nxt = length - 2, 0
            else:
                prev, nxt = i - 1, i + 1
            num_prev, num_cur, num_nxt = nums[prev], nums[i], nums[nxt]
            if num_cur < num_prev:
                return num_cur
            if num_nxt < num_cur:
                return num_nxt
            return -1

        @functools.cache
        def dp(left: int, right: int) -> int:
            if left < 0 or right == length or left > right:
                return  inf
            mid = left + (right - left) // 2
            num_left, num_mid, num_right = nums[left], nums[mid], nums[right]
            for idx in (left, mid, right):
                check_res = check(idx)
                if check_res != -1:
                    return check_res
            if num_left == num_mid == num_right:
                return min(num_left, dp(left + 1, mid - 1), dp(mid + 1, right - 1))
            if num_mid < num_left:
                return dp(left + 1, mid - 1)
            return dp(mid + 1, right - 1)
        
        return dp(0, length - 1)

2026-01-09 11:15:58 +0300 MSK

Fri, 09 Jan 2026 11:15:58 +0300

Code

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def subtreeWithAllDeepest(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        if root is None:
            return None
        neg_inf = float("-inf")

        def dfs(node: TreeNode, depth: int) -> tuple[TreeNode, int]:
            if node.left is None and node.right is None:
                return node, depth
            if node.left is None:
                return dfs(node.right, depth + 1)
            if node.right is None:
                return dfs(node.left, depth + 1)
            left_node, left_depth = dfs(node.left, depth + 1)
            right_node, right_depth = dfs(node.right, depth + 1)
            if left_depth == right_depth:
                return node, left_depth
            if left_depth > right_depth:
                return left_node, left_depth
            return right_node, right_depth
        
        return dfs(root, 0)[0]

2026-01-08 22:11:32 +0300 MSK

Thu, 08 Jan 2026 22:11:32 +0300

Code

class Solution:
    def minCut(self, s: str) -> int:
        n = len(s)
        cuts = [i for i in range(n)] 

        for center in range(n):
            for left, right in ((center, center), (center, center + 1)):
                while left >= 0 and right < n and s[left] == s[right]:
                    if left == 0:
                        cuts[right] = 0 
                    else:
                        cuts[right] = min(cuts[right], cuts[left - 1] + 1)
                    left -= 1
                    right += 1

        return cuts[-1]

2026-01-08 19:05:53 +0300 MSK

Thu, 08 Jan 2026 19:05:53 +0300

Code

class Solution:
    def findLadders(self, beginWord: str, endWord: str, wordList: List[str]) -> int:
        words, mp, ans = set(wordList), defaultdict(list), []
        
        def bfs(words: set[str]) -> None:
            letters = [chr(97 + x) for x in range(26)]
            ws, q, next_lev = len(beginWord), deque([beginWord]), set()
            while q:
                size = len(q)
                for _ in range(size):
                    w = q.popleft()
                    for i in range(ws):
                        pre, suf = w[:i], w[i+1:]
                        for l in letters:
                            nw = pre + l + suf
                            if nw in words:
                                mp[nw].append(w)
                                next_lev.add(nw)
                q.extend(next_lev)
                words -= next_lev
                next_lev.clear()

        bfs(words)

        def dfs(w: str, arr):
            if w == beginWord:
                ans.append(list(arr))
                return
            for nw in mp[w]:
                arr.appendleft(nw)
                dfs(nw,arr)
                arr.popleft()

        if endWord in mp:
            dfs(endWord, deque([endWord]))

        return ans

2026-01-08 17:17:32 +0300 MSK

Thu, 08 Jan 2026 17:17:32 +0300

Code

class Solution:
    def numDistinct(self, s: str, t: str) -> int:
        cache = {}
        length1, length2 = len(s), len(t)

        def dp(i: int, j: int) -> int:
            if j == length2:
                return 1
            if i == length1:
                return 0
            key = (i, j)
            if key in cache:
                return cache[key]
            res = 0
            if s[i] == t[j]:
                res += dp(i + 1, j+ 1)
            res += dp(i + 1, j)
            cache[key] = res
            return res

        return dp(0, 0)

2026-01-08 15:42:20 +0300 MSK

Thu, 08 Jan 2026 15:42:20 +0300

Code

class Solution:
    def maxDotProduct(self, nums1: List[int], nums2: List[int]) -> int:
        cache = {}

        def dp(i: int, j: int):
            if i == len(nums1) or j == len(nums2):
                return float("-inf")
            if (i, j) in cache:
                return cache[(i, j)]
            take = nums1[i] * nums2[j]
            res = max(take + dp(i+1, j+1), take, dp(i+1,j), dp(i,j+1))
            cache[(i, j)] = res
            return cache[(i, j)]

        return dp(0,0)

2026-01-07 21:40:08 +0300 MSK

Wed, 07 Jan 2026 21:40:08 +0300

Code

class Solution:
    def isScramble(self, s1: str, s2: str) -> bool:
        cache = {}

        def check(s1: str, s2: str) -> bool:
            key = (s1, s2)
            if key in cache:
                return cache[key]
            if s1 == s2:
                cache[key] = True
                return True
            res = False
            for middle in range(1, len(s1)):    
                if (
                    check(s1[:middle], s2[:middle]) 
                    and check(s1[middle:], s2[middle:])    
                ) or (
                    check(s1[:middle], s2[-middle:])
                    and check(s1[middle:], s2[:len(s1) - middle])
                ):
                    res = True
                    break
            cache[key] = res
            return res

        return check(s1, s2)

2026-01-07 19:46:02 +0300 MSK

Wed, 07 Jan 2026 19:46:02 +0300

Code

class Solution:
    def largestRectangleArea(self, heights: List[int]) -> int:
        stack = []
        area = 0
        length = len(heights)

        for i in range(length):
            while stack and heights[i] < heights[stack[-1]]:
                bar = stack.pop()
                if stack:
                    pse = stack[-1]
                else:
                    pse =  -1
                nse = i
                area = max(area, heights[bar] * (nse - pse - 1))
            stack.append(i)

        while stack:
            bar = stack.pop()
            if stack:
                pse = stack[-1] 
            else:
                pse =  -1
            nse = length
            area = max(area, heights[bar] * (nse - pse - 1))

        return area

2026-01-07 18:35:43 +0300 MSK

Wed, 07 Jan 2026 18:35:43 +0300

Code

class Solution:
    def orderlyQueue(self, s: str, k: int) -> str:
        if k > 1:
            return "".join(sorted(s))
        min_string = s
        for i in range(1, len(s)):
            min_string = min(min_string, s[i:] + s[:i])
        return min_string

2026-01-07 15:39:17 +0300 MSK

Wed, 07 Jan 2026 15:39:17 +0300

Code

import itertools

class Solution:
    def getPermutation(self, n: int, k: int) -> str:
        for nums in itertools.permutations(range(1, n + 1), n):
            if k == 1:
                return "".join(map(str, nums))
            k -= 1
        raise Exception

2026-01-07 15:23:44 +0300 MSK

Wed, 07 Jan 2026 15:23:44 +0300

Code

class Solution:
    def solveNQueens(self, n: int) -> List[List[str]]:
        res = []
        state = [["."] * n for _ in range(n)]
    
        def backtrack(row: int, col: int, left: int) -> None:
            if left == 0: 
                res.append(tuple("".join(cur_row) for cur_row in state))
                return
            if row >= n or col >= n:
                return

            place = True
            for i in range(row):
                if state[i][col] == "Q":
                    place = False
                    break

            if place:
                cur_i, cur_j = row, col
                while cur_i >= 0 and cur_j >= 0:
                    if state[cur_i][cur_j] == "Q":
                        place = False
                        break
                    cur_i -= 1
                    cur_j -= 1
            
            if place:
                cur_i, cur_j = row, col
                while cur_i >= 0 and cur_j < n:
                    if state[cur_i][cur_j] == "Q":
                        place = False
                        break
                    cur_i -= 1
                    cur_j += 1

            if place:    
                state[row][col] = "Q"
                backtrack(row + 1, 0, left - 1)
                state[row][col] = "."
            
            if col + 1 == n:
                nxt_row, nxt_col = row + 1, 0
            else:
                nxt_row, nxt_col = row, col + 1
            backtrack(nxt_row, nxt_col, left)

        backtrack(0, 0, n)
        
        return res

2026-01-07 14:29:52 +0300 MSK

Wed, 07 Jan 2026 14:29:52 +0300

Code

class Solution:
    def longestValidParentheses(self, s: str) -> int:
        stack = []
        lengths = [0] * len(s)
        max_length = 0
        for i, char in enumerate(s):
            stack.append((i, char))
            while len(stack) > 1 and stack[-2][1] == "(" and stack[-1][1] == ")":
                start, end = stack[-2][0], stack[-1][0]
                length = end - start + 1
                if start > 1:
                    length += lengths[start - 1]
                lengths[end] = length
                max_length = max(max_length, length)
                stack.pop()
                stack.pop()

        return max_length

2026-01-07 13:23:43 +0300 MSK

Wed, 07 Jan 2026 13:23:43 +0300

Code

class Solution:
    def isMatch(self, s: str, p: str) -> bool:
        length1, length2 = len(s), len(p)

        def match(i: int, j: int) -> bool:
            if i < length1:
                char = s[i]
            else:
                char = None
            if j < length2:
                pat = p[j]
            else:
                pat = None
            
            if char is None and pat is None:
                res = True
            elif pat is None:
                res = False
            elif char is None:
                res = (length2 - j) % 2 == 0
                if res:
                    for cur_j in range(j, length2, 2):
                        if p[cur_j] == "*" or p[cur_j + 1] != "*":
                            res = False
                            break
            else:
                if j + 1 < length2:
                    pat_nxt = p[j + 1]
                else:
                    pat_nxt = None
                valid = pat == "." or char == pat
                if pat_nxt and pat_nxt == "*":
                    res = (valid and match(i + 1, j)) or match(i, j + 2)
                else:
                    res = valid and match(i + 1, j + 1)

            return res

        return match(0, 0)

2026-01-07 13:23:17 +0300 MSK

Wed, 07 Jan 2026 13:23:17 +0300

Code

class Solution:
    def isMatch(self, s: str, p: str) -> bool:
        length1, length2 = len(s), len(p)
        cache = {}

        def match(i: int, j: int) -> bool:
            if (i, j) in cache:
                return cache[(i, j)]
            if i < length1:
                char = s[i]
            else:
                char = None
            if j < length2:
                pat = p[j]
            else:
                pat = None
            
            if char is None and pat is None:
                res = True
            elif pat is None:
                res = False
            elif char is None:
                res = (length2 - j) % 2 == 0
                if res:
                    for cur_j in range(j, length2, 2):
                        if p[cur_j] == "*" or p[cur_j + 1] != "*":
                            res = False
                            break
            else:
                if j + 1 < length2:
                    pat_nxt = p[j + 1]
                else:
                    pat_nxt = None
                valid = pat == "." or char == pat
                if pat_nxt and pat_nxt == "*":
                    res = (valid and match(i + 1, j)) or match(i, j + 2)
                else:
                    res = valid and match(i + 1, j + 1)

            cache[(i, j)] = res
            return res

        return match(0, 0)

2026-01-07 12:50:50 +0300 MSK

Wed, 07 Jan 2026 12:50:50 +0300

Code

class Solution:
    def isMatch(self, s: str, p: str) -> bool:
        length1, length2 = len(s), len(p)
        cache = {}
        def search(i: int, j: int) -> bool:
            if (i, j) in cache:
                return cache[(i, j)]
            if i < length1:
                char = s[i]
            else:
                char = None
            if j < length2:
                pat = p[j]
            else:
                pat = None
            if char is None and pat is None:
                res = True
            elif char is None:
                res = pat == "*" and search(i, j + 1)
            elif pat is None:
                res = False
            elif pat == "?":
                res = search(i + 1, j + 1)
            elif pat == "*":
                nxt = j + 1
                while nxt < length2 and p[nxt] == "*":
                    nxt += 1
                res = search(i, nxt) or search(i + 1, nxt) or search(i + 1, j)
            else:
                res = pat == char and search(i + 1, j + 1)
            cache[(i, j)] = res
            return res

        return search(0, 0)

2026-01-07 11:11:18 +0300 MSK

Wed, 07 Jan 2026 11:11:18 +0300

Code

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def maxProduct(self, root: Optional[TreeNode]) -> int:
        if root is None:
            return 0
        sums = {}
        def dfs_sum(node: Optional[TreeNode]) -> int:
            if node is None:
                return 0
            node_id = id(node)
            if node_id in sums:
                return sums[node_id]
            res = node.val + dfs_sum(node.left) + dfs_sum(node.right)
            sums[node_id] = res
            return res
        dfs_sum(root)
        root_sum = sums[id(root)]
        def dfs(node: Optional[TreeNode]) -> int:
            if node is None:
                return 0
            tree1 = sums[id(node)]
            tree2 = root_sum - tree1 
            res = max(tree1 * tree2, dfs(node.left), dfs(node.right))
            return res
        return max(dfs(root.left), dfs(root.right)) % (10 ** 9 + 7)

2026-01-06 23:04:34 +0300 MSK

Tue, 06 Jan 2026 23:04:34 +0300

Code

import re

PATTERN = r"^[-+]?(\d+|[.]\d+|\d+[.]\d*)([eE][-+]?\d+)?$"

class Solution:
    def isNumber(self, s: str) -> bool:
        return re.match(PATTERN, s) is not None

2026-01-06 22:19:43 +0300 MSK

Tue, 06 Jan 2026 22:19:43 +0300

Code

class Encrypter:

    def __init__(self, keys: List[str], values: List[str], dictionary: List[str]):
        self.key_to_i = {}
        self.keys = keys
        self.values = values
        self.value_to_i = collections.defaultdict(list)
        for i, key in enumerate(keys):
            self.key_to_i[key] = i
        for i, value in enumerate(values):
            self.value_to_i[value].append(i)
        self.trie = {}
        for word in dictionary:
            trie = self.trie
            for char in word:
                if char not in trie:
                    trie[char] = {}
                trie = trie[char]
            trie[""] = True

    def encrypt(self, word1: str) -> str:
        res = []
        for char in word1:
            if char not in self.key_to_i:
                return ""
            res.append(self.values[self.key_to_i[char]])
        return "".join(res)

    def decrypt(self, word2: str) -> int:
        def backtrack(i: int, trie: dict[str, dict]) -> int:
            if i >= len(word2):
                if trie.get(""):
                    return 1
                return 0
            res = 0
            for idx in self.value_to_i[word2[i:i+ 2]]:
                key = self.keys[idx]
                if key in trie:
                    res += backtrack(i + 2, trie[key])
            return res

        return backtrack(0, self.trie)

# Your Encrypter object will be instantiated and called as such:
# obj = Encrypter(keys, values, dictionary)
# param_1 = obj.encrypt(word1)
# param_2 = obj.decrypt(word2)

2026-01-06 21:39:35 +0300 MSK

Tue, 06 Jan 2026 21:39:35 +0300

Code

class MaxString:
    __slots__ = ("s")
    def __init__(self, s):
        self.s = s

    def __lt__(self, other):
        return self.s > other.s


class SORTracker:
    def __init__(self):
        self.right = []
        self.left = []

    def add(self, name: str, score: int) -> None:
        _, name, score = heapq.heappushpop(
            self.left, 
            ((score, MaxString(name)), name, score)
        )
        heapq.heappush(self.right, ((-score, name), name, score))

    def get(self) -> str:
        _, name, score = heapq.heappop(self.right)
        heapq.heappush(self.left, ((score, MaxString(name)), name, score))
        return name

2026-01-06 21:10:32 +0300 MSK

Tue, 06 Jan 2026 21:10:32 +0300

Code

from sortedcontainers import SortedList

class SORTracker:

    def __init__(self):
        self.cnt = 0 
        self.data = SortedList()

    def add(self, location: str, score: int) -> None:
        self.data.add((-score, location))

    def get(self) -> str:
        _, location = self.data[self.cnt]
        self.cnt+= 1
        return location

2026-01-06 19:37:48 +0300 MSK

Tue, 06 Jan 2026 19:37:48 +0300

Code

class WordFilter:

    def __init__(self, words: List[str]):
        self.prefix = {}
        self.postfix = {}
        for i, word in enumerate(words):
            prefix = self.prefix
            for char in word:
                if char not in prefix:
                    prefix[char] = {}
                prefix = prefix[char]
            prefix[""] = i
            postfix = self.postfix
            for char in reversed(word):
                if char not in postfix:
                    postfix[char] = {}
                postfix = postfix[char]
            if "" not in postfix:
                postfix[""] = set()
            postfix[""] = i

    def f(self, pref: str, suff: str) -> int:
        prefixes, postfixes = set(), set()
        postfix, prefix = self.postfix, self.prefix
        for char in pref:
            if char not in prefix:
                return -1
            prefix = prefix[char]
        for char in reversed(suff):
            if char not in postfix:
                return -1
            postfix = postfix[char]
        postfix_queue = [postfix]
        prefix_queue = [prefix]
        while postfix_queue:
            for key, value in postfix_queue.pop().items():
                if key == "":
                    postfixes.add(value)
                else:
                    postfix_queue.append(value)
        while prefix_queue:
            for key, value in prefix_queue.pop().items():
                if key == "":
                    prefixes.add(value)
                else:
                    prefix_queue.append(value)
        res = prefixes & postfixes
        if not res:
            return -1
        return max(res)

# Your WordFilter object will be instantiated and called as such:
# obj = WordFilter(words)
# param_1 = obj.f(pref,suff)

2026-01-06 12:16:09 +0300 MSK

Tue, 06 Jan 2026 12:16:09 +0300

Code

class FreqStack:

    def __init__(self):
        self.levels = [None]
        self.last_level = 0
        self.freqs = collections.defaultdict(int)

    def push(self, val: int) -> None:
        freq = self.freqs[val] + 1
        if freq >= len(self.levels):
            self.levels.append([])
        self.levels[freq].append(val)
        self.freqs[val] = freq

    def pop(self) -> int:
        for i in reversed(range(len(self.levels))):
            level = self.levels[i]
            if level:
                val = level.pop()
                self.freqs[val] -= 1
                return val
        raise Exception


# Your FreqStack object will be instantiated and called as such:
# obj = FreqStack()
# obj.push(val)
# param_2 = obj.pop()

2026-01-06 10:05:37 +0300 MSK

Tue, 06 Jan 2026 10:05:37 +0300

Code

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def maxLevelSum(self, root: Optional[TreeNode]) -> int:
        cur, nxt = [root], []
        level = 1
        min_level, max_sum = 1, root.val
        while cur or nxt:
            cur_sum = 0
            while cur:
                node = cur.pop()
                cur_sum += node.val
                if node.left:
                    nxt.append(node.left)
                if node.right:
                    nxt.append(node.right)
            if cur_sum > max_sum:
                min_level, max_sum = level, cur_sum
            cur, nxt = nxt, cur
            level += 1
        return min_level

2026-01-05 18:58:31 +0300 MSK

Mon, 05 Jan 2026 18:58:31 +0300

Code

class TreeAncestor:

    def __init__(self, n: int, parent: List[int]):
        m = 1 + int(log2(n)) #at most 16 for this problem 
        self.dp = [[-1] * m for _ in range(n)] #ith node's 2^j parent
        for j in range(m):
            for i in range(n):
                if j == 0: 
                    self.dp[i][0] = parent[i] 
                elif self.dp[i][j-1] != -1: 
                    self.dp[i][j] = self.dp[self.dp[i][j-1]][j-1]
    
    def getKthAncestor(self, node: int, k: int) -> int:
        while k > 0 and node != -1: 
            i = int(log2(k))
            node = self.dp[node][i]
            k -= (1 << i)
        return node

2026-01-05 14:24:49 +0300 MSK

Mon, 05 Jan 2026 14:24:49 +0300

Code

class Node:
    def __init__(
        self, 
        char: str, 
        prev: Optional["Node"], 
        nxt: Optional["Node"]
    ) -> None:
        self.char = char
        self.prev = prev
        self.nxt = nxt

class TextEditor:

    def __init__(self):
        self.length = 0
        self.root = Node("", None, None)
        self.cursor = self.root

    def addText(self, text: str) -> None:
        node = self.cursor
        self.length += len(text)
        for char in text:
            cur = Node(char, node, node.nxt)
            nxt = node.nxt
            node.nxt = cur
            if nxt:
                nxt.prev = cur
            node = cur
            self.cursor = cur

    def deleteText(self, k: int) -> int:
        res = 0
        while self.cursor is not self.root and k > 0:
            res += 1
            k -= 1
            if self.cursor.nxt:
                self.cursor.nxt.prev = self.cursor.prev
            self.cursor.prev.nxt = self.cursor.nxt
            self.cursor = self.cursor.prev
        return res

    def last_ten(self) -> str:
        res = []
        node = self.cursor
        while node is not self.root and len(res) < 10:
            res.append(node.char)
            node = node.prev
        res.reverse()
        return "".join(res)

    def cursorLeft(self, k: int) -> str:
        while self.cursor is not self.root and k > 0:
            k -= 1
            self.cursor = self.cursor.prev
        res = self.last_ten()
        return res

    def cursorRight(self, k: int) -> str:
        while self.cursor.nxt  and k > 0:
            k -= 1
            self.cursor = self.cursor.nxt
        res = self.last_ten()
        return res

# Your TextEditor object will be instantiated and called as such:
# obj = TextEditor()
# obj.addText(text)
# param_2 = obj.deleteText(k)
# param_3 = obj.cursorLeft(k)
# param_4 = obj.cursorRight(k)

2026-01-05 12:30:08 +0300 MSK

Mon, 05 Jan 2026 12:30:08 +0300

Code

class Solution:
    def maxMatrixSum(self, matrix: List[List[int]]) -> int:
        heap = []
        min_pos = float("inf")
        res = 0
        for row in matrix:
            for col in row:
                if col < 0:
                    heapq.heappush(heap, col)
                else:
                    res += col
                    min_pos = min(min_pos, col)
        while len(heap) >= 2:
            res += -(heapq.heappop(heap) + heapq.heappop(heap))
        if not heap:
            return res
        last = heap.pop()
        if min_pos == float("inf"):
            return res + last
        return max(res + last, (res - min_pos) - (min_pos + last))

2026-01-04 21:18:13 +0300 MSK

Sun, 04 Jan 2026 21:18:13 +0300

Code

class Solution:
    def sumFourDivisors(self, nums: list[int]) -> int:
        res = 0
        for n in nums:
            val = self.sumOne(n)
            if val != -1:
                res += val
        return res

    def sumOne(self, n: int) -> int:
        p = round(n ** (1/3))
        if p ** 3 == n and self.isPrime(p):
            return 1 + p + p*p + p*p*p

        for i in range(2, int(n ** 0.5) + 1):
            if n % i == 0:
                a, b = i, n // i
                if a != b and self.isPrime(a) and self.isPrime(b):
                    return 1 + a + b + n
                return -1
        return -1

    def isPrime(self, x: int) -> bool:
        if x < 2:
            return False
        for i in range(2, int(x ** 0.5) + 1):
            if x % i == 0:
                return False
        return True

2026-01-03 13:57:12 +0300 MSK

Sat, 03 Jan 2026 13:57:12 +0300

Code

class Solution:
    def numOfWays(self, n: int) -> int:
        MOD = 10**9 + 7
        A = B = 6

        for _ in range(2, n + 1):
            A, B = (2*A + 2*B) % MOD, (2*A + 3*B) % MOD

        return (A + B) % MOD

2026-01-02 16:54:09 +0300 MSK

Fri, 02 Jan 2026 16:54:09 +0300

Code

class StreamChecker:

    def __init__(self, words: List[str]):
        self.trie = {}
        self.min_length = float("inf")
        for word in words:
            node = self.trie
            self.min_length = min(self.min_length, len(word))
            for char in reversed(word):
                if char not in node:
                    node[char] = {}
                node = node[char]
            node["is_word"] = True 
        self.letters = []

    def query(self, letter: str) -> bool:
        self.letters.append(letter)
        if len(self.letters) < self.min_length:
            return False
        node = self.trie
        for letter in reversed(self.letters):
            if letter not in node:
                return False
            if node[letter].get("is_word"):
                return True
            node = node[letter]
        return False
            



# Your StreamChecker object will be instantiated and called as such:
# obj = StreamChecker(words)
# param_1 = obj.query(letter)

2026-01-02 16:49:02 +0300 MSK

Fri, 02 Jan 2026 16:49:02 +0300

Code

class StreamChecker:

    def __init__(self, words: List[str]):
        self.trie = {}
        self.lengths = set() 
        for word in words:
            node = self.trie
            self.lengths.add(len(word))
            for char in word:
                if char not in node:
                    node[char] = {}
                node = node[char]
            node["is_word"] = True 
        self.letters = []

    def query(self, letter: str) -> bool:
        self.letters.append(letter)
        
        for length in self.lengths:
            if length > len(self.letters):
                continue
            node = self.trie
            was_break = False
            for letter in self.letters[-length:]:
                if letter not in node:
                    was_break = True
                    break
                node = node[letter]
            if was_break:
                continue
            if node.get("is_word", False):
                return True

        return False
            



# Your StreamChecker object will be instantiated and called as such:
# obj = StreamChecker(words)
# param_1 = obj.query(letter)

2026-01-02 10:21:34 +0300 MSK

Fri, 02 Jan 2026 10:21:34 +0300

Code

class Solution:
    def repeatedNTimes(self, nums: List[int]) -> int:
        enc = set()
        for num in nums:
            if num in enc:
                return num
            enc.add(num)
        raise Exception

2026-01-01 13:06:44 +0300 MSK

Thu, 01 Jan 2026 13:06:44 +0300

Code

class RLEIterator:

    def __init__(self, encoding: List[int]):
        self.i, self.enc, self.length = 0, encoding, len(encoding)

    def next(self, n: int) -> int:
        while self.i < self.length and  n > 0:
            count = self.enc[self.i]
            if count == 0:
                self.i += 2
            elif count >= n:
                self.enc[self.i] -= n
                return self.enc[self.i + 1]
            else:
                n -= count
                self.i += 2
        return -1

# Your RLEIterator object will be instantiated and called as such:
# obj = RLEIterator(encoding)
# param_1 = obj.next(n)

2026-01-01 13:05:15 +0300 MSK

Thu, 01 Jan 2026 13:05:15 +0300

Code

class RLEIterator:

    def __init__(self, encoding: List[int]):
        self.enc = encoding
        self.enc.reverse()

    def next(self, n: int) -> int:
        while self.enc and n > 0:
            count = self.enc[-1]
            if count == 0:
                self.enc.pop()
                self.enc.pop()
            elif count >= n:
                self.enc[-1] -= n
                return self.enc[-2]
            else:
                n -= count
                self.enc.pop()
                self.enc.pop()
        return -1

# Your RLEIterator object will be instantiated and called as such:
# obj = RLEIterator(encoding)
# param_1 = obj.next(n)

2026-01-01 12:27:10 +0300 MSK

Thu, 01 Jan 2026 12:27:10 +0300

Code

class Solution:
    def plusOne(self, digits: List[int]) -> List[int]:
        for i in reversed(range(len(digits))):
            dig = digits[i] + 1
            if dig == 10:
                digits[i] = 0
                if i == 0:
                    digits.insert(0, 1)
            else:
                digits[i] = dig
                break
        return digits

2025-12-31 18:07:08 +0300 MSK

Wed, 31 Dec 2025 18:07:08 +0300

Code

class Solution:
    def latestDayToCross(self, row: int, col: int, cells: list[list[int]]) -> int:
        dsu = DSU(row * col + 2)
        grid = [[0] * col for _ in range(row)]
        dirs = [(0, 1), (0, -1), (1, 0), (-1, 0), (1, 1), (1, -1), (-1, 1), (-1, -1)]

        for i in range(row * col):
            r = cells[i][0] - 1
            c = cells[i][1] - 1
            grid[r][c] = 1

            id1 = r * col + c + 1
            for dr, dc in dirs:
                nr, nc = r + dr, c + dc
                if 0 <= nr < row and 0 <= nc < col and grid[nr][nc] == 1:
                    id2 = nr * col + nc + 1
                    dsu.union(id1, id2)

            if c == 0:
                dsu.union(0, id1)
            if c == col - 1:
                dsu.union(row * col + 1, id1)

            if dsu.find(0) == dsu.find(row * col + 1):
                return i
        return -1


class DSU:
    def __init__(self, n):
        self.root = list(range(n))
        self.size = [1] * n

    def find(self, x):
        if self.root[x] != x:
            self.root[x] = self.find(self.root[x])
        return self.root[x]

    def union(self, x, y):
        rx = self.find(x)
        ry = self.find(y)
        if rx == ry:
            return
        if self.size[rx] > self.size[ry]:
            rx, ry = ry, rx
        self.root[rx] = ry
        self.size[ry] += self.size[rx]

2025-12-30 21:07:43 +0300 MSK

Tue, 30 Dec 2025 21:07:43 +0300

Code

class Solution:
    def numMagicSquaresInside(self, grid: List[List[int]]) -> int:
        ans = 0
        m = len(grid)
        n = len(grid[0])
        for row in range(m - 2):
            for col in range(n - 2):
                if self._isMagicSquare(grid, row, col):
                    ans += 1
        return ans

    def _isMagicSquare(self, grid, row, col):
        # The sequences are each repeated twice to account for
        # the different possible starting points of the sequence
        # in the magic square
        sequence = "2943816729438167"
        sequenceReversed = "7618349276183492"

        border = []
        # Flattened indices for bordering elements of 3x3 grid
        borderIndices = [0, 1, 2, 5, 8, 7, 6, 3]
        for i in borderIndices:
            num = grid[row + i // 3][col + (i % 3)]
            border.append(str(num))

        borderConverted = "".join(border)

        # Make sure the sequence starts at one of the corners
        return (
            grid[row][col] % 2 == 0
            and (
                sequence.find(borderConverted) != -1
                or sequenceReversed.find(borderConverted) != -1
            )
            and grid[row + 1][col + 1] == 5
        )

2025-12-29 19:39:26 +0300 MSK

Mon, 29 Dec 2025 19:39:26 +0300

Code


from functools import cache


class Solution:
    def pyramidTransition(self, bottom: str, allowed: List[str]) -> bool:
        # build up potential values for next rows based on allowed values
        tops = defaultdict(list)
        for key in allowed:
            tops[key[:2]].append(key[2])

        def gen_next_rows(full_items, all_valid=set(), i=0, cur=''):
            # handle when a base pair does not have a top option in allowed
            if any([item == [] for item in full_items]):
                return []

            # generated a full new line, add to set of valid options
            if i == len(full_items):
                all_valid.add(cur)
                return

            # full line is not complete, for each top option of current base pair,
            # use it and look at the options for the next base pair.
            for item in full_items[i]:
                gen_next_rows(full_items, all_valid, i + 1, cur + item)

            # all row options generated, return the options
            return all_valid

        seen = set()

        def find_next_row(last):
            n = len(last)
            # made it to the top with a valid top option for the row of length 2
            if n == 1:
                return True

            # Generate all potential options for the next row and try them.
            # For example 2: the list comprehension used in gen_next_rows would be
            # [['B', 'C'], ['B', 'C'], ['B', 'C']] for the next row choices after bottom
            options = gen_next_rows([tops[last[i:i + 2]] for i in range(n - 1)], set())

            # cache is useful here because the same sequence may appear more than once
            # as the pyramid builds up.
            for option in options:
                if option in seen:
                    continue
                if find_next_row(option):
                    return True
                seen.add(option)
            return False
        return find_next_row(bottom)

2025-12-28 16:38:30 +0300 MSK

Sun, 28 Dec 2025 16:38:30 +0300

Code

class Solution:
    def countNegatives(self, grid: List[List[int]]) -> int:
        count = 0
        for row in reversed(grid):
            for col in reversed(row):
                if col < 0:
                    count += 1
                else:
                    break
        return count

2025-12-27 17:07:34 +0300 MSK

Sat, 27 Dec 2025 17:07:34 +0300

Code

class Solution:
    def mostBooked(self, n: int, meetings: List[List[int]]) -> int:
        unused_rooms, used_rooms = list(range(n)), []
        heapify(unused_rooms)
        meeting_count = [0] * n
        for start, end in sorted(meetings):
            while used_rooms and used_rooms[0][0] <= start:
                _, room = heappop(used_rooms)
                heappush(unused_rooms, room)
            if unused_rooms:
                room = heappop(unused_rooms)
                heappush(used_rooms, [end, room])
            else:
                room_availability_time, room = heappop(used_rooms)
                heappush(
                    used_rooms,
                    [room_availability_time + end - start, room]
                )
            meeting_count[room] += 1
        return meeting_count.index(max(meeting_count))

2025-12-27 16:57:55 +0300 MSK

Sat, 27 Dec 2025 16:57:55 +0300

Code

class Node:
    def __init__(self,  name: str, parent: Optional["Node"] = None) -> None:
        self.name: str = name
        self.parent: Optional["Node"] = parent
        self.children: list[Node] = []
        self.dead: bool = False

    def __iter__(self) -> Generator["Node", None, None]:
        if not self.dead:
            yield self
        for child in self.children:
            yield from child

class ThroneInheritance:

    def __init__(self, kingName: str):
        self._root: Node = Node(kingName)
        self._nodes: dict[str, Node] = {
            kingName: self._root
        }

    def birth(self, parentName: str, childName: str) -> None:
        parent = self._nodes[parentName]
        child = Node(childName, parent)
        parent.children.append(child)
        self._nodes[childName] = child

    def death(self, name: str) -> None:
        node = self._nodes.pop(name)
        node.dead = True

    def getInheritanceOrder(self) -> List[str]:
        return list(node.name for node in self._root)


# Your ThroneInheritance object will be instantiated and called as such:
# obj = ThroneInheritance(kingName)
# obj.birth(parentName,childName)
# obj.death(name)
# param_3 = obj.getInheritanceOrder()

2025-12-27 16:45:10 +0300 MSK

Sat, 27 Dec 2025 16:45:10 +0300

Code

class LUPrefix:
    def __init__(self, n: int):
        self._start = {}
        self._end = {}

    def upload(self, video: int) -> None:
        if video - 1 not in self._end and video + 1 not in self._start:
            self._start[video] = video
            self._end[video] = video
        elif video - 1 in self._end and video + 1 in self._start:
            end = self._start.pop(video + 1)
            start = self._end.pop(video - 1)
            self._start[start] = end
            self._end[end] = start
        elif video -1 in self._end:
            start = self._end.pop(video - 1)
            self._start[start] = video
            self._end[video] = start
        elif video + 1 in self._start:
            end = self._start.pop(video + 1)
            self._start[video] = end
            self._end[end] = video

    def longest(self) -> int:
        return self._start.get(1, 0)

# Your LUPrefix object will be instantiated and called as such:
# obj = LUPrefix(n)
# obj.upload(video)
# param_2 = obj.longest()

2025-12-26 21:12:54 +0300 MSK

Fri, 26 Dec 2025 21:12:54 +0300

Code

class CombinationIterator:

    def __init__(self, characters: str, combinationLength: int):
        self._length: int = combinationLength
        self._chars: str = characters
        self._cur: list[str] = []
        self._gen = self._generator(0)
        self._nxt: Optional[str] = next(self._gen, None)
    
    def _generator(self, i: int) -> Generator[str, None, None]:
        if len(self._cur) == self._length:
            yield "".join(self._cur)
            return
        if i >= len(self._chars):
            return
        char = self._chars[i]
        self._cur.append(char)
        yield from self._generator(i + 1)
        self._cur.pop()
        yield from self._generator(i + 1)

    def next(self) -> str:
        nxt = self._nxt
        self._nxt = next(self._gen, None)
        return nxt

    def hasNext(self) -> bool:
        return self._nxt is not  None


# Your CombinationIterator object will be instantiated and called as such:
# obj = CombinationIterator(characters, combinationLength)
# param_1 = obj.next()
# param_2 = obj.hasNext()

2025-12-26 14:01:28 +0300 MSK

Fri, 26 Dec 2025 14:01:28 +0300

Code

class Solution:
    def bestClosingTime(self, customers: str) -> int:
        j, min_pen = len(customers), customers.count("N")
        cur_pen = min_pen
        for i in reversed(range(len(customers))):
            if customers[i] == "Y":
                cur_pen += 1
            else:
                cur_pen -= 1
            if cur_pen <= min_pen:
                j, min_pen = i, cur_pen
        return j

2025-12-25 20:08:37 +0300 MSK

Thu, 25 Dec 2025 20:08:37 +0300

Code

class Solution:
    def maximumHappinessSum(self, happiness: List[int], k: int) -> int:
        happiness.sort()
        res = 0
        for i in range(k):
            res += max(0, happiness.pop() - i)
        return res

2025-12-25 20:05:52 +0300 MSK

Thu, 25 Dec 2025 20:05:52 +0300

Code

class Solution:
    def maximumHappinessSum(self, happiness: List[int], k: int) -> int:
        happiness.sort(reverse=True)
        happiness = happiness[:k]
        res = 0
        for i in range(len(happiness)):
            res += max(0, happiness[i] - i)
        return res

2025-12-24 15:28:01 +0300 MSK

Wed, 24 Dec 2025 15:28:01 +0300

Code

class Solution:
    def minimumBoxes(self, apple: List[int], capacity: List[int]) -> int:
        count = sum(apple)
        capacity.sort()
        res = 0
        while count > 0:
            res += 1
            count -= capacity.pop()
        return res

2025-12-24 14:24:51 +0300 MSK

Wed, 24 Dec 2025 14:24:51 +0300

Code

class Solution:
    def rob(self, nums: List[int]) -> int:
        n = len(nums)
        if n == 1:
            return nums[0]

        def dp(i, j, memo: dict):
            if i == j:
                return 0
            if i == j-1:
                return nums[j-1]
            if (i, j) not in memo:
                rob = nums[i] + dp(i+2, j, memo)
                skip = dp(i+1, j, memo)
                memo[(i, j)] = max(rob, skip)
            return memo[(i, j)]
        return max(dp(0, n-1, {}), dp(1, n, {}))

2025-12-24 13:58:01 +0300 MSK

Wed, 24 Dec 2025 13:58:01 +0300

Code

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def pathSum(self, root: Optional[TreeNode], targetSum: int) -> List[List[int]]:
        res, cur = [], []
        
        def dfs(node: Optional[TreeNode], cur_sum: int) -> None:
            if node is None:
                return
            cur_sum += node.val
            cur.append(node.val)
            if node.right or node.left:
                dfs(node.left, cur_sum)
                dfs(node.right, cur_sum)
            elif cur_sum == targetSum:
                res.append(cur.copy())
            cur.pop()

        dfs(root, 0)
        return res

2025-12-24 13:51:10 +0300 MSK

Wed, 24 Dec 2025 13:51:10 +0300

Code

class Solution:
    def recoverTree(self, root: Optional[TreeNode]) -> None:
        self.first = self.second = self.prev = None

        def inorder(node):
            if not node:
                return
            inorder(node.left)
            if self.prev and self.prev.val > node.val:
                if not self.first:
                    self.first = self.prev
                self.second = node
            self.prev = node
            inorder(node.right)

        inorder(root)

        # Swap the values
        self.first.val, self.second.val = self.second.val, self.first.val

2025-12-24 13:44:07 +0300 MSK

Wed, 24 Dec 2025 13:44:07 +0300

Code

class Solution:
    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
        heap = []
        freqs = defaultdict(int)
        for num in nums:
            freqs[num] += 1
            freq = freqs[num]
            heapq.heappush(heap, (-freq, num))
        res = set()
        while k > 0:
            _, num = heapq.heappop(heap)
            if num not in res:
                k -= 1
                res.add(num)
        return list(res)

2025-12-24 12:18:23 +0300 MSK

Wed, 24 Dec 2025 12:18:23 +0300

Code

class Solution:
    def hIndex(self, citations: List[int]) -> int:
        left, right = 0, len(citations) - 1
        h = 0
        while left <= right:
            mid = left + (right - left) // 2
            count = len(citations) - mid
            val = citations[mid]
            h = max(h, min(count, val))
            if count >= val:
                left = mid + 1
            else:
                right = mid - 1
        return h

2025-12-23 19:29:34 +0300 MSK

Tue, 23 Dec 2025 19:29:34 +0300

Code

class Solution:
    def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:
        r = 0
        c = len(matrix[0])-1

        while r < len(matrix) and c >= 0:
            if matrix[r][c] == target:
                return True
            elif matrix[r][c] > target:
                c -= 1
            else:
                r += 1

        return False

2025-12-23 18:39:29 +0300 MSK

Tue, 23 Dec 2025 18:39:29 +0300

Code

class Solution:
    def maxTwoEvents(self, events):
        times = []
        for e in events:
            # 1 denotes start time.
            times.append([e[0], 1, e[2]])
            # 0 denotes end time.
            times.append([e[1] + 1, 0, e[2]])

        ans, max_value = 0, 0
        times.sort()

        for time_value in times:
            # If current time is a start time, find maximum sum of maximum end
            # time till now.
            if time_value[1]:
                ans = max(ans, time_value[2] + max_value)
            else:
                max_value = max(max_value, time_value[2])

        return ans

2025-12-22 19:27:46 +0300 MSK

Mon, 22 Dec 2025 19:27:46 +0300

Code

class Solution(object):
    def minDeletionSize(self, A):
        W = len(A[0])
        dp = [1] * W
        for i in range(W-2, -1, -1):
            for j in range(i+1, W):
                if all(row[i] <= row[j] for row in A):
                    dp[i] = max(dp[i], 1 + dp[j])

        return W - max(dp)

2025-12-22 16:40:19 +0300 MSK

Mon, 22 Dec 2025 16:40:19 +0300

Code

class Solution:
    def minCost(self, s: str, cost: List[int]) -> int:
        costs = [0] * 26
        for i in range(len(s)):
            char, cur_cost = s[i], cost[i]
            char_val = ord(char) - ord("a")
            for j in range(26):
                if j != char_val:
                    costs[j] += cur_cost
        res = float("inf")
        for cost in costs:
            res = min(res, cost)
        return res

2025-12-22 16:34:47 +0300 MSK

Mon, 22 Dec 2025 16:34:47 +0300

Code

class Solution:
    def mirrorDistance(self, n: int) -> int:
        dig = []
        orig = n
        while n > 0:
            dig.append(n % 10)
            n //= 10
        res = 0
        cur = 0
        while dig:
            res += dig.pop() * (10 ** cur)
            cur += 1
        return abs(orig - res)

2025-12-21 20:30:45 +0300 MSK

Sun, 21 Dec 2025 20:30:45 +0300

Code

class Solution(object):
    def minDeletionSize(self, A):
        cuts = [False] * (len(A) - 1)
        ans = 0
        for col in zip(*A):
            if all(cuts[i] or col[i] <= col[i+1] for i in range(len(col) - 1)):
                for i in range(len(col) - 1):
                    if col[i] < col[i+1]:
                        cuts[i] = True
            else:
                ans += 1
        return ans

2025-12-20 19:15:02 +0300 MSK

Sat, 20 Dec 2025 19:15:02 +0300

Code

class Solution:
    def minDeletionSize(self, strs: List[str]) -> int:
        res = 0
        for col in range(len(strs[0])):
            prev = 0
            for row in range(len(strs)):
                char = ord(strs[row][col])
                if char >= prev:
                    prev = char
                else:
                    res += 1
                    break
        return res

2025-12-20 19:14:25 +0300 MSK

Sat, 20 Dec 2025 19:14:25 +0300

Code

package main

import (
	"sort"
)

func find(groups []int, index int) int {
	for index != groups[index] {
		index = groups[index]
	}
	return index
}

func findAllPeople(n int, meetings [][]int, firstPerson int) []int {
	groups := make([]int, 100000)
	var result []int
	var temp []int

	for i := 0; i < n; i++ {
		groups[i] = i
	}
	groups[firstPerson] = 0

	sort.Slice(meetings, func(i, j int) bool {
		return meetings[i][2] < meetings[j][2]
	})

	i := 0
	for i < len(meetings) {
		currentTime := meetings[i][2]
		temp = temp[:0]
		for i < len(meetings) && meetings[i][2] == currentTime {
			g1 := find(groups, meetings[i][0])
			g2 := find(groups, meetings[i][1])
			groups[max(g1, g2)] = min(g1, g2)
			temp = append(temp, meetings[i][0], meetings[i][1])
			i++
		}
		for _, j := range temp {
			if find(groups, j) != 0 {
				groups[j] = j
			}
		}
	}

	for j := 0; j < n; j++ {
		if find(groups, j) == 0 {
			result = append(result, j)
		}
	}

	return result
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

2025-12-18 21:06:02 +0300 MSK

Thu, 18 Dec 2025 21:06:02 +0300

Code

class Solution:
    def maxProfit(self, prices: List[int], strategy: List[int], k: int) -> int:
        native_profit = 0
        native_segment = 0
        changed_segment = 0
        max_changed_segment = 0
        for i in range(len(prices)):
            price = prices[i]
            native_profit += price * strategy[i]
            native_segment += price * strategy[i]
            if i + 1 <= k // 2:
                pass
            elif i + 1 < k :
                changed_segment += price
            elif i  + 1 == k:
                changed_segment += price
                max_changed_segment = max(max_changed_segment, changed_segment - native_segment)
            else:
                changed_segment += price - prices[i - (k // 2)]
                native_segment -= prices[i - k] * strategy[i - k]
                max_changed_segment = max(max_changed_segment, changed_segment - native_segment)

        return max(native_profit, native_profit + max_changed_segment)

2025-12-17 08:08:52 +0300 MSK

Wed, 17 Dec 2025 08:08:52 +0300

Code

class Solution:
    def maximumProfit(self, prices: List[int], k: int) -> int:
        n = len(prices)
        dp = [[0] * 3 for _ in range(k + 1)]
        # initialize the state on day 0
        for j in range(1, k + 1):
            dp[j][1] = -prices[0]
            dp[j][2] = prices[0]

        for i in range(1, n):
            for j in range(k, 0, -1):
                dp[j][0] = max(
                    dp[j][0], max(dp[j][1] + prices[i], dp[j][2] - prices[i])
                )
                dp[j][1] = max(dp[j][1], dp[j - 1][0] - prices[i])
                dp[j][2] = max(dp[j][2], dp[j - 1][0] + prices[i])

        return dp[k][0]

2025-12-16 20:00:23 +0300 MSK

Tue, 16 Dec 2025 20:00:23 +0300

Code

class Solution:
    def absDifference(self, nums: List[int], k: int) -> int:
        nums.sort()
        return abs(sum(nums[:k]) - sum(nums[-k:]))

2025-12-16 19:58:35 +0300 MSK

Tue, 16 Dec 2025 19:58:35 +0300

Code

class Solution:
    def sortByReflection(self, nums: List[int]) -> List[int]:

        reverse = lambda num: int(bin(num)[-1:1:-1], 2)     # <--1)
        nums.sort(key = lambda x: (reverse(x), x))          # <--2)

        return nums

2025-12-16 19:57:10 +0300 MSK

Tue, 16 Dec 2025 19:57:10 +0300

Code

class Solution:
    def sumAndMultiply(self, n: int) -> int:
        cur = 0
        dig_sum, num = 0, 0
        while n > 0:
            dig = n % 10
            n //= 10
            if dig != 0:
                dig_sum += dig
                num += dig * (10 ** cur)
                cur += 1
        return num * dig_sum

2025-12-16 19:53:04 +0300 MSK

Tue, 16 Dec 2025 19:53:04 +0300

Code

class Solution:
    def minimumFlips(self, n: int) -> int:
        bits = []
        while n > 0:
            bits.append(n % 2)
            n //= 2
        print(bits)
        res = 0
        for i in range(len(bits) // 2):
            if bits[i] != bits[-i-1]:
                res += 2
        return res

2025-12-16 19:48:24 +0300 MSK

Tue, 16 Dec 2025 19:48:24 +0300

Code

class Solution:
    def maximizeExpressionOfThree(self, nums: List[int]) -> int:
        nums.sort()
        return  nums.pop() + nums.pop() - nums[0]

2025-12-16 19:46:51 +0300 MSK

Tue, 16 Dec 2025 19:46:51 +0300

Code

import collections

class Solution:
    def minimumDistance(self, nums: list[int]) -> int:
        idx1 = {}
        idx2 = {}
        res = float("inf")
        for i, num in enumerate(nums):
            if num in idx2:
                dist = abs(idx1[num] - idx2[num]) + abs(idx2[num] - i) + abs(i - idx1[num])
                res = min(res, dist)
                idx1[num] = idx2[num]
                idx2[num] = i
            elif num in idx1:
                idx2[num] = i
            else:
                idx1[num] = i
        if res == float("inf"):
            return -1
        return res

2025-12-16 19:33:50 +0300 MSK

Tue, 16 Dec 2025 19:33:50 +0300

Code

class Solution:
    def minMoves(self, nums: List[int]) -> int:
        target = max(nums)
        res = 0
        for num in nums:
            res += target - num
        return res

2025-12-16 19:32:04 +0300 MSK

Tue, 16 Dec 2025 19:32:04 +0300

Code

class Solution:
    def findMissingElements(self, nums: List[int]) -> List[int]:
        nums.sort()
        res = []
        for i in range(1, len(nums)):
            cur, prev = nums[i], nums[i - 1]
            res.extend(range(prev + 1, cur))
        return res

2025-12-16 19:29:16 +0300 MSK

Tue, 16 Dec 2025 19:29:16 +0300

Code

class Solution:
    def removeZeros(self, n: int) -> int:
        cur = 0
        res = 0
        while n > 0:
            dig = n % 10
            if dig != 0:
                res += dig * (10 ** cur)
                cur += 1
            n //= 10
        return res

2025-12-16 19:26:34 +0300 MSK

Tue, 16 Dec 2025 19:26:34 +0300

Code

class Solution:
    def missingMultiple(self, nums: List[int], k: int) -> int:
        enc = set(nums)
        cur = k
        while True:
            if cur in enc:
                cur += k
            else:
                return cur

2025-12-16 19:23:42 +0300 MSK

Tue, 16 Dec 2025 19:23:42 +0300

Code

class Solution:
    def sumDivisibleByK(self, nums: List[int], k: int) -> int:
        freq = [0] * 101
        for num in nums:
            freq[num] += 1
        res = 0
        for num, freq in enumerate(freq):
            if freq != 0 and freq % k == 0:
                res += num * freq
        return res

2025-12-16 19:02:03 +0300 MSK

Tue, 16 Dec 2025 19:02:03 +0300

Code

class Solution:
    def maxProfit(
        self,
        n: int,
        present: List[int],
        future: List[int],
        hierarchy: List[List[int]],
        budget: int,
    ) -> int:
        g = [[] for _ in range(n)]
        for e in hierarchy:
            g[e[0] - 1].append(e[1] - 1)

        def dfs(u: int):
            cost = present[u]
            dCost = present[u] // 2

            # dp[u][state][budget]
            # state = 0: Do not purchase parent node, state = 1: Must purchase parent node
            dp0 = [0] * (budget + 1)
            dp1 = [0] * (budget + 1)

            # subProfit[state][budget]
            # state = 0: discount not available, state = 1: discount available
            subProfit0 = [0] * (budget + 1)
            subProfit1 = [0] * (budget + 1)
            uSize = cost

            for v in g[u]:
                child_dp0, child_dp1, vSize = dfs(v)
                uSize += vSize
                for i in range(budget, -1, -1):
                    for sub in range(min(vSize, i) + 1):
                        if i - sub >= 0:
                            subProfit0[i] = max(
                                subProfit0[i],
                                subProfit0[i - sub] + child_dp0[sub],
                            )
                            subProfit1[i] = max(
                                subProfit1[i],
                                subProfit1[i - sub] + child_dp1[sub],
                            )

            for i in range(budget + 1):
                dp0[i] = subProfit0[i]
                dp1[i] = subProfit0[i]
                if i >= dCost:
                    dp1[i] = max(
                        subProfit0[i], subProfit1[i - dCost] + future[u] - dCost
                    )
                if i >= cost:
                    dp0[i] = max(
                        subProfit0[i], subProfit1[i - cost] + future[u] - cost
                    )

            return dp0, dp1, uSize

        return dfs(0)[0][budget]

2025-12-15 21:33:29 +0300 MSK

Mon, 15 Dec 2025 21:33:29 +0300

Code

class Solution:
    def getDescentPeriods(self, prices: List[int]) -> int:
        n = len(prices)
        res = 1  # total number of smooth descending periods, initial value is dp[0]
        prev = 1  # total number of smooth descending periods ending with the previous element, initial value is dp[0]
        # traverse the array starting from 1, and update prev and the total res according to the recurrence relation
        for i in range(1, n):
            if prices[i] == prices[i - 1] - 1:
                prev += 1
            else:
                prev = 1
            res += prev
        return res

2025-12-14 20:42:06 +0300 MSK

Sun, 14 Dec 2025 20:42:06 +0300

Code

class Solution {
public:
    // Store 1000000007 in a variable for convenience
    const int MOD = 1e9 + 7;
    
    // Count the number of ways to divide from "index" to the last index
    // with "seats" number of "S" in the current section
    int count(int index, int seats, string& corridor, int cache[][3]) {
        // If we have reached the end of the corridor, then
        // the current section is valid only if "seats" is 2
        if (index == corridor.length()) {
            return seats == 2 ? 1 : 0;
        }

        // If we have already computed the result of this sub-problem,
        // then return the cached result
        if (cache[index][seats] != -1) {
            return cache[index][seats];
        }

        // Result of the sub-problem
        int result = 0;

        // If the current section has exactly 2 "S"
        if (seats == 2) {
            // If the current element is "S", then we have to close the
            // section and start a new section from this index. Next index
            // will have one "S" in the current section
            if (corridor[index] == 'S') {
                result = count(index + 1, 1, corridor, cache);
            } else {
                // If the current element is "P", then we have two options
                // 1. Close the section and start a new section from this index
                // 2. Keep growing the section
                result = (count(index + 1, 0, corridor, cache) + count(index + 1, 2, corridor, cache)) % MOD;  
            }
        } else {
            // Keep growing the section. Increment "seats" if present
            // element is "S"
            if (corridor[index] == 'S') {
                result = count(index + 1, seats + 1, corridor, cache);
            } else {
                result = count(index + 1, seats, corridor, cache);
            }
        }

        // Memoize the result, and return it
        cache[index][seats] = result;
        return cache[index][seats];
    }

    int numberOfWays(string corridor) {
        // Cache the result of each sub-problem
        int cache[corridor.length()][3];
        memset(cache, -1, sizeof(cache));

        // Call the count function
        return count(0, 0, corridor, cache);
    }
};

2025-12-13 20:21:05 +0300 MSK

Sat, 13 Dec 2025 20:21:05 +0300

Code

class Solution:
    def validateCoupons(self, code: List[str], businessLine: List[str], isActive: List[bool]) -> List[str]:
        res, n = [], len(code)
        b_order = {"electronics": 0, "grocery": 1, "pharmacy": 2, "restaurant": 3}
        for i in range(n):
            if (
                isActive[i] 
                and code[i] 
                and re.match("^[a-zA-Z0-9_]+$", code[i]) 
                and businessLine[i] in (
                    "electronics", "grocery", "pharmacy", "restaurant"
                )
            ):
                res.append(i)
        def sort(i: int) -> tuple[str, str]:
            return (b_order[businessLine[i]], code[i])
        res.sort(key=sort)
        for i in range(len(res)):
            res[i] = code[res[i]]
        return res

2025-12-13 20:20:09 +0300 MSK

Sat, 13 Dec 2025 20:20:09 +0300

Code

class Solution:
    def countMentions(
        self, numberOfUsers: int, events: List[List[str]]
    ) -> List[int]:
        events.sort(key=lambda e: (int(e[1]), e[0] == "MESSAGE"))
        count = [0] * numberOfUsers
        next_online_time = [0] * numberOfUsers
        for event in events:
            cur_time = int(event[1])
            if event[0] == "MESSAGE":
                if event[2] == "ALL":
                    for i in range(numberOfUsers):
                        count[i] += 1
                elif event[2] == "HERE":
                    for i, t in enumerate(next_online_time):
                        if t <= cur_time:
                            count[i] += 1
                else:
                    for idx in event[2].split():
                        count[int(idx[2:])] += 1
            else:
                next_online_time[int(event[2])] = cur_time + 60
        return count

2025-12-11 14:20:50 +0300 MSK

Thu, 11 Dec 2025 14:20:50 +0300

Code

class Solution:
    def countCoveredBuildings(self, n: int, buildings: List[List[int]]) -> int:
        max_row = [0] * (n + 1)
        min_row = [n + 1] * (n + 1)
        max_col = [0] * (n + 1)
        min_col = [n + 1] * (n + 1)

        for p in buildings:
            x, y = p[0], p[1]
            max_row[y] = max(max_row[y], x)
            min_row[y] = min(min_row[y], x)
            max_col[x] = max(max_col[x], y)
            min_col[x] = min(min_col[x], y)

        res = 0
        for p in buildings:
            x, y = p[0], p[1]
            if (
                x > min_row[y]
                and x < max_row[y]
                and y > min_col[x]
                and y < max_col[x]
            ):
                res += 1

        return res

2025-12-10 20:14:13 +0300 MSK

Wed, 10 Dec 2025 20:14:13 +0300

Code

class Solution:
    def countPermutations(self, complexity: List[int]) -> int:
        n = len(complexity)
        for i in range(1, n):
            if complexity[i] <= complexity[0]:
                return 0

        ans, mod = 1, 10**9 + 7
        for i in range(2, n):
            ans = ans * i % mod
        return ans

2025-12-09 20:31:56 +0300 MSK

Tue, 09 Dec 2025 20:31:56 +0300

Code

class Solution:
    def specialTriplets(self, nums: List[int]) -> int:
        MOD = 10**9 + 7
        pos = defaultdict(list)

        for i, v in enumerate(nums):
            pos[v].append(i)

        def upper_bound(arr, i):
            l, r = 0, len(arr) - 1
            while l < r:
                mid = l + ((r - l + 1) >> 1)
                if i >= arr[mid]:
                    l = mid
                else:
                    r = mid - 1
            return l + 1, len(arr) - 1 - l

        ans = 0
        for i in range(1, len(nums) - 1):
            target = nums[i] * 2
            if target in pos and len(pos[target]) > 1 and pos[target][0] < i:
                l, r = upper_bound(pos[target], i)
                if nums[i] == 0:
                    l -= 1
                ans = (ans + l * r) % MOD

        return ans

2025-12-08 20:20:12 +0300 MSK

Mon, 08 Dec 2025 20:20:12 +0300

Code

class Solution:
    def countTriples(self, n: int) -> int:
        res = 0
        for a in range(1, n):
            for b in range(a + 1, n):
                c = math.sqrt(a * a + b * b)
                if c % 1 == 0 and c <= n:
                    res += 2
        return res

2025-12-07 19:27:13 +0300 MSK

Sun, 07 Dec 2025 19:27:13 +0300

Code


func countOdds(low int, high int) int {
	low_even, high_even, half := (low&1) == 0, (high&1) == 0, (high-low)/2
	if low_even && high_even  {
		return half
	}
	return half + 1
}

2025-12-06 19:08:58 +0300 MSK

Sat, 06 Dec 2025 19:08:58 +0300

Code

class Solution:
    def countPartitions(self, nums: List[int]) -> int:
        sm, n = [0] * len(nums), len(nums)
        sm[0] = nums[0]
        for i in range(n):
            sm[i] = sm[i - 1] + nums[i]
        res = 0
        for i in range(n - 1):
            left = sm[i]
            right = sm[-1] - left
            res += abs(right - left) % 2 == 0
        return res

2025-12-06 19:07:24 +0300 MSK

Sat, 06 Dec 2025 19:07:24 +0300

Code

class Solution:
    def countPartitions(self, nums: List[int], k: int) -> int:
        n = len(nums)
        mod = 10**9 + 7
        dp = [0] * (n + 1)
        prefix = [0] * (n + 1)
        min_q = deque()
        max_q = deque()

        dp[0] = 1
        prefix[0] = 1
        j = 0

        for i in range(n):
            # maintain the maximum value queue
            while max_q and nums[max_q[-1]] <= nums[i]:
                max_q.pop()
            max_q.append(i)

            # maintain the minimum value queue
            while min_q and nums[min_q[-1]] >= nums[i]:
                min_q.pop()
            min_q.append(i)

            # adjust window
            while max_q and min_q and nums[max_q[0]] - nums[min_q[0]] > k:
                if max_q[0] == j:
                    max_q.popleft()
                if min_q[0] == j:
                    min_q.popleft()
                j += 1

            if j > 0:
                dp[i + 1] = (prefix[i] - prefix[j - 1] + mod) % mod
            else:
                dp[i + 1] = prefix[i] % mod
            prefix[i + 1] = (prefix[i] + dp[i + 1]) % mod

        return dp[n]

2025-12-04 19:31:16 +0300 MSK

Thu, 04 Dec 2025 19:31:16 +0300

Code

class Solution:
    def countCollisions(self, directions: str) -> int:
        dirs = directions.lstrip("L").rstrip("R")
        return len(dirs) - dirs.count("S")

2025-12-03 21:01:12 +0300 MSK

Wed, 03 Dec 2025 21:01:12 +0300

Code

class Solution:
    def countTrapezoids(self, points: List[List[int]]) -> int:
        n = len(points)
        inf = 10**9 + 7
        slope_to_intercept = defaultdict(list)
        mid_to_slope = defaultdict(list)
        ans = 0

        for i in range(n):
            x1, y1 = points[i]
            for j in range(i + 1, n):
                x2, y2 = points[j]
                dx = x1 - x2
                dy = y1 - y2

                if x2 == x1:
                    k = inf
                    b = x1
                else:
                    k = (y2 - y1) / (x2 - x1)
                    b = (y1 * dx - x1 * dy) / dx

                mid = (x1 + x2) * 10000 + (y1 + y2)
                slope_to_intercept[k].append(b)
                mid_to_slope[mid].append(k)

        for sti in slope_to_intercept.values():
            if len(sti) == 1:
                continue

            cnt = defaultdict(int)
            for b_val in sti:
                cnt[b_val] += 1

            total_sum = 0
            for count in cnt.values():
                ans += total_sum * count
                total_sum += count

        for mts in mid_to_slope.values():
            if len(mts) == 1:
                continue

            cnt = defaultdict(int)
            for k_val in mts:
                cnt[k_val] += 1

            total_sum = 0
            for count in cnt.values():
                ans -= total_sum * count
                total_sum += count

        return ans

2025-12-02 19:36:01 +0300 MSK

Tue, 02 Dec 2025 19:36:01 +0300

Code

class Solution:
    def countTrapezoids(self, points: List[List[int]]) -> int:
        point_num = defaultdict(int)
        mod = 10**9 + 7
        ans, total_sum = 0, 0
        for point in points:
            point_num[point[1]] += 1
        for p_num in point_num.values():
            edge = p_num * (p_num - 1) // 2
            ans = (ans + edge * total_sum) % mod
            total_sum = (total_sum + edge) % mod
        return ans

2025-12-01 19:36:43 +0300 MSK

Mon, 01 Dec 2025 19:36:43 +0300

Code

class Solution:
    # n = 2, batteries = [3,3,3], Output: 4
    # n = 2, batteries = [1,1,1,1], Output: 2
    def maxRunTime(self, n: int, batteries: List[int]) -> int:
        length = len(batteries)

        if length < n:
            return 0
        
        if length == n:
            return min(batteries)

        batteries.sort()
        extra = sum(batteries[:-n])
        live = batteries[-n:]

        
        # We increase the total running time using 'extra' by increasing 
        # the running time of the computer with the smallest battery.
        for i in range(n - 1):
            # If the target running time is between live[i] and live[i + 1].
            if extra // (i + 1) < live[i + 1] - live[i]:
                return live[i] + extra // (i + 1)
            
            # Reduce 'extra' by the total power used.
            extra -= (i + 1) * (live[i + 1] - live[i])
        
        # If there is power left, we can increase the running time 
        # of all computers.
        return live[-1] + extra // n

2025-11-30 20:53:29 +0300 MSK

Sun, 30 Nov 2025 20:53:29 +0300

Code

class Solution:
    def minSubarray(self, nums: List[int], p: int) -> int:
        n = len(nums)
        total_sum = 0

        # Step 1: Calculate total sum and target remainder
        for num in nums:
            total_sum = (total_sum + num) % p

        target = total_sum % p
        if target == 0:
            return 0  # The array is already divisible by p

        # Step 2: Use a dict to track prefix sum mod p
        mod_map = {
            0: -1
        }  # To handle the case where the whole prefix is the answer
        current_sum = 0
        min_len = n

        # Step 3: Iterate over the array
        for i in range(n):
            current_sum = (current_sum + nums[i]) % p

            # Calculate what we need to remove
            needed = (current_sum - target + p) % p

            # If we have seen the needed remainder, we can consider this subarray
            if needed in mod_map:
                min_len = min(min_len, i - mod_map[needed])

            # Store the current remainder and index
            mod_map[current_sum] = i

        # Step 4: Return result
        return -1 if min_len == n else min_len

2025-11-29 21:07:28 +0300 MSK

Sat, 29 Nov 2025 21:07:28 +0300

Code

class Solution:
    def minOperations(self, nums: List[int], k: int) -> int:
        return sum(nums) % k

2025-11-28 20:52:48 +0300 MSK

Fri, 28 Nov 2025 20:52:48 +0300

Code

class Solution:
    def maxKDivisibleComponents(
        self, n: int, edges: List[List[int]], values: List[int], k: int
    ) -> int:
        if n < 2:
            return 1
        component_count = 0
        graph = defaultdict(list)
        in_degree = [0 for _ in range(n)]

        # Build the graph and calculate in-degrees
        for node1, node2 in edges:
            graph[node1].append(node2)
            graph[node2].append(node1)
            in_degree[node1] += 1
            in_degree[node2] += 1

        # Initialize the queue with nodes having in-degree of 1 (leaf nodes)
        queue = deque(node for node in range(n) if in_degree[node] == 1)

        while queue:
            current_node = queue.popleft()
            in_degree[current_node] -= 1
            add_value = 0

            # Check if the current node's value is divisible by k
            if values[current_node] % k == 0:
                component_count += 1
            else:
                add_value = values[current_node]

            # Propagate the value to the neighbor nodes
            for neighbor_node in graph[current_node]:
                if in_degree[neighbor_node] == 0:
                    continue
                in_degree[neighbor_node] -= 1
                values[neighbor_node] += add_value

                # If the neighbor node's in-degree becomes 1, add it to the queue
                if in_degree[neighbor_node] == 1:
                    queue.append(neighbor_node)

        return component_count

2025-11-27 17:52:11 +0300 MSK

Thu, 27 Nov 2025 17:52:11 +0300

Code

class Solution:
    def maxSubarraySum(self, nums: List[int], k: int) -> int:
        n = len(nums)
        prefixSum = 0
        maxSum = -sys.maxsize
        kSum = [sys.maxsize // 2] * k
        kSum[k - 1] = 0
        for i in range(n):
            prefixSum += nums[i]
            maxSum = max(maxSum, prefixSum - kSum[i % k])
            kSum[i % k] = min(kSum[i % k], prefixSum)
        return maxSum

2025-11-26 18:06:00 +0300 MSK

Wed, 26 Nov 2025 18:06:00 +0300

Code

class Solution:
    def numberOfPaths(self, grid: List[List[int]], k: int) -> int:
        MOD = 10**9 + 7
        m, n = len(grid), len(grid[0])

        dp = [[[0] * k for _ in range(n + 1)] for _ in range(m + 1)]

        for i in range(1, m + 1):
            for j in range(1, n + 1):
                if i == 1 and j == 1:
                    dp[i][j][grid[0][0] % k] = 1
                    continue

                value = grid[i - 1][j - 1] % k
                for r in range(k):
                    prev_mod = (r - value + k) % k
                    dp[i][j][r] = (
                        dp[i - 1][j][prev_mod] + dp[i][j - 1][prev_mod]
                    ) % MOD

        return dp[m][n][0]

2025-11-25 19:49:04 +0300 MSK

Tue, 25 Nov 2025 19:49:04 +0300

Code

class Solution:
    def smallestRepunitDivByK(self, K: int) -> int:
        remainder = 0
        for length_N in range(1,K+1):
            remainder = (remainder*10+1) % K
            if remainder == 0:
                return length_N
        return -1

2025-11-24 18:58:12 +0300 MSK

Mon, 24 Nov 2025 18:58:12 +0300

Code

class Solution:
    def prefixesDivBy5(self, nums: List[int]) -> List[bool]:
        cur = 0
        for i in range(len(nums)):
            cur <<= 1
            cur |= nums[i]
            nums[i] = cur % 5 == 0
        return nums

2025-11-23 18:20:29 +0300 MSK

Sun, 23 Nov 2025 18:20:29 +0300

Code

class Solution:
    def maxSumDivThree(self, nums: List[int]) -> int:
        f = [0, -float("inf"), -float("inf")]
        for num in nums:
            g = f[:]
            for i in range(3):
                g[(i + num % 3) % 3] = max(g[(i + num % 3) % 3], f[i] + num)
            f = g
        return f[0]

2025-11-22 17:51:32 +0300 MSK

Sat, 22 Nov 2025 17:51:32 +0300

Code

class Solution:
    def minimumOperations(self, nums: List[int]) -> int:
        res = 0
        for i in range(len(nums)):
            res += nums[i] % 3 != 0
        return res

2025-11-21 17:40:54 +0300 MSK

Fri, 21 Nov 2025 17:40:54 +0300

Code

class Solution {
public:
    int countPalindromicSubsequence(string s) {
        unordered_set<char> letters;
        for (char c : s) {
            letters.insert(c);
        }
        int ans = 0;
        for (char letter : letters) {
            int i = -1;
            int j = 0;
            for (int k = 0; k < s.size(); k++) {
                if (s[k] == letter) {
                    if (i == -1) {
                        i = k;
                    }
                    
                    j = k;
                }
            }
            unordered_set<char> between;
            for (int k = i + 1; k < j; k++) {
                between.insert(s[k]);
            }
            
            ans += between.size();
        }
        return ans;
    }
};

2025-11-20 18:30:09 +0300 MSK

Thu, 20 Nov 2025 18:30:09 +0300

Code

class Solution(object):
    def intersectionSizeTwo(self, intervals):
        intervals.sort(key =lambda val: (val[0], -val[1]))
        todo = [2] * len(intervals)
        ans = 0
        while intervals:
            (s, e), t = intervals.pop(), todo.pop()
            for p in range(s, s+t):
                for i, (s0, e0) in enumerate(intervals):
                    if todo[i] and p <= e0:
                        todo[i] -= 1
                ans += 1
        return ans

2025-11-19 18:01:12 +0300 MSK

Wed, 19 Nov 2025 18:01:12 +0300

Code

class Solution:
    def findFinalValue(self, nums: List[int], original: int) -> int:
        nums.sort()
        length = len(nums)
        left, right = 0, length - 1
        while left <= right:
            i = left + (right - left) // 2
            val = nums[i]
            if val > original:
                right = i - 1
            elif val == original:
                original *= 2
                left = i + 1
                right = length - 1
            else:
                left = i + 1
        return original

2025-11-18 19:16:52 +0300 MSK

Tue, 18 Nov 2025 19:16:52 +0300

Code

class Solution(object):
    def isOneBitCharacter(self, bits):
        i = 0
        while i < len(bits) - 1:
            i += bits[i] + 1
        return i == len(bits) - 1

2025-11-17 18:59:11 +0300 MSK

Mon, 17 Nov 2025 18:59:11 +0300

Code

class Solution:
    def kLengthApart(self, nums: List[int], k: int) -> bool:
        prev = -k - 1
        for i, num in enumerate(nums):
            if num == 0:
                continue
            if i - prev - 1 >= k:
                prev = i
            else:
                return False
        return True

2025-11-16 18:07:29 +0300 MSK

Sun, 16 Nov 2025 18:07:29 +0300

Code

class Solution:
    def numSub(self, s: str) -> int:
        total, consecutive = 0, 0
        length = len(s)
        for i in range(length):
            if s[i] == "0":
                total += consecutive * (consecutive + 1) // 2
                consecutive = 0
            else:
                consecutive += 1

        total += consecutive * (consecutive + 1) // 2
        total %= 10**9 + 7
        return total

2025-11-15 18:41:02 +0300 MSK

Sat, 15 Nov 2025 18:41:02 +0300

Code

class Solution:
    def numberOfSubstrings(self, s: str) -> int:
        n = len(s)
        pre = [-1] * (n + 1)
        for i in range(n):
            if i == 0 or s[i - 1] == "0":
                pre[i + 1] = i
            else:
                pre[i + 1] = pre[i]

        res = 0
        for i in range(1, n + 1):
            cnt0 = 1 if s[i - 1] == "0" else 0
            j = i
            while j > 0 and cnt0 * cnt0 <= n:
                cnt1 = (i - pre[j]) - cnt0
                if cnt0 * cnt0 <= cnt1:
                    res += min(j - pre[j], cnt1 - cnt0 * cnt0 + 1)
                j = pre[j]
                cnt0 += 1
        return res

2025-11-14 15:39:54 +0300 MSK

Fri, 14 Nov 2025 15:39:54 +0300

Code

class Solution:
    def maxOperations(self, s: str) -> int:
        count_one = 0
        ans = 0
        i = 0
        while i < len(s):
            if s[i] == "0":
                while i + 1 < len(s) and s[i + 1] == "0":
                    i += 1
                ans += count_one
            else:
                count_one += 1
            i += 1
        return ans

2025-11-14 15:39:21 +0300 MSK

Fri, 14 Nov 2025 15:39:21 +0300

Code

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        n = len(nums)
        num1 = 0
        g = 0

        for x in nums:
            if x == 1:
                num1 += 1
            g = gcd(g, x)

        if num1 > 0:
            return n - num1
        if g > 1:
            return -1

        min_len = n
        for i in range(n):
            g = 0
            for j in range(i, n):
                g = gcd(g, nums[j])
                if g == 1:
                    min_len = min(min_len, j - i + 1)
                    break

        return min_len + n - 2

2025-11-14 15:38:45 +0300 MSK

Fri, 14 Nov 2025 15:38:45 +0300

Code

class Solution:
    def rangeAddQueries(
        self, n: int, queries: List[List[int]]
    ) -> List[List[int]]:
        diff = [[0] * (n + 1) for _ in range(n + 1)]
        for row1, col1, row2, col2 in queries:
            diff[row1][col1] += 1
            diff[row2 + 1][col1] -= 1
            diff[row1][col2 + 1] -= 1
            diff[row2 + 1][col2 + 1] += 1

        mat = [[0] * n for _ in range(n)]
        for i in range(n):
            for j in range(n):
                x1 = 0 if i == 0 else mat[i - 1][j]
                x2 = 0 if j == 0 else mat[i][j - 1]
                x3 = 0 if i == 0 or j == 0 else mat[i - 1][j - 1]
                mat[i][j] = diff[i][j] + x1 + x2 - x3
        return mat

2025-11-11 19:43:26 +0300 MSK

Tue, 11 Nov 2025 19:43:26 +0300

Code

class Solution:
    def findMaxForm(self, strs: List[str], m: int, n: int) -> int:
        dp = {(0, 0): 0}

        for s in strs:
            ones = 0
            zeroes = 0
            for ch in s:
                if ch == "0":
                    zeroes += 1
                else:
                    ones += 1
            newdp = {}

            for k, v in dp.items():
                prevzeroes, prevones = k
                newzeroes, newones = prevzeroes + zeroes, prevones + ones
                if newzeroes <= m and newones <= n:
                    if (newzeroes, newones) not in dp:
                        newdp[(newzeroes, newones)] = v + 1

                    elif dp[(newzeroes, newones)] < v + 1:
                        newdp[(newzeroes, newones)] = v + 1
            dp.update(newdp)
        return max(dp.values())

2025-11-10 19:49:56 +0300 MSK

Mon, 10 Nov 2025 19:49:56 +0300

Code

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        s = []
        res = 0
        for a in nums:
            while s and s[-1] > a:
                s.pop()
            if a == 0:
                continue
            if not s or s[-1] < a:
                res += 1
                s.append(a)
        return res

2025-11-09 17:05:22 +0300 MSK

Sun, 09 Nov 2025 17:05:22 +0300

Code

class Solution:
    def countOperations(self, num1: int, num2: int) -> int:
        count = 0
        while num1 > 0 and num2 > 0:
            if num1 >= num2:
                count += num1 // num2
                num1 %= num2
            else:
                count += num2 // num1
                num2 %= num1
        return count

2025-11-08 22:09:46 +0300 MSK

Sat, 08 Nov 2025 22:09:46 +0300

Code

class Solution:
    def minimumOneBitOperations(self, n: int) -> int:
        if n == 0:
            return 0
        
        k = 0
        curr = 1
        while (curr * 2) <= n:
            curr *= 2
            k += 1

        return 2 ** (k + 1) - 1 - self.minimumOneBitOperations(n ^ curr)

2025-11-07 20:28:33 +0300 MSK

Fri, 07 Nov 2025 20:28:33 +0300

Code

class Solution:
    def maxPower(self, stations: List[int], r: int, k: int) -> int:
        n = len(stations)
        cnt = [0] * (n + 1)

        for i in range(n):
            left = max(0, i - r)
            right = min(n, i + r + 1)
            cnt[left] += stations[i]
            cnt[right] -= stations[i]

        def check(val: int) -> bool:
            diff = cnt.copy()
            total = 0
            remaining = k

            for i in range(n):
                total += diff[i]
                if total < val:
                    add = val - total
                    if remaining < add:
                        return False
                    remaining -= add
                    end = min(n, i + 2 * r + 1)
                    diff[end] -= add
                    total += add
            return True

        lo, hi = min(stations), sum(stations) + k
        res = 0
        while lo <= hi:
            mid = (lo + hi) // 2
            if check(mid):
                res = mid
                lo = mid + 1
            else:
                hi = mid - 1
        return res

2025-11-06 20:39:45 +0300 MSK

Thu, 06 Nov 2025 20:39:45 +0300

Code

class DSU:
    def __init__(self, size):
        self.parent = list(range(size))

    def find(self, x):
        if self.parent[x] != x:
            self.parent[x] = self.find(self.parent[x])
        return self.parent[x]

    def join(self, u, v):
        self.parent[self.find(v)] = self.find(u)


class Solution:
    def processQueries(
        self, c: int, connections: List[List[int]], queries: List[List[int]]
    ) -> List[int]:
        dsu = DSU(c + 1)
        for p in connections:
            dsu.join(p[0], p[1])

        online = [True] * (c + 1)
        offline_counts = [0] * (c + 1)
        minimum_online_stations = {}

        for q in queries:
            op, x = q[0], q[1]
            if op == 2:
                online[x] = False
                offline_counts[x] += 1

        for i in range(1, c + 1):
            root = dsu.find(i)
            if root not in minimum_online_stations:
                minimum_online_stations[root] = -1

            station = minimum_online_stations[root]
            if online[i]:
                if station == -1 or station > i:
                    minimum_online_stations[root] = i

        ans = []
        for i in range(len(queries) - 1, -1, -1):
            op, x = queries[i][0], queries[i][1]
            root = dsu.find(x)
            station = minimum_online_stations[root]

            if op == 1:
                if online[x]:
                    ans.append(x)
                else:
                    ans.append(station)

            if op == 2:
                if offline_counts[x] > 1:
                    offline_counts[x] -= 1
                else:
                    online[x] = True
                    if station == -1 or station > x:
                        minimum_online_stations[root] = x

        return ans[::-1]

2025-11-05 20:31:23 +0300 MSK

Wed, 05 Nov 2025 20:31:23 +0300

Code

class Helper:
    def __init__(self, x):
        self.x = x
        self.result = 0
        self.large = SortedList()
        self.small = SortedList()
        self.occ = defaultdict(int)

    def insert(self, num):
        if self.occ[num] > 0:
            self.internal_remove((self.occ[num], num))
        self.occ[num] += 1
        self.internal_insert((self.occ[num], num))

    def remove(self, num):
        self.internal_remove((self.occ[num], num))
        self.occ[num] -= 1
        if self.occ[num] > 0:
            self.internal_insert((self.occ[num], num))

    def get(self):
        return self.result

    def internal_insert(self, p):
        if len(self.large) < self.x or p > self.large[0]:
            self.result += p[0] * p[1]
            self.large.add(p)
            if len(self.large) > self.x:
                to_remove = self.large[0]
                self.result -= to_remove[0] * to_remove[1]
                self.large.remove(to_remove)
                self.small.add(to_remove)
        else:
            self.small.add(p)

    def internal_remove(self, p):
        if p >= self.large[0]:
            self.result -= p[0] * p[1]
            self.large.remove(p)
            if self.small:
                to_add = self.small[-1]
                self.result += to_add[0] * to_add[1]
                self.small.remove(to_add)
                self.large.add(to_add)
        else:
            self.small.remove(p)


class Solution:
    def findXSum(self, nums, k, x):
        helper = Helper(x)
        ans = []

        for i in range(len(nums)):
            helper.insert(nums[i])
            if i >= k:
                helper.remove(nums[i - k])
            if i >= k - 1:
                ans.append(helper.get())

        return ans

2025-11-04 17:04:32 +0300 MSK

Tue, 04 Nov 2025 17:04:32 +0300

Code

class Solution:
    def findXSum(self, nums: List[int], k: int, x: int) -> List[int]:

        def do_sum (idx: int)-> int:

            ctr = Counter(nums[idx:idx + k])
            most_freq = nlargest(x, ctr, key = lambda y: (ctr[y], y))

            return sum(map(lambda y: y * ctr[y], most_freq))


        return tuple(map(do_sum,range(len(nums)+1 - k)))

2025-11-03 17:26:21 +0300 MSK

Mon, 03 Nov 2025 17:26:21 +0300

Code

class Solution:
    def minCost(self, colors: str, neededTime: list[int]) -> int:
        total_time, curr_max_time = 0, 0

        for i in range(len(colors)):
            if i > 0 and colors[i] != colors[i - 1]:
                curr_max_time = 0
            total_time += min(curr_max_time, neededTime[i])
            curr_max_time = max(curr_max_time, neededTime[i])

        return total_time

2025-11-02 19:37:10 +0300 MSK

Sun, 02 Nov 2025 19:37:10 +0300

Code

class Solution:
    def modifiedList(
        self, nums: List[int], head: Optional[ListNode]
    ) -> Optional[ListNode]:
        # Create a set for efficient lookup of values in nums
        values_to_remove = set(nums)

        # Handle the case where the head node needs to be removed
        while head and head.val in values_to_remove:
            head = head.next

        # If the list is empty after removing head nodes, return None
        if not head:
            return None

        # Iterate through the list, removing nodes with values in the set
        current = head
        while current.next:
            if current.next.val in values_to_remove:
                # Skip the next node by updating the pointer
                current.next = current.next.next
            else:
                # Move to the next node
                current = current.next

        return head

2025-11-02 19:36:12 +0300 MSK

Sun, 02 Nov 2025 19:36:12 +0300

Code

class Solution:
    def modifiedList(
        self, nums: List[int], head: Optional[ListNode]
    ) -> Optional[ListNode]:
        # Create a set for efficient lookup of values in nums
        values_to_remove = set(nums)

        # Handle the case where the head node needs to be removed
        while head and head.val in values_to_remove:
            head = head.next

        # If the list is empty after removing head nodes, return None
        if not head:
            return None

        # Iterate through the list, removing nodes with values in the set
        current = head
        while current.next:
            if current.next.val in values_to_remove:
                # Skip the next node by updating the pointer
                current.next = current.next.next
            else:
                # Move to the next node
                current = current.next

        return head

2025-11-02 19:35:07 +0300 MSK

Sun, 02 Nov 2025 19:35:07 +0300

Code

class Solution:
    UNGUARDED = 0
    GUARDED = 1
    GUARD = 2
    WALL = 3

    # Depth-First Search to mark guarded cells
    def _recurse(
        self, row: int, col: int, grid: List[List[int]], direction: str
    ) -> None:
        if (
            row < 0
            or row >= len(grid)
            or col < 0
            or col >= len(grid[0])
            or grid[row][col] == self.GUARD
            or grid[row][col] == self.WALL
        ):
            return

        grid[row][col] = self.GUARDED  # Mark cell as guarded
        if direction == "U":
            self._recurse(row - 1, col, grid, "U")  # Up
        if direction == "D":
            self._recurse(row + 1, col, grid, "D")  # Down
        if direction == "L":
            self._recurse(row, col - 1, grid, "L")  # Left
        if direction == "R":
            self._recurse(row, col + 1, grid, "R")  # Right

    def countUnguarded(
        self, m: int, n: int, guards: List[List[int]], walls: List[List[int]]
    ) -> int:
        grid = [[self.UNGUARDED] * n for _ in range(m)]

        # Mark guards' positions
        for guard in guards:
            grid[guard[0]][guard[1]] = self.GUARD

        # Mark walls' positions
        for wall in walls:
            grid[wall[0]][wall[1]] = self.WALL

        # Mark cells as guarded by traversing from each guard
        for guard in guards:
            self._recurse(guard[0] - 1, guard[1], grid, "U")  # Up
            self._recurse(guard[0] + 1, guard[1], grid, "D")  # Down
            self._recurse(guard[0], guard[1] - 1, grid, "L")  # Left
            self._recurse(guard[0], guard[1] + 1, grid, "R")  # Right

        # Count unguarded cells
        count = sum(row.count(self.UNGUARDED) for row in grid)
        return count

2025-10-31 21:10:44 +0300 MSK

Fri, 31 Oct 2025 21:10:44 +0300

Code

class Solution:
    def getSneakyNumbers(self, nums: List[int]) -> List[int]:
        n = len(nums) - 2
        xor_all = 0
        for num in nums:
            xor_all ^= num
        for num in range(n):
            xor_all ^= num
        rightmost_bit = xor_all & -xor_all
        dup1, dup2 = 0, 0
        for num in nums:
            if num & rightmost_bit:
                dup1 ^= num
            else:
                dup2 ^= num
        for num in range(n):
            if num & rightmost_bit:
                dup1 ^= num
            else:
                dup2 ^= num
        return [dup1, dup2]

2025-10-30 20:34:31 +0300 MSK

Thu, 30 Oct 2025 20:34:31 +0300

Code

class Solution:
    def minNumberOperations(self, target: List[int]) -> int:
        n = len(target)
        ans = target[0]
        for i in range(1, n):
            ans += max(target[i] - target[i - 1], 0)
        return ans

2025-10-29 19:40:08 +0300 MSK

Wed, 29 Oct 2025 19:40:08 +0300

Code

class Solution:
    def smallestNumber(self, n: int) -> int:
        res = 0
        while n > 0:
            res = (res << 1) | 1
            n //= 2
        return res

2025-10-28 17:46:01 +0300 MSK

Tue, 28 Oct 2025 17:46:01 +0300

Code

class Solution:
    def scoreBalance(self, s: str) -> bool:
        right, left = 0, 0
        for char in s:
            right += ord(char) - ord('a') + 1
        for char in s:
            val = ord(char) - ord('a') + 1
            left += val
            right -= val
            if left == right:
                return True
            if left > right:
                return False
        return False

2025-10-28 17:19:30 +0300 MSK

Tue, 28 Oct 2025 17:19:30 +0300

Code

class Solution:
    def countValidSelections(self, nums: List[int]) -> int:
        n, res = len(nums), 0
        left, right = [0 for _ in range(n)], [0 for _ in range(n)]
        for i in range(1, n):
            left[i] = left[i - 1] + nums[i - 1]
            right[-i - 1] = right[-i] + nums[-i]
        for i, num in enumerate(nums):
            if num != 0: continue
            if left[i] == right[i]: res += 2
            if abs(left[i] - right[i]) == 1: res += 1
        return res

2025-10-27 20:43:34 +0300 MSK

Mon, 27 Oct 2025 20:43:34 +0300

Code

class Solution:
    def numberOfBeams(self, bank):
        ans, temp = 0, 0
        for s in bank:
            n = s.count('1')
            if n == 0:
                continue
            ans += temp * n
            temp = n
        return ans

2025-10-27 12:49:36 +0300 MSK

Mon, 27 Oct 2025 12:49:36 +0300

Code

class Bank:
    def __init__(self, balance: List[int]):
        self.balance = balance

    def transfer(self, account1: int, account2: int, money: int) -> bool:
        if (
            account1 > len(self.balance)
            or account2 > len(self.balance)
            or self.balance[account1 - 1] < money
        ):
            return False
        self.balance[account1 - 1] -= money
        self.balance[account2 - 1] += money
        return True

    def deposit(self, account: int, money: int) -> bool:
        if account > len(self.balance):
            return False
        self.balance[account - 1] += money
        return True

    def withdraw(self, account: int, money: int) -> bool:
        if account > len(self.balance) or self.balance[account - 1] < money:
            return False
        self.balance[account - 1] -= money
        return True

2025-10-27 12:48:19 +0300 MSK

Mon, 27 Oct 2025 12:48:19 +0300

Code

class Bank:
    def __init__(self, balance: List[int]):
        self.balance = balance

    def transfer(self, account1: int, account2: int, money: int) -> bool:
        if (
            account1 > len(self.balance)
            or account2 > len(self.balance)
            or self.balance[account1 - 1] < money
        ):
            return False
        self.balance[account1 - 1] -= money
        self.balance[account2 - 1] += money
        return True

    def deposit(self, account: int, money: int) -> bool:
        if account > len(self.balance):
            return False
        self.balance[account - 1] += money
        return True

    def withdraw(self, account: int, money: int) -> bool:
        if account > len(self.balance) or self.balance[account - 1] < money:
            return False
        self.balance[account - 1] -= money
        return True

2025-10-25 13:13:55 +0300 MSK

Sat, 25 Oct 2025 13:13:55 +0300

Code

class Solution {
public:
    int totalMoney(int n) {
        int ans {0};
        int monday {1};
        
        while (n > 0) {
            for (int day {0}; day < min(n, 7); ++day) {
                ans += monday + day;
            }
            n -= 7;
            ++monday;
        }
        
        return ans;
    }
};

2025-10-24 19:02:20 +0300 MSK

Fri, 24 Oct 2025 19:02:20 +0300

Code

class Solution:
    def nextBeautifulNumber(self, n: int) -> int:
        for i in range(n + 1, 1224445):
            count = Counter(str(i))
            if all(count[d] == int(d) for d in count):
                return i

2025-10-23 19:12:54 +0300 MSK

Thu, 23 Oct 2025 19:12:54 +0300

Code

class Solution:
    def hasSameDigits(self, s: str) -> bool:
        stack = list(map(int, s))
        stack.reverse()
        while len(stack) > 2:
            prev = stack.pop()
            for i in reversed(range(len(stack))):
                stack[i], prev = (prev + stack[i]) % 10, stack[i]
        return stack[0] == stack[1]

2025-10-22 16:36:23 +0300 MSK

Wed, 22 Oct 2025 16:36:23 +0300

Code

class Solution:
    def maxFrequency(self, nums: List[int], k: int, numOperations: int) -> int:
        nums.sort()
        ans = 0
        num_count = defaultdict(int)
        modes = set()

        def add_mode(value):
            modes.add(value)
            if value - k >= nums[0]:
                modes.add(value - k)
            if value + k <= nums[-1]:
                modes.add(value + k)

        last_num_index = 0
        for i in range(len(nums)):
            if nums[i] != nums[last_num_index]:
                num_count[nums[last_num_index]] = i - last_num_index
                ans = max(ans, i - last_num_index)
                add_mode(nums[last_num_index])
                last_num_index = i

        num_count[nums[last_num_index]] = len(nums) - last_num_index
        ans = max(ans, len(nums) - last_num_index)
        add_mode(nums[last_num_index])

        for mode in sorted(modes):
            l = bisect.bisect_left(nums, mode - k)
            r = bisect.bisect_right(nums, mode + k) - 1
            if mode in num_count:
                temp_ans = min(r - l + 1, num_count[mode] + numOperations)
            else:
                temp_ans = min(r - l + 1, numOperations)
            ans = max(ans, temp_ans)

        return ans

2025-10-21 20:51:47 +0300 MSK

Tue, 21 Oct 2025 20:51:47 +0300

Code

class Solution:
    def maxFrequency(self, nums: List[int], k: int, numOperations: int) -> int:
        nums.sort()
        ans = 0
        num_count = {}
        last_num_index = 0
        for i in range(len(nums)):
            if nums[i] != nums[last_num_index]:
                num_count[nums[last_num_index]] = i - last_num_index
                ans = max(ans, i - last_num_index)
                last_num_index = i

        num_count[nums[last_num_index]] = len(nums) - last_num_index
        ans = max(ans, len(nums) - last_num_index)

        for i in range(nums[0], nums[-1] + 1):
            l = bisect.bisect_left(nums, i - k)
            r = bisect.bisect_right(nums, i + k) - 1
            if i in num_count:
                temp_ans = min(r - l + 1, num_count[i] + numOperations)
            else:
                temp_ans = min(r - l + 1, numOperations)
            ans = max(ans, temp_ans)

        return ans

2025-10-20 21:06:38 +0300 MSK

Mon, 20 Oct 2025 21:06:38 +0300

Code

class Solution:
    def finalValueAfterOperations(self, operations: List[str]) -> int:
        res = 0
        for op in operations:
            if op.startswith("++") or op.endswith("++"):
                res += 1
            else:
                res -= 1
        return res

2025-10-19 18:18:20 +0300 MSK

Sun, 19 Oct 2025 18:18:20 +0300

Code

class Solution:
    def findLexSmallestString(self, s: str, a: int, b: int) -> str:
        n = len(s)
        vis = [False] * n
        res = s
        # double the length of s for convenience in extracting the rotated string t
        s = s + s
        i = 0
        while not vis[i]:
            vis[i] = True
            for j in range(10):
                k_limit = 0 if b % 2 == 0 else 9
                for k in range(k_limit + 1):
                    # before each accumulation, re-truncate t
                    t = list(s[i : i + n])
                    for p in range(1, n, 2):
                        t[p] = str((int(t[p]) + j * a) % 10)
                    for p in range(0, n, 2):
                        t[p] = str((int(t[p]) + k * a) % 10)
                    t_str = "".join(t)
                    if t_str < res:
                        res = t_str
            i = (i + b) % n
        return res

2025-10-18 20:20:30 +0300 MSK

Sat, 18 Oct 2025 20:20:30 +0300

Code

class Solution:
    def maxDistinctElements(self, nums: List[int], k: int) -> int:
        nums.sort()

        cnt = 0
        prev = -math.inf

        for num in nums:
            curr = min(max(num - k, prev + 1), num + k)
            if curr > prev:
                cnt += 1
                prev = curr

        return cnt

2025-10-17 20:03:35 +0300 MSK

Fri, 17 Oct 2025 20:03:35 +0300

Code

class Solution:
    def maxPartitionsAfterOperations(self, s: str, k: int) -> int:
        n = len(s)
        left = [[0] * 3 for _ in range(n)]
        right = [[0] * 3 for _ in range(n)]

        num, mask, count = 0, 0, 0
        for i in range(n - 1):
            binary = 1 << (ord(s[i]) - ord("a"))
            if not (mask & binary):
                count += 1
                if count <= k:
                    mask |= binary
                else:
                    num += 1
                    mask = binary
                    count = 1
            left[i + 1][0] = num
            left[i + 1][1] = mask
            left[i + 1][2] = count

        num, mask, count = 0, 0, 0
        for i in range(n - 1, 0, -1):
            binary = 1 << (ord(s[i]) - ord("a"))
            if not (mask & binary):
                count += 1
                if count <= k:
                    mask |= binary
                else:
                    num += 1
                    mask = binary
                    count = 1
            right[i - 1][0] = num
            right[i - 1][1] = mask
            right[i - 1][2] = count

        max_val = 0
        for i in range(n):
            seg = left[i][0] + right[i][0] + 2
            tot_mask = left[i][1] | right[i][1]
            tot_count = bin(tot_mask).count("1")
            if left[i][2] == k and right[i][2] == k and tot_count < 26:
                seg += 1
            elif min(tot_count + 1, 26) <= k:
                seg -= 1
            max_val = max(max_val, seg)
        return max_val

2025-10-16 21:12:42 +0300 MSK

Thu, 16 Oct 2025 21:12:42 +0300

Code

class Solution:
    def findSmallestInteger(self, nums: List[int], value: int) -> int:
        mp = Counter(x % value for x in nums)
        mex = 0
        while mp[mex % value] > 0:
            mp[mex % value] -= 1
            mex += 1
        return mex

2025-10-15 21:05:53 +0300 MSK

Wed, 15 Oct 2025 21:05:53 +0300

Code

class Solution:
    def maxIncreasingSubarrays(self, nums: List[int]) -> int:
        n = len(nums)
        cnt, precnt, ans = 1, 0, 0
        for i in range(1, n):
            if nums[i] > nums[i - 1]:
                cnt += 1
            else:
                precnt, cnt = cnt, 1
            ans = max(ans, min(precnt, cnt))
            ans = max(ans, cnt // 2)
        return ans

2025-10-14 21:36:00 +0300 MSK

Tue, 14 Oct 2025 21:36:00 +0300

Code

class Solution:
    def hasIncreasingSubarrays(self, nums: List[int], k: int) -> bool:
        n = len(nums)
        cnt = 1
        prv_cnt = 0
        for i in range(1, n):
            cur, prv = nums[i], nums[i - 1]
            if cur > prv:
                cnt += 1
            else:
                prv_cnt, cnt = cnt, 1
            if cnt >= 2 * k or prv_cnt >= k and cnt >= k:
                return True
        return False

2025-10-13 21:06:28 +0300 MSK

Mon, 13 Oct 2025 21:06:28 +0300

Code

class Solution:
    def removeAnagrams(self, words: List[str]) -> List[str]:
        freqs1, freqs2 = bytearray(26), bytearray(26)
        res = []
        for i, word in enumerate(words):
            for i in range(26):
                freqs2[i] = 0
            for char in word:
                freqs2[ord(char) - 97] += 1
            if i != 0 and freqs1 == freqs2:
                continue
            freqs1, freqs2 = freqs2, freqs1
            res.append(word)
        return res

2025-10-12 18:25:03 +0300 MSK

Sun, 12 Oct 2025 18:25:03 +0300

Code

class Solution:
    def quickmul(self, x: int, y: int, mod: int) -> int:
        res, cur = 1, x % mod
        while y:
            if y & 1:
                res = res * cur % mod
            y >>= 1
            cur = cur * cur % mod
        return res

    def magicalSum(self, m: int, k: int, nums: List[int]) -> int:
        n = len(nums)
        mod = 10**9 + 7

        fac = [1] * (m + 1)
        for i in range(1, m + 1):
            fac[i] = fac[i - 1] * i % mod

        ifac = [1] * (m + 1)
        for i in range(2, m + 1):
            ifac[i] = self.quickmul(i, mod - 2, mod)
        for i in range(2, m + 1):
            ifac[i] = ifac[i - 1] * ifac[i] % mod

        numsPower = [[1] * (m + 1) for _ in range(n)]
        for i in range(n):
            for j in range(1, m + 1):
                numsPower[i][j] = numsPower[i][j - 1] * nums[i] % mod

        f = [
            [[[0] * (k + 1) for _ in range(m * 2 + 1)] for _ in range(m + 1)]
            for _ in range(n)
        ]

        for j in range(m + 1):
            f[0][j][j][0] = numsPower[0][j] * ifac[j] % mod

        for i in range(n - 1):
            for j in range(m + 1):
                for p in range(m * 2 + 1):
                    for q in range(k + 1):
                        if f[i][j][p][q] == 0:
                            continue
                        q2 = (p % 2) + q
                        if q2 > k:
                            break
                        for r in range(m - j + 1):
                            p2 = (p // 2) + r
                            if p2 > m * 2:
                                continue
                            f[i + 1][j + r][p2][q2] = (
                                f[i + 1][j + r][p2][q2]
                                + f[i][j][p][q]
                                * numsPower[i + 1][r]
                                % mod
                                * ifac[r]
                                % mod
                            ) % mod

        res = 0
        for p in range(m * 2 + 1):
            for q in range(k + 1):
                if bin(p).count("1") + q == k:
                    res = (res + f[n - 1][m][p][q] * fac[m] % mod) % mod
        return res

2025-10-11 21:08:12 +0300 MSK

Sat, 11 Oct 2025 21:08:12 +0300

Code

class Solution:
    def maximumTotalDamage(self, power):
        count = Counter(power)
        vec = [(-(10**9), 0)]
        for k in sorted(count.keys()):
            vec.append((k, count[k]))
        n = len(vec)
        f = [0] * n
        mx = 0
        j = 1
        for i in range(1, n):
            while j < i and vec[j][0] < vec[i][0] - 2:
                mx = max(mx, f[j])
                j += 1
            f[i] = mx + vec[i][0] * vec[i][1]
        return max(f)

2025-10-10 19:31:54 +0300 MSK

Fri, 10 Oct 2025 19:31:54 +0300

Code

class Solution:
    def maximumEnergy(self, energy: List[int], k: int) -> int:
        n = len(energy)
        ans = -inf

        for i in range(n - k, n):
            total = 0
            j = i
            while j >= 0:
                total += energy[j]
                ans = max(ans, total)
                j -= k

        return ans

2025-10-09 21:03:44 +0300 MSK

Thu, 09 Oct 2025 21:03:44 +0300

Code

class Solution:
    def minTime(self, skill: List[int], mana: List[int]) -> int:
        n, m = len(skill), len(mana)
        times = [0] * n
        for j in range(m):
            cur_time = 0
            for i in range(n):
                cur_time = max(cur_time, times[i]) + skill[i] * mana[j]
            times[n - 1] = cur_time
            for i in range(n - 2, -1, -1):
                times[i] = times[i + 1] - skill[i + 1] * mana[j]
        return times[n - 1]

2025-10-08 20:28:20 +0300 MSK

Wed, 08 Oct 2025 20:28:20 +0300

Code

class Solution:
    def successfulPairs(self, spells: List[int], potions: List[int], success: int) -> List[int]:
        freq=Counter(potions)
        pMax=max(freq)
        F=[0]*(1+pMax)
        for p, f in freq.items():
            F[p]=f
        freq=list(accumulate(F))
        n, m=len(spells), len(potions)
        res=[0]*n
        for i, x in enumerate(spells):
            k=(success+x-1)//x
            if k<=pMax:
                res[i]=m-freq[k-1]
        return res

2025-10-07 19:48:34 +0300 MSK

Tue, 07 Oct 2025 19:48:34 +0300

Code

from sortedcontainers import SortedList


class Solution:
    def avoidFlood(self, rains: List[int]) -> List[int]:
        ans = [1] * len(rains)
        st = SortedList()
        mp = {}
        for i, rain in enumerate(rains):
            if rain == 0:
                st.add(i)
            else:
                ans[i] = -1
                if rain in mp:
                    it = st.bisect(mp[rain])
                    if it == len(st):
                        return []
                    ans[st[it]] = rain
                    st.discard(st[it])
                mp[rain] = i
        return ans

2025-10-06 20:51:45 +0300 MSK

Mon, 06 Oct 2025 20:51:45 +0300

Code

class Solution:
    def swimInWater(self, grid: List[List[int]]) -> int:
        m, n = len(grid), len(grid[0])
        pq = [(grid[0][0], 0, 0)]
        directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]
        seen = set()
        
        while pq:
            max_d, r, c = heapq.heappop(pq)
            if (r, c) in seen: continue
            seen.add((r, c))
            if r == m-1 and c == n-1:
                return max_d
            
            for dr, dc in directions:
                nr, nc = r + dr, c + dc
                if 0 <= nr < m and 0 <= nc < n and (nr, nc) not in seen:
                    new_d = max(max_d, grid[nr][nc])
                    heapq.heappush(pq, (new_d, nr, nc))
        
        return -1

2025-10-05 19:06:52 +0300 MSK

Sun, 05 Oct 2025 19:06:52 +0300

Code

class Solution:
    def pacificAtlantic(self, heights: List[List[int]]) -> List[List[int]]:
        def dfs(cell, visited):
            if cell in visited:
                return
            visited.add(cell)
            r, c = cell
            for nr, nc in [(r-1, c), (r+1, c), (r, c-1), (r, c+1)]:
                if 0 <= nr < rows and 0 <= nc < cols and heights[nr][nc] >= heights[r][c]:
                    dfs((nr, nc), visited)

        rows, cols = len(heights), len(heights[0])
        pacific, atlantic = set(), set()

        for r in range(rows):
            dfs((r, 0), pacific)
            dfs((r, cols - 1), atlantic)
        for c in range(cols):
            dfs((0, c), pacific)
            dfs((rows - 1, c), atlantic)

        return list(pacific & atlantic)

2025-10-05 18:56:55 +0300 MSK

Sun, 05 Oct 2025 18:56:55 +0300

Code

class Solution:
    def alternatingSum(self, nums: List[int]) -> int:
        res = 0
        for i, num in enumerate(nums):
            if i % 2 == 0:
                res += num
            else:
                res -= num
        return res

2025-10-04 21:18:06 +0300 MSK

Sat, 04 Oct 2025 21:18:06 +0300

Code

class Solution:
    def maxArea(self, height: list[int]) -> int:
        i = 0
        j = len(height) - 1
        res = 0

        while i < j:
            res = max(res, (j - i) * min(height[i], height[j]))
            if height[i] < height[j]:
                i += 1
            else:
                j -= 1

        return res

2025-10-03 16:57:28 +0300 MSK

Fri, 03 Oct 2025 16:57:28 +0300

Code

class Solution:
    # Class to store the height and coordinates of a cell in the grid
    class Cell:
        def __init__(self, height, row, col):
            self.height = height
            self.row = row
            self.col = col

        # Comparison method for the priority queue (min-heap)
        def __lt__(self, other):
            return self.height < other.height

    # Helper function to check if a cell is valid (within grid bounds)
    def _is_valid_cell(self, row, col, num_of_rows, num_of_cols):
        return 0 <= row < num_of_rows and 0 <= col < num_of_cols

    def trapRainWater(self, height_map):
        # Direction arrays
        d_row = [0, 0, -1, 1]
        d_col = [-1, 1, 0, 0]

        num_of_rows = len(height_map)
        num_of_cols = len(height_map[0])

        visited = [[False] * num_of_cols for _ in range(num_of_rows)]

        # Priority queue (min-heap) to process boundary cells in increasing height order
        boundary = []

        # Add the first and last column cells to the boundary and mark them as visited
        for i in range(num_of_rows):
            heapq.heappush(boundary, self.Cell(height_map[i][0], i, 0))
            heapq.heappush(
                boundary,
                self.Cell(height_map[i][num_of_cols - 1], i, num_of_cols - 1),
            )
            visited[i][0] = visited[i][num_of_cols - 1] = True

        # Add the first and last row cells to the boundary and mark them as visited
        for i in range(num_of_cols):
            heapq.heappush(boundary, self.Cell(height_map[0][i], 0, i))
            heapq.heappush(
                boundary,
                self.Cell(height_map[num_of_rows - 1][i], num_of_rows - 1, i),
            )
            visited[0][i] = visited[num_of_rows - 1][i] = True

        # Initialize the total water volume to 0
        total_water_volume = 0

        # Process cells in the boundary (min-heap will always pop the smallest height)
        while boundary:
            # Pop the cell with the smallest height from the boundary
            current_cell = heapq.heappop(boundary)

            current_row = current_cell.row
            current_col = current_cell.col
            min_boundary_height = current_cell.height

            # Explore all 4 neighboring cells
            for direction in range(4):
                # Calculate the row and column of the neighbor
                neighbor_row = current_row + d_row[direction]
                neighbor_col = current_col + d_col[direction]

                # Check if the neighbor is within the grid bounds and not yet visited
                if (
                    self._is_valid_cell(
                        neighbor_row, neighbor_col, num_of_rows, num_of_cols
                    )
                    and not visited[neighbor_row][neighbor_col]
                ):
                    # Get the height of the neighbor cell
                    neighbor_height = height_map[neighbor_row][neighbor_col]

                    # If the neighbor's height is less than the current boundary height, water can be trapped
                    if neighbor_height < min_boundary_height:
                        # Add the trapped water volume
                        total_water_volume += (
                            min_boundary_height - neighbor_height
                        )

                    # Push the neighbor into the boundary with updated height (to prevent water leakage)
                    heapq.heappush(
                        boundary,
                        self.Cell(
                            max(neighbor_height, min_boundary_height),
                            neighbor_row,
                            neighbor_col,
                        ),
                    )
                    visited[neighbor_row][neighbor_col] = True

        # Return the total amount of trapped water
        return total_water_volume

2025-10-02 17:45:08 +0300 MSK

Thu, 02 Oct 2025 17:45:08 +0300

Code

class Solution:
    def maxBottlesDrunk(self, numBottles: int, numExchange: int) -> int:
        res, empty = numBottles, numBottles
        while empty >= numExchange:
            empty = (empty - numExchange) + 1
            numExchange += 1
            res += 1
        return res

2025-10-01 09:21:36 +0300 MSK

Wed, 01 Oct 2025 09:21:36 +0300

Code

class Solution:
    def decimalRepresentation(self, n: int) -> List[int]:
        res = []
        count = 0
        while n > 0:
            val = (n % 10) * (10 ** count)
            if val != 0:
                res.append(val)
            count += 1
            n //= 10
        res.reverse()
        return res

2025-10-01 09:19:12 +0300 MSK

Wed, 01 Oct 2025 09:19:12 +0300

Code

class Solution:
    def majorityFrequencyGroup(self, s: str) -> str:
        freqs = [0] * 26
        groups = [([], 0) for _ in range(101)]
        for char in s:
            freqs[ord(char) - 97] += 1
        for i, freq in enumerate(freqs):
            if freq == 0:
                continue
            chars, _ = groups[freq]
            chars.append(chr(i + 97))
            groups[freq] = (chars, freq)
        groups.sort(key=lambda val: (len(val[0]), val[1]))
        return "".join(groups[-1][0])

2025-10-01 08:50:51 +0300 MSK

Wed, 01 Oct 2025 08:50:51 +0300

Code

class Solution:
    def evenNumberBitwiseORs(self, nums: List[int]) -> int:
        res = 0
        for num in nums:
            if num % 2 == 0:
                res |= num
        return res

2025-10-01 08:48:37 +0300 MSK

Wed, 01 Oct 2025 08:48:37 +0300

Code

class Solution:
    def maxKDistinct(self, nums: List[int], k: int) -> List[int]:
        nums.sort(reverse=True)
        res = []
        for i in range(len(nums)):
            if i == 0 or nums[i] != nums[i - 1]:
                res.append(nums[i])
                if len(res) == k:
                    break
        return res

2025-10-01 08:46:25 +0300 MSK

Wed, 01 Oct 2025 08:46:25 +0300

Code

class Solution:
    def earliestTime(self, tasks: List[List[int]]) -> int:
        res = math.inf
        for start, dur in tasks:
            res = min(res, start + dur)
        return res

2025-10-01 08:43:05 +0300 MSK

Wed, 01 Oct 2025 08:43:05 +0300

Code

class Solution:
    def numWaterBottles(self, numBottles: int, numExchange: int) -> int:
        res, empty = 0, 0
        while numBottles > 0:
            res += numBottles
            empty += numBottles
            numBottles, empty = empty // numExchange, empty % numExchange
        return res

2025-09-30 19:51:05 +0300 MSK

Tue, 30 Sep 2025 19:51:05 +0300

Code

class Solution:
    def triangularSum(self, nums: List[int]) -> int:
        while len(nums) > 1:
            new_nums = list()
            for i in range(len(nums) - 1):
                new_nums.append((nums[i] + nums[i + 1]) % 10)
            nums = new_nums
        return nums[0]

2025-09-29 18:59:55 +0300 MSK

Mon, 29 Sep 2025 18:59:55 +0300

Code

class Solution:
    def minScoreTriangulation(self, values: List[int]) -> int:
        @lru_cache(None)
        def dp(i, j):
            if i + 2 > j:
                return 0
            if i + 2 == j:
                return values[i] * values[i + 1] * values[j]
            return min(
                (values[i] * values[k] * values[j] + dp(i, k) + dp(k, j))
                for k in range(i + 1, j)
            )

        return dp(0, len(values) - 1)

2025-09-28 17:19:33 +0300 MSK

Sun, 28 Sep 2025 17:19:33 +0300

Code

class Solution:
    def largestPerimeter(self, nums: List[int]) -> int:
        nums.sort(reverse=True)
        for i in range(len(nums) - 2):
            if nums[i + 1] + nums[i + 2] > nums[i]:
                return nums[i] + nums[i + 1] + nums[i + 2]
        return 0

2025-09-27 17:16:05 +0300 MSK

Sat, 27 Sep 2025 17:16:05 +0300

Code

class Solution:
    def smallestAbsent(self, nums: List[int]) -> int:
        enc = set(nums)
        avg = max(sum(nums) // len(nums), 0) + 1
        while True:
            if avg in enc:
                avg += 1
            else:
                return avg

2025-09-27 10:04:38 +0300 MSK

Sat, 27 Sep 2025 10:04:38 +0300

Code

class Solution(object):
    def largestTriangleArea(self, points):
        def area(p, q, r):
            return .5 * abs(p[0]*q[1]+q[0]*r[1]+r[0]*p[1]
                           -p[1]*q[0]-q[1]*r[0]-r[1]*p[0])

        return max(area(*triangle)
            for triangle in itertools.combinations(points, 3))

2025-09-26 19:59:24 +0300 MSK

Fri, 26 Sep 2025 19:59:24 +0300

Code

class Solution:
    def triangleNumber(self, nums: List[int]) -> int:
        nums.sort()
        n = len(nums)
        count = 0

        for i in range(n - 1, -1, -1):
            left, right = 0, i - 1
            while left < right:
                if nums[left] + nums[right] > nums[i]:
                    count += right - left
                    right -= 1
                else:
                    left += 1
        return count

2025-09-25 17:15:32 +0300 MSK

Thu, 25 Sep 2025 17:15:32 +0300

Code

class Solution:
    def minimumTotal(self, triangle: List[List[int]]) -> int:
        cur, prev = [], triangle[0]
        for row in range(1, len(triangle)):
            for col in range(row + 1):
                if col == 0:
                    val = prev[col]
                elif col == row:
                    val = prev[col - 1]
                else:
                    val = min(prev[col - 1], prev[col])
                cur.append(val + triangle[row][col])
            prev.clear()
            cur, prev = prev, cur
        return min(prev)

2025-09-24 18:51:01 +0300 MSK

Wed, 24 Sep 2025 18:51:01 +0300

Code

class Solution:
    def fractionToDecimal(self, numerator: int, denominator: int) -> str:
        if numerator == 0:
            return "0"
        fraction = []
        if (numerator < 0) ^ (denominator < 0):
            fraction.append("-")
        dividend = abs(numerator)
        divisor = abs(denominator)
        fraction.append(str(dividend // divisor))
        remainder = dividend % divisor
        if remainder == 0:
            return "".join(fraction)
        fraction.append(".")
        map_dict = {}
        while remainder != 0:
            if remainder in map_dict:
                fraction.insert(map_dict[remainder], "(")
                fraction.append(")")
                break
            map_dict[remainder] = len(fraction)
            remainder *= 10
            fraction.append(str(remainder // divisor))
            remainder %= divisor

        return "".join(fraction)

2025-09-23 16:55:31 +0300 MSK

Tue, 23 Sep 2025 16:55:31 +0300

Code

class Solution:
    def compareVersion(self, version1: str, version2: str) -> int:
        digs1, digs2 = list(map(int, version1.split("."))), list(map(int, version2.split(".")))
        while digs1 and digs1[-1] == 0:
            digs1.pop()
        while digs2 and digs2[-1] == 0:
            digs2.pop()
        length1, length2 = len(digs1), len(digs2)
        for i in range(max(length1, length2)):
            if i == length1:
                return -1
            if i == length2:
                return 1
            dig1, dig2 = digs1[i], digs2[i]
            if dig1 > dig2:
                return 1
            elif dig2 > dig1:
                return -1
        return 0

2025-09-22 19:34:44 +0300 MSK

Mon, 22 Sep 2025 19:34:44 +0300

Code

class Solution:
    def maxFrequencyElements(self, nums: List[int]) -> int:
        max_freq, max_freq_count = 0, 0
        freqs = [0] * 101
        for num in nums:
            freqs[num] += 1
        for num, freq in enumerate(freqs):
            if freq > max_freq:
                max_freq, max_freq_count = freq, freq
            elif freq == max_freq:
                max_freq_count += freq
        return max_freq_count

2025-09-21 19:30:58 +0300 MSK

Sun, 21 Sep 2025 19:30:58 +0300

Code

class MovieRentingSystem:

    def __init__(self, n: int, entries: List[List[int]]):
        self.available = {}  # (shop, movie) -> price
        self.movie_shops = {}  # movie -> list of (price, shop)
        self.rented = set()  # (shop, movie) that are currently rented

        for shop, movie, price in entries:
            self.available[(shop, movie)] = price
            if movie not in self.movie_shops:
                self.movie_shops[movie] = []
            self.movie_shops[movie].append((price, shop))

        # Sort shops by price for each movie initially
        for movie in self.movie_shops:
            self.movie_shops[movie].sort()

    def search(self, movie: int) -> List[int]:
        result = []
        for price, shop in self.movie_shops.get(movie, []):
            if (shop, movie) not in self.rented:
                result.append(shop)
            if len(result) == 5:
                break
        return result

    def rent(self, shop: int, movie: int) -> None:
        self.rented.add((shop, movie))

    def drop(self, shop: int, movie: int) -> None:
        self.rented.discard((shop, movie))

    def report(self) -> List[List[int]]:
        rented_list = []
        for shop, movie in self.rented:
            price = self.available[(shop, movie)]
            rented_list.append((price, shop, movie))

        rented_list.sort()
        return [[shop, movie] for price, shop, movie in rented_list[:5]]

2025-09-20 19:25:16 +0300 MSK

Sat, 20 Sep 2025 19:25:16 +0300

Code

class Router:
    def __init__(self, memoryLimit: int):
        self.size = memoryLimit
        self.packets = {}  # key -> [source, destination, timestamp]
        self.counts = defaultdict(list)  # destination -> sorted list of timestamps
        self.queue = deque()  # FIFO order of packets

    def addPacket(self, source: int, destination: int, timestamp: int) -> bool:
        key = self._encode(source, destination, timestamp)

        # Duplicate check
        if key in self.packets:
            return False

        # If memory full, forward oldest packet
        if len(self.packets) >= self.size:
            self.forwardPacket()

        # Add packet
        self.packets[key] = [source, destination, timestamp]
        self.queue.append(key)
        self.counts[destination].append(timestamp)

        return True

    def forwardPacket(self):
        if not self.packets:
            return []

        key = self.queue.popleft()
        packet = self.packets.pop(key)

        dest = packet[1]
        self.counts[dest].pop(0)  # remove the earliest timestamp

        return packet

    def getCount(self, destination: int, startTime: int, endTime: int) -> int:
        timestamps = self.counts.get(destination, [])
        if not timestamps:
            return 0

        # Binary search for range
        left = bisect.bisect_left(timestamps, startTime)
        right = bisect.bisect_right(timestamps, endTime)

        return right - left

    def _encode(self, source: int, destination: int, timestamp: int) -> int:
        # Encode uniquely into 1 number
        return (source << 40) | (destination << 20) | timestamp

2025-09-19 18:44:46 +0300 MSK

Fri, 19 Sep 2025 18:44:46 +0300

Code

class Spreadsheet:

    def __init__(self, rows: int):
        self._grid = [[0] * 26 for _ in range(rows)]

    def _coord(self, cell: str) -> tuple[int, int]:
        return int(cell[1:]) - 1, ord(cell[0]) - ord("A")

    def setCell(self, cell: str, value: int) -> None:
        row, col = self._coord(cell)
        self._grid[row][col] = value

    def resetCell(self, cell: str) -> None:
        row, col = self._coord(cell)
        self._grid[row][col] = 0

    def getValue(self, formula: str) -> int:
        res = 0
        for cell in formula[1:].split("+"):
            if cell[0].isdigit():
                res += int(cell)
            else:
                row, col = self._coord(cell)
                res += self._grid[row][col]
        return res

# Your Spreadsheet object will be instantiated and called as such:
# obj = Spreadsheet(rows)
# obj.setCell(cell,value)
# obj.resetCell(cell)
# param_3 = obj.getValue(formula)

2025-09-18 19:58:25 +0300 MSK

Thu, 18 Sep 2025 19:58:25 +0300

Code

class TaskManager:
    def __init__(self, tasks: List[List[int]]):
        self.tasks = SortedSet()
        self.task_to_users = {}
        self.task_to_priority = {}
        for user_id, task_id, priority in tasks:
            self.add(user_id, task_id, priority)
    def add(self, userId: int, taskId: int, priority: int) -> None:
        self.tasks.add((priority, taskId, userId))
        self.task_to_users[taskId] = userId
        self.task_to_priority[taskId] = priority
    def edit(self, taskId: int, newPriority: int) -> None:
        user = self.task_to_users[taskId]
        self.rmv(taskId)
        self.add(user, taskId, newPriority)        
    def rmv(self, taskId: int) -> None:
        user = self.task_to_users[taskId]        
        priority = self.task_to_priority[taskId]
        self.tasks.remove((priority, taskId, user))
        del self.task_to_users[taskId]
        del self.task_to_priority[taskId]
    def execTop(self) -> int:
        if not self.tasks:
            return -1
        _, task_id, user_id = self.tasks[-1]
        self.rmv(task_id)
        return user_id

2025-09-17 20:39:54 +0300 MSK

Wed, 17 Sep 2025 20:39:54 +0300

Code

from sortedcontainers import SortedSet

class FoodRatings:
    def __init__(self, foods: List[str], cuisines: List[str], ratings: List[int]):
        # Map food with its rating.
        self.food_rating_map = {}
        # Map food with the cuisine it belongs to.
        self.food_cuisine_map = {}

        # Store all food of cuisine in a set (to sort them on ratings/name)
        # Set element -> Tuple: (-1 * food_rating, food_name)
        self.cuisine_food_map = defaultdict(SortedSet)

        for i in range(len(foods)):
            # Store 'rating' and 'cuisine' of the current 'food' in 'food_rating_map' and 'food_cuisine_map' maps.
            self.food_rating_map[foods[i]] = ratings[i]
            self.food_cuisine_map[foods[i]] = cuisines[i]
            # Insert the '(-1 * rating, name)' element in the current cuisine's set.
            self.cuisine_food_map[cuisines[i]].add((-ratings[i], foods[i]))

    def changeRating(self, food: str, newRating: int) -> None:
        # Fetch cuisine name for food.
        cuisine_name = self.food_cuisine_map[food]

        # Find and delete the element from the respective cuisine's set.
        old_element = (-self.food_rating_map[food], food)
        self.cuisine_food_map[cuisine_name].remove(old_element)

        # Update food's rating in 'food_rating' map.
        self.food_rating_map[food] = newRating
        # Insert the '(-1 * new rating, name)' element in the respective cuisine's set.
        self.cuisine_food_map[cuisine_name].add((-newRating, food))

    def highestRated(self, cuisine: str) -> str:
        highest_rated = self.cuisine_food_map[cuisine][0]
        # Return name of the highest-rated 'food' of 'cuisine'.
        return highest_rated[1]

2025-09-16 18:41:40 +0300 MSK

Tue, 16 Sep 2025 18:41:40 +0300

Code

from math import gcd

class Solution(object):
    def replaceNonCoprimes(self, nums):
        stack = []

        for num in nums:
            while stack:
                g = gcd(stack[-1], num)
                if g == 1:
                    break
                num = (stack.pop() * num) // g
            stack.append(num)

        return stack

2025-09-15 18:04:52 +0300 MSK

Mon, 15 Sep 2025 18:04:52 +0300

Code

class Solution:
    def canBeTypedWords(self, text: str, brokenLetters: str) -> int:
        ignore = False
        res = 0
        for char in itertools.chain(text, " "):
            if char == " ":
                if ignore:
                    ignore = False
                else:
                    res += 1
            elif char in brokenLetters:
                ignore = True
        return res

2025-09-14 19:11:43 +0300 MSK

Sun, 14 Sep 2025 19:11:43 +0300

Code

class Solution(object):
    def spellchecker(self, wordlist, queries):
        def devowel(word):
            return "".join('*' if c in 'aeiou' else c
                           for c in word)

        words_perfect = set(wordlist)
        words_cap = {}
        words_vow = {}

        for word in wordlist:
            wordlow = word.lower()
            words_cap.setdefault(wordlow, word)
            words_vow.setdefault(devowel(wordlow), word)

        def solve(query):
            if query in words_perfect:
                return query

            queryL = query.lower()
            if queryL in words_cap:
                return words_cap[queryL]

            queryLV = devowel(queryL)
            if queryLV in words_vow:
                return words_vow[queryLV]
            return ""

        return tuple(map(solve, queries))

2025-09-13 18:48:49 +0300 MSK

Sat, 13 Sep 2025 18:48:49 +0300

Code

class Solution:
    def maxFreqSum(self, s: str) -> int:
        freqs = [0] * 26
        for char in s:
            freqs[ord(char) - 97] += 1
        max_vow, max_con = 0, 0
        for i in range(26):
            if chr(i + 97) in ("a", "e", "i", "o", "u"):
                max_vow = max(max_vow, freqs[i])
            else:
                max_con = max(max_con, freqs[i])
        return max_vow + max_con

2025-09-12 21:22:49 +0300 MSK

Fri, 12 Sep 2025 21:22:49 +0300

Code

class Solution:
    def doesAliceWin(self, s: str) -> bool:
        return any(c in "aeiou" for c in s)

2025-09-11 20:29:02 +0300 MSK

Thu, 11 Sep 2025 20:29:02 +0300

Code

class Solution:
    def sortVowels(self, s: str) -> str:
        vowels = []

        s_list = list(s)

        # collect all vowels
        for i in s_list:
            if i in "AEIOUaeiou":
                vowels.append(i)
        
        if vowels == []:
            return s

        # sort the vowels
        vowels.sort()

        count = 0

        # replace original vowels with sorted ones
        for j in range(len(s)):
            if s_list[j] in "AEIOUaeiou":
                s_list[j] = vowels[count]
                count += 1

        return "".join(s_list)

2025-09-10 18:11:04 +0300 MSK

Wed, 10 Sep 2025 18:11:04 +0300

Code

class Solution:
    def minimumTeachings(
        self, n: int, languages: List[List[int]], friendships: List[List[int]]
    ) -> int:
        cncon = set()
        for friendship in friendships:
            mp = {}
            conm = False
            for lan in languages[friendship[0] - 1]:
                mp[lan] = 1
            for lan in languages[friendship[1] - 1]:
                if lan in mp:
                    conm = True
                    break
            if not conm:
                cncon.add(friendship[0] - 1)
                cncon.add(friendship[1] - 1)

        max_cnt = 0
        cnt = [0] * (n + 1)
        for friendship in cncon:
            for lan in languages[friendship]:
                cnt[lan] += 1
                max_cnt = max(max_cnt, cnt[lan])

        return len(cncon) - max_cnt

2025-09-09 18:44:51 +0300 MSK

Tue, 09 Sep 2025 18:44:51 +0300

Code

class Solution:
    def peopleAwareOfSecret(self, n: int, delay: int, forget: int) -> int:
        know, share = deque([(1, 1)]), deque([])
        know_cnt, share_cnt = 1, 0
        for i in range(2, n + 1):
            if know and know[0][0] == i - delay:
                know_cnt -= know[0][1]
                share_cnt += know[0][1]
                share.append(know[0])
                know.popleft()
            if share and share[0][0] == i - forget:
                share_cnt -= share[0][1]
                share.popleft()
            if share:
                know_cnt += share_cnt
                know.append((i, share_cnt))
        return (know_cnt + share_cnt) % (10**9 + 7)

2025-09-08 18:09:53 +0300 MSK

Mon, 08 Sep 2025 18:09:53 +0300

Code

class Solution:
    def getNoZeroIntegers(self, n: int) -> List[int]:
        for A in range(1, n):
            B = n - A
            if "0" not in str(A) + str(B):
                return [A, B]
        return []

2025-09-07 11:16:52 +0300 MSK

Sun, 07 Sep 2025 11:16:52 +0300

Code

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        num1 = nums[0]
        for num in nums[1:]:
            if num != num1:
                return 1
        return 0

2025-09-07 11:00:41 +0300 MSK

Sun, 07 Sep 2025 11:00:41 +0300

Code

class Solution:
    def sumZero(self, n: int) -> List[int]:
        res = []
        for i in range(1, n, 2):
            res.extend((i, -i))
        if len(res) < n:
            res.append(0)
        return res

2025-09-06 17:38:19 +0300 MSK

Sat, 06 Sep 2025 17:38:19 +0300

Code

class Solution:
    def get(self, num: int) -> int:
        i = 1
        base = 1
        cnt = 0
        while base <= num:
            cnt += ((i + 1) // 2) * (min(base * 2 - 1, num) - base + 1)
            i += 1
            base *= 2
        return cnt

    def minOperations(self, queries: List[List[int]]) -> int:
        res = 0
        for q in queries:
            res += (self.get(q[1]) - self.get(q[0] - 1) + 1) // 2
        return res

2025-09-05 19:23:51 +0300 MSK

Fri, 05 Sep 2025 19:23:51 +0300

Code

class Solution:
    def makeTheIntegerZero(self, num1: int, num2: int) -> int:
        k = 1
        while True:
            x = num1 - num2 * k
            if x < k:
                return -1
            if k >= x.bit_count():
                return k
            k += 1

2025-09-04 22:15:30 +0300 MSK

Thu, 04 Sep 2025 22:15:30 +0300

Code

class Solution:
    def findClosest(self, x: int, y: int, z: int) -> int:
        dxz = abs(x - z)
        dyz = abs(y - z)
        if dxz < dyz:
            return 1
        elif dxz > dyz:
            return 2
        else:
            return 0

2025-09-03 18:20:51 +0300 MSK

Wed, 03 Sep 2025 18:20:51 +0300

Code

class Solution:
    def numberOfPairs(self, points: List[List[int]]) -> int:
        ans = 0
        points.sort(key=lambda x: (x[0], -x[1]))

        for i in range(len(points) - 1):
            pointA = points[i]
            xMin = pointA[0] - 1
            xMax = math.inf
            yMin = -math.inf
            yMax = pointA[1] + 1

            for j in range(i + 1, len(points)):
                pointB = points[j]
                if (
                    pointB[0] > xMin
                    and pointB[0] < xMax
                    and pointB[1] > yMin
                    and pointB[1] < yMax
                ):
                    ans += 1
                    xMin = pointB[0]
                    yMin = pointB[1]

        return ans

2025-09-02 20:18:23 +0300 MSK

Tue, 02 Sep 2025 20:18:23 +0300

Code

class Solution:
    def numberOfPairs(self, points: List[List[int]]) -> int:
        ans = 0
        n = len(points)

        for i in range(n):
            pointA = points[i]
            for j in range(n):
                pointB = points[j]
                if i == j or not (
                    pointA[0] <= pointB[0] and pointA[1] >= pointB[1]
                ):
                    continue
                if n == 2:
                    ans += 1
                    continue

                illegal = False
                for k in range(n):
                    if k == i or k == j:
                        continue

                    pointTmp = points[k]
                    isXContained = (
                        pointTmp[0] >= pointA[0] and pointTmp[0] <= pointB[0]
                    )
                    isYContained = (
                        pointTmp[1] <= pointA[1] and pointTmp[1] >= pointB[1]
                    )
                    if isXContained and isYContained:
                        illegal = True
                        break
                if not illegal:
                    ans += 1
        return ans

2025-09-01 17:35:05 +0300 MSK

Mon, 01 Sep 2025 17:35:05 +0300

Code

class Solution:
    def maxAverageRatio(self, classes: List[List[int]], extraStudents: int) -> float:
        n = len(classes)
        res = 0
        for i in range(n):
            pass_, total = classes[i]
            profit = ((pass_ + 1) / (total + 1)) - (pass_ / total)
            classes[i] = (-profit, pass_, total)
        heapq.heapify(classes)
        while classes and extraStudents > 0:
            _, pass_, total = heapq.heappop(classes)
            if pass_ == total:
                res += 1
            else:
                pass_ += 1
                total += 1
                profit = ((pass_ + 1) / (total + 1)) - (pass_ / total)
                heapq.heappush(classes, (-profit, pass_, total))
                extraStudents -= 1
        for _, pass_, total in classes:
            res += pass_ / total
        return res / n

2025-08-31 15:07:32 +0300 MSK

Sun, 31 Aug 2025 15:07:32 +0300

Code

class Solution:
    def solveSudoku(self, board: list[list[str]]) -> None:
        n, N = 3, 9
        rows = [[0] * (N + 1) for _ in range(N)]
        cols = [[0] * (N + 1) for _ in range(N)]
        boxes = [[0] * (N + 1) for _ in range(N)]
        sudokuSolved = False

        def couldPlace(d, row, col):
            idx = (row // n) * n + col // n
            return (rows[row][d] + cols[col][d] + boxes[idx][d]) == 0

        def placeNumber(d, row, col):
            idx = (row // n) * n + col // n
            rows[row][d] += 1
            cols[col][d] += 1
            boxes[idx][d] += 1
            board[row][col] = str(d)

        def removeNumber(d, row, col):
            idx = (row // n) * n + col // n
            rows[row][d] -= 1
            cols[col][d] -= 1
            boxes[idx][d] -= 1
            board[row][col] = '.'

        def placeNextNumbers(row, col):
            nonlocal sudokuSolved
            if row == N - 1 and col == N - 1:
                sudokuSolved = True
            elif col == N - 1:
                backtrack(row + 1, 0)
            else:
                backtrack(row, col + 1)

        def backtrack(row, col):
            nonlocal sudokuSolved
            if board[row][col] == '.':
                for d in range(1, 10):
                    if couldPlace(d, row, col):
                        placeNumber(d, row, col)
                        placeNextNumbers(row, col)
                        if not sudokuSolved:
                            removeNumber(d, row, col)
            else:
                placeNextNumbers(row, col)

        for i in range(N):
            for j in range(N):
                if board[i][j] != '.':
                    placeNumber(int(board[i][j]), i, j)
        backtrack(0, 0)

2025-08-31 14:18:46 +0300 MSK

Sun, 31 Aug 2025 14:18:46 +0300

Code

class Solution:
    def recoverOrder(self, order: List[int], friends: List[int]) -> List[int]:
        for i in range(len(order)):
            if order[i] in friends:
                order[i] = (i, order[i])
            else:
                order[i] = (101, 101)
        order.sort()
        while order[-1] == (101, 101):
            order.pop()
        for i in range(len(order)):
            order[i] = order[i][1]
        return order

2025-08-31 14:13:40 +0300 MSK

Sun, 31 Aug 2025 14:13:40 +0300

Code

class Solution:
    def getLeastFrequentDigit(self, n: int) -> int:
        freqs = [0] * 10
        while n > 0:
            freqs[n % 10] += 1
            n //= 10
        min_freq, min_num = math.inf, -math.inf
        for i in range(10):
            if freqs[i] != 0 and (
                freqs[i] < min_freq or (freqs[i] == min_freq and i < min_num)
            ):
                min_freq, min_num = freqs[i], i
        return min_num

2025-08-30 20:16:00 +0300 MSK

Sat, 30 Aug 2025 20:16:00 +0300

Code

class Solution:
    def isValidSudoku(self, board: List[List[str]]) -> bool:
        rows = [[False] * 9 for _ in range(9)]
        cols = [[False] * 9 for _ in range(9)]
        boxes = [[False] * 9 for _ in range(9)]

        for i in range(9):
            for j in range(9):
                if board[i][j] != '.':
                    num = ord(board[i][j]) - ord('1')
                    boxIndex = (i // 3) * 3 + (j // 3)
                    if rows[i][num] or cols[j][num] or boxes[boxIndex][num]:
                        return False
                    rows[i][num] = cols[j][num] = boxes[boxIndex][num] = True
        return True

2025-08-29 19:59:52 +0300 MSK

Fri, 29 Aug 2025 19:59:52 +0300

Code

class Solution:
    def flowerGame(self, n: int, m: int) -> int:
        return (m * n) // 2

2025-08-28 16:59:23 +0300 MSK

Thu, 28 Aug 2025 16:59:23 +0300

Code

class Solution:
    def sortMatrix(self, grid: List[List[int]]) -> List[List[int]]:
        n = len(grid)

        for i in range(n):
            tmp = [grid[i + j][j] for j in range(n - i)]
            tmp.sort(reverse=True)
            for j in range(n - i):
                grid[i + j][j] = tmp[j]

        for j in range(1, n):
            tmp = [grid[i][j + i] for i in range(n - j)]
            tmp.sort()
            for i in range(n - j):
                grid[i][j + i] = tmp[i]

        return grid

2025-08-27 16:22:50 +0300 MSK

Wed, 27 Aug 2025 16:22:50 +0300

Code

class Solution:
    def lenOfVDiagonal(self, grid: List[List[int]]) -> int:
        DIRS = [(1, 1), (1, -1), (-1, -1), (-1, 1)]
        m, n = len(grid), len(grid[0])

        @cache
        def dfs(cx, cy, direction, turn, target):
            nx, ny = cx + DIRS[direction][0], cy + DIRS[direction][1]
            # If it goes beyond the boundary or the next node's value is not the target value, then return
            if nx < 0 or ny < 0 or nx >= m or ny >= n or grid[nx][ny] != target:
                return 0
            turn_int = 1 if turn else 0
            # Continue walking in the original direction.
            max_step = dfs(nx, ny, direction, turn, 2 - target)
            if turn:
                # Clockwise rotate 90 degrees turn
                max_step = max(
                    max_step,
                    dfs(nx, ny, (direction + 1) % 4, False, 2 - target),
                )
            return max_step + 1

        res = 0
        for i in range(m):
            for j in range(n):
                if grid[i][j] == 1:
                    for direction in range(4):
                        res = max(res, dfs(i, j, direction, True, 2) + 1)
        return res

2025-08-26 09:10:25 +0300 MSK

Tue, 26 Aug 2025 09:10:25 +0300

Code

class Solution:
    def myAtoi(self, s: str) -> int:
        digits = []
        sign = None
        found_dig = False
        for char in s:
            if char.isdigit():
                digits.append(int(char))
                found_dig = True
            elif not found_dig and sign is None and char == " ":
                continue
            elif not found_dig and sign is None and char in ("+", "-"):
                sign = 1
                if char == "-":
                    sign = -1
            else:
                break
        if sign is None:
            sign = 1
        res = 0
        cnt = 0
        while digits:
            res += digits.pop() * (10 ** cnt)
            cnt += 1
            if res > 2 ** 31 - 1 and sign == 1:
                return 2 ** 31 - 1
            elif res > 2 ** 31 and sign == -1:
                return -(2 ** 31)
        return res * sign

2025-08-26 08:16:39 +0300 MSK

Tue, 26 Aug 2025 08:16:39 +0300

Code

class Solution:
    def reverse(self, x: int) -> int:
        digits = []
        neg = 1
        if x < 0:
            neg = -1
            x = -x
        while x > 0:
            digits.append(x % 10)
            x //= 10
        cnt, res = 0, 0
        while digits:
            res += digits.pop() * (10 ** cnt)
            cnt += 1
            if res > 2 ** 31:
                return 0
        return res * neg

2025-08-26 08:11:15 +0300 MSK

Tue, 26 Aug 2025 08:11:15 +0300

Code

class Solution:
    def areaOfMaxDiagonal(self, dimensions: List[List[int]]) -> int:
        max_diag, max_area = 0, 0
        for ln, wdth in dimensions:
            diag, area = ln ** 2 + wdth ** 2, ln * wdth
            if diag > max_diag or (diag == max_diag and area > max_area):
                max_diag, max_area = diag, area
        return max_area

2025-08-25 17:00:38 +0300 MSK

Mon, 25 Aug 2025 17:00:38 +0300

Code

class MyCalendar:
    def __init__(self): 
        self.events = SortedList()

    def book(self, startTime: int, endTime: int) -> bool:
        insert_index = self.events.bisect_left((startTime, endTime))
        if (
            insert_index - 1 >= 0 
            and startTime < self.events[insert_index - 1][1]
        ) or (
            insert_index < len(self.events) 
            and self.events[insert_index][0] < endTime
        ):
            return False
        self.events.add((startTime, endTime))
        return True


# Your MyCalendar object will be instantiated and called as such:
# obj = MyCalendar()
# param_1 = obj.book(startTime,endTime)

2025-08-25 11:40:44 +0300 MSK

Mon, 25 Aug 2025 11:40:44 +0300

Code

class Solution:
    def findDiagonalOrder(self, mat: List[List[int]]) -> List[int]:
        res, rows, cols, cur = [], len(mat), len(mat[0]), []
        for i in range(rows + cols):
            if i < rows:
                row, col = i, 0
            else:
                row, col = rows - 1, (i - rows) + 1 
            while row >= 0 and col < cols:
                cur.append(mat[row][col])
                row, col = row - 1, col + 1
            if i % 2 != 0:
                cur.reverse()
            res.extend(cur)
            cur.clear()
        return res

2025-08-24 20:51:14 +0300 MSK

Sun, 24 Aug 2025 20:51:14 +0300

Code

class MyCircularQueue:

    def __init__(self, k: int):
        self._k = k
        self._q = [-1] * k
        self._i = 0
        self._len = 0

    def enQueue(self, value: int) -> bool:
        if self.isFull():
            return False
        self._q[self._i] = value
        self._i = (self._i + 1) % self._k
        self._len += 1
        return True

    def deQueue(self) -> bool:
        if self._len > 0:
            self._len -= 1
            return True
        return False

    def Front(self) -> int:
        if self.isEmpty():
            return -1
        return self._q[(self._i - self._len + self._k) % self._k]  
        
    def Rear(self) -> int:
        if self.isEmpty():
            return -1
        return self._q[(self._i - 1 + self._k) % self._k]

    def isEmpty(self) -> bool:
        return self._len == 0

    def isFull(self) -> bool:
        return self._len == self._k


# Your MyCircularQueue object will be instantiated and called as such:
# obj = MyCircularQueue(k)
# param_1 = obj.enQueue(value)
# param_2 = obj.deQueue()
# param_3 = obj.Front()
# param_4 = obj.Rear()
# param_5 = obj.isEmpty()
# param_6 = obj.isFull()

2025-08-24 19:54:22 +0300 MSK

Sun, 24 Aug 2025 19:54:22 +0300

Code

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Codec:

    def serialize(self, root: Optional[TreeNode]) -> str:
        """Encodes a tree to a single string.
        """
        if root is None:
            return ""
        left, right = self.serialize(root.left), self.serialize(root.right)
        return f"{root.val}|{len(left)}|{left}{right}"

    def deserialize(self, data: str) -> Optional[TreeNode]:
        """Decodes your encoded data to tree.
        """
        if not data:
            return None
        val, left_len, rest = data.split("|", 2)
        root = TreeNode(int(val))
        root.left = self.deserialize(rest[:int(left_len)])
        root.right = self.deserialize(rest[int(left_len):])
        return root    

# Your Codec object will be instantiated and called as such:
# Your Codec object will be instantiated and called as such:
# ser = Codec()
# deser = Codec()
# tree = ser.serialize(root)
# ans = deser.deserialize(tree)
# return ans

2025-08-24 19:38:13 +0300 MSK

Sun, 24 Aug 2025 19:38:13 +0300

Code

class Solution:

    def __init__(self, nums: List[int]):
        self._orig = nums
        self._cur = nums.copy()

    def reset(self) -> List[int]:
        return self._orig

    def shuffle(self) -> List[int]:
        return random.sample(self._orig, k=len(self._orig))


# Your Solution object will be instantiated and called as such:
# obj = Solution(nums)
# param_1 = obj.reset()
# param_2 = obj.shuffle()

2025-08-24 19:30:45 +0300 MSK

Sun, 24 Aug 2025 19:30:45 +0300

Code

class Solution:
    def maxHeightOfTriangle(self, red: int, blue: int) -> int:
        return max(self.helper(red, blue), self.helper(blue, red))
    
    def helper(self, red: int, blue: int) -> int:
        h = 0
        i = 1
        
        while True:
            if i % 2 == 1:
                if red >= i:
                    red -= i
                else:
                    break
            else:
                if blue >= i:
                    blue -= i
                else:
                    break
            h += 1
            i += 1
        
        return h

2025-08-24 19:28:22 +0300 MSK

Sun, 24 Aug 2025 19:28:22 +0300

Code

class Solution:
    def incremovableSubarrayCount(self, nums: List[int]) -> int:
        result = 0
        n = len(nums)
        if n == 0:
            return 0
        prefix_idx, suffix_idx = 0, n - 1
        while prefix_idx + 1 < n and nums[prefix_idx + 1] > nums[prefix_idx]:
            prefix_idx += 1
        if prefix_idx == n - 1:
            return (n * (n + 1)) // 2
        while suffix_idx > 0 and nums[suffix_idx] > nums[suffix_idx - 1]:
            suffix_idx -= 1
        result += prefix_idx + 1
        result += n - suffix_idx + 1
        i = 0
        j = suffix_idx
        while i <= prefix_idx:
            while j < n and nums[i] >= nums[j]:
                j += 1
            result += n - j
            i += 1
        return result

2025-08-24 19:26:17 +0300 MSK

Sun, 24 Aug 2025 19:26:17 +0300

Code

class Solution:
    def gcdOfOddEvenSums(self, n: int) -> int:
        odd_num = 1 + (n - 1) * 2
        even_num = 2 + (n - 1) * 2
        odd_sum = (n * (1 + odd_num)) // 2
        even_sum = (n * (2 + even_num)) // 2
        return math.gcd(odd_sum, even_sum)

2025-08-24 19:18:26 +0300 MSK

Sun, 24 Aug 2025 19:18:26 +0300

Code

class Solution:
    def reverseSubmatrix(self, grid: List[List[int]], x: int, y: int, k: int) -> List[List[int]]:
        rows, cols = len(grid), len(grid[0])
        for col in range(y, y + k):
            for row_dlt in range(k // 2):
                row1 = x + row_dlt
                row2 = (x + k - 1) - row_dlt
                grid[row1][col], grid[row2][col] = grid[row2][col], grid[row1][col]
        return grid

2025-08-24 19:07:06 +0300 MSK

Sun, 24 Aug 2025 19:07:06 +0300

Code

 SELECT r.book_id,
       b.title,
       b.author,
       b.genre,
       b.pages,
       Max(r.session_rating) - Min(r.session_rating) rating_spread,
       Round(( Sum(CASE WHEN r.session_rating < 3 THEN 1 ELSE 0 END + CASE WHEN
                           r.session_rating >
                           3 THEN 1 ELSE 0 END) ) / COUNT(r.session_id) ::
             Decimal(10, 2), 2)                      polarization_score
FROM   reading_sessions r
       INNER JOIN books b USING(book_id)
GROUP  BY r.book_id,
          b.title,
          b.author,
          b.genre,
          b.pages
HAVING COUNT(r.session_id) > 4
       AND Max(r.session_rating) > 3
       AND Min(r.session_rating) < 3
       AND Round(( Sum(CASE WHEN r.session_rating < 3 THEN 1 ELSE 0 END + CASE
                       WHEN
                                   r.session_rating >
                                   3 THEN 1 ELSE 0 END) ) / COUNT(r.session_id)
                 ::
                 Decimal(
                     10, 2), 2) >= 0.6
ORDER  BY polarization_score desc,
          b.title desc

2025-08-24 19:02:12 +0300 MSK

Sun, 24 Aug 2025 19:02:12 +0300

Code

class Solution:
    def isTrionic(self, nums: List[int]) -> bool:
        seg, n = 0, len(nums)
        for i in range(1, n):
            cur, prv = nums[i], nums[i - 1]
            if cur == prv:
                return False
            if seg == 0:
                if cur < prv:
                    if i == 1:
                        return False
                    seg = 1
            elif seg == 1:
                if cur > prv:
                    seg = 2
            elif seg == 2:
                if cur < prv:
                    return False
        return seg == 2

2025-08-24 18:57:13 +0300 MSK

Sun, 24 Aug 2025 18:57:13 +0300

Code

from typing import List

class Solution:
    def earliestFinishTime(self,landStartTime: List[int],landDuration: List[int],waterStartTime: List[int],waterDuration: List[int]) -> int:
        res = float('inf')
        n, m = len(landStartTime), len(waterStartTime)
        for i in range(n):
            a, d = landStartTime[i], landDuration[i]
            for j in range(m):
                b, e = waterStartTime[j], waterDuration[j]
                land_end = a + d
                start_water = max(land_end, b)
                finish1 = start_water + e
                water_end = b + e
                start_land = max(water_end, a)
                finish2 = start_land + d
                res = min(res, finish1, finish2)
        return res

2025-08-24 18:52:47 +0300 MSK

Sun, 24 Aug 2025 18:52:47 +0300

Code

class Solution:
    def checkDivisibility(self, n: int) -> bool:
        sm, pr, num = 0, 1, n
        while num > 0:
            dig = num % 10
            num //= 10
            sm += dig
            pr *= dig
        return n % (sm + pr) == 0

2025-08-24 18:50:32 +0300 MSK

Sun, 24 Aug 2025 18:50:32 +0300

Code

class Solution:
    def validateCoupons(self, code: List[str], businessLine: List[str], isActive: List[bool]) -> List[str]:
        res, n = [], len(code)
        b_order = {"electronics": 0, "grocery": 1, "pharmacy": 2, "restaurant": 3}
        for i in range(n):
            if (
                isActive[i] 
                and code[i] 
                and re.match("^[a-zA-Z0-9_]+$", code[i]) 
                and businessLine[i] in (
                    "electronics", "grocery", "pharmacy", "restaurant"
                )
            ):
                res.append(i)
        def sort(i: int) -> tuple[str, str]:
            return (b_order[businessLine[i]], code[i])
        res.sort(key=sort)
        for i in range(len(res)):
            res[i] = code[res[i]]
        return res

2025-08-24 18:39:15 +0300 MSK

Sun, 24 Aug 2025 18:39:15 +0300

Code

class Solution:
    def concatHex36(self, n: int) -> str:
        res = []
        for num, base in ((n ** 3, 36), (n ** 2, 16)):
            while num > 0:
                dig = num % base
                if dig < 10:
                    res.append(str(dig))
                else:
                    res.append(chr((dig - 10) + 65))
                num //= base
        res.reverse()
        return "".join(res)

2025-08-24 18:38:15 +0300 MSK

Sun, 24 Aug 2025 18:38:15 +0300

Code

class Solution:
    def concatHex36(self, n: int) -> str:
        res, cur = [], []
        for num, base in ((n ** 2, 16), (n ** 3, 36)):
            while num > 0:
                dig = num % base
                if dig < 10:
                    cur.append(str(dig))
                else:
                    cur.append(chr((dig - 10) + 65))
                num //= base
            cur.reverse()
            res.extend(cur)
            cur.clear()
        return "".join(res)

2025-08-24 18:22:04 +0300 MSK

Sun, 24 Aug 2025 18:22:04 +0300

Code

class Solution:
    def checkPrimeFrequency(self, nums: List[int]) -> bool:
        def is_prime(v: int) -> bool:
            for i in range(2, int(math.sqrt(v)) + 1):
                if v % i == 0:
                    return False
            return True
        freqs = [0] * 101
        for num in nums:
            freqs[num] += 1
        for freq in freqs:
            if freq > 1 and is_prime(freq):
                return True
        return False

2025-08-24 18:15:48 +0300 MSK

Sun, 24 Aug 2025 18:15:48 +0300

Code

class Solution:
    def generateTag(self, caption: str) -> str:
        res, n, cur = [], len(caption), []
        for i in range(n):
            ch = caption[i]
            if ch.isalpha():
                cur.append(ch.lower())
            if (ch == " " or i + 1 == n) and cur:
                if res:
                    cur[0] = cur[0].upper()
                res.append("".join(cur))
                cur.clear()
        return "".join(itertools.chain("#", res))[:100]

2025-08-24 18:07:04 +0300 MSK

Sun, 24 Aug 2025 18:07:04 +0300

Code

SELECT 
    book_id, 
    MAX(title) AS title, 
    MAX(author) AS author, 
    MAX(genre) AS genre, 
    MAX(publication_year) AS publication_year, 
    MAX(total_copies) AS current_borrowers 
FROM
    (
        SELECT 
            book_id,
            title,
            author, 
            genre,publication_year, 
            total_copies,
            total_copies AS total_remain 
        FROM 
            library_books
        UNION 
            ALL
        SELECT 
            book_id, 
            '', 
            '', 
            '', 
            1000, 
            0, 
            -1 
        FROM 
            borrowing_records 
        WHERE 
            return_date IS NULL
    ) sub
GROUP BY 
    book_id
HAVING 
    SUM(total_remain) = 0
ORDER BY 
    current_borrowers DESC, 
    title;

2025-08-24 18:01:04 +0300 MSK

Sun, 24 Aug 2025 18:01:04 +0300

Code

class Solution:
    def minCuttingCost(self, n: int, m: int, k: int) -> int:
        ans = 0
        if m <= k and n <= k:
            return 0
        if m > k and n <= k:
            ans += (m - k) * k
        if n > k and m <= k:
            ans += (n - k) * k
        return ans

2025-08-24 17:55:59 +0300 MSK

Sun, 24 Aug 2025 17:55:59 +0300

Code

class Solution:
    def smallestIndex(self, nums: List[int]) -> int:
        for i in range(len(nums)):
            num = nums[i]
            sm = 0
            while num > 0:
                sm += num % 10
                num //= 10
            if sm == i:
                return i
        return -1

2025-08-24 17:54:29 +0300 MSK

Sun, 24 Aug 2025 17:54:29 +0300

Code

class Solution:
    def minDeletion(self, s: str, k: int) -> int:
        freqs, n = [0] * 26, len(s)
        for i in range(n):
            freqs[ord(s[i]) - 97] += 1
        freqs.sort()
        res = 0
        for i in range(26 - k):
            res += freqs[i]
        return res

2025-08-24 17:52:40 +0300 MSK

Sun, 24 Aug 2025 17:52:40 +0300

Code

class Solution:
    def minDeletion(self, s: str, k: int) -> int:
        freqs, n = [0] * 26, len(s)
        for i in range(n):
            freqs[ord(s[i]) - 97] += 1
        freqs.sort(reverse=True)
        res = 0
        while len(freqs) > k:
            res += freqs.pop()
        return res

2025-08-24 17:46:18 +0300 MSK

Sun, 24 Aug 2025 17:46:18 +0300

Code

class Solution:
    def maxFreqSum(self, s: str) -> int:
        freqs, n = [0] * 26, len(s)
        for i in range(n):
            freqs[ord(s[i]) - 97] += 1
        max_vow, max_con = 0, 0
        vow = tuple(ord(ch) - 97 for ch in ("a", "e", "i", "o", "u"))
        for i in range(26):
            if i in vow:
                max_vow = max(max_vow, freqs[i])
            else:
                max_con = max(max_con, freqs[i])
        return max_vow + max_con

2025-08-24 17:42:32 +0300 MSK

Sun, 24 Aug 2025 17:42:32 +0300

Code

class Solution:
    def maxProduct(self, n: int) -> int:
        num1, num2 = -math.inf, -math.inf
        while n > 0:
            dig = n % 10
            if dig > num2:
                num1, num2 = num2, dig
            elif dig > num1:
                num1 = dig
            n //= 10
        return num1 * num2

2025-08-24 17:41:29 +0300 MSK

Sun, 24 Aug 2025 17:41:29 +0300

Code

class Solution:
    def maxProduct(self, n: int) -> int:
        dig = []
        while n > 0:
            heapq.heappush(dig, -(n % 10))
            n //= 10
        return abs(heapq.heappop(dig) * heapq.heappop(dig))

2025-08-24 17:40:23 +0300 MSK

Sun, 24 Aug 2025 17:40:23 +0300

Code

class Solution:
    def findClosest(self, x: int, y: int, z: int) -> int:
        diff1, diff2 = abs(z - x), abs(z - y)
        if diff1 == diff2:
            return 0
        if diff1 < diff2:
            return 1
        return 2

2025-08-24 17:38:35 +0300 MSK

Sun, 24 Aug 2025 17:38:35 +0300

Code

class Solution:
    def minOperations(self, nums: List[int], k: int) -> int:
        return sum(nums) % k

2025-08-24 17:36:34 +0300 MSK

Sun, 24 Aug 2025 17:36:34 +0300

Code

class Solution:
    def minimumPairRemoval(self, nums: List[int], ans = 0) -> int:
        def notSorted(nums: List[int]) -> bool:
            for a, b in pairwise(nums):
                if a > b: 
                    return True
            return False
        
        while notSorted(nums):
            minSum, mnIdx = inf, -1
            for i, pair in enumerate(pairwise(nums)):
                if sum(pair) < minSum:
                    minSum, mnIdx, delIdx = sum(pair), i, i + 1
            nums[mnIdx] = minSum
            del nums[delIdx]
            ans += 1
        return ans

2025-08-24 17:22:24 +0300 MSK

Sun, 24 Aug 2025 17:22:24 +0300

Code

class Solution:
    def minCosts(self, cost: List[int]) -> List[int]:
        
        return list(accumulate(cost, min))

2025-08-24 17:12:42 +0300 MSK

Sun, 24 Aug 2025 17:12:42 +0300

Code

class Solution:
    def reverseDegree(self, s: str) -> int:
        res, n = 0, len(s)
        for i in range(n):
            res += (i + 1) * (26 - (ord(s[i]) - 97))
        return res

2025-08-24 17:10:49 +0300 MSK

Sun, 24 Aug 2025 17:10:49 +0300

Code

class Solution:
    def maxContainers(self, n: int, w: int, maxWeight: int) -> int:
        return min(maxWeight // w, n * n)

2025-08-24 17:08:09 +0300 MSK

Sun, 24 Aug 2025 17:08:09 +0300

Code

class Solution:
    def totalNumbers(self, digits: List[int]) -> int:
        enc = set()
        p = [a * 100 + b * 10 + c for a, b, c in itertools.permutations(digits, 3)]
        for num in p:
            if num not in enc and len(str(num)) == 3:
                if num % 2 == 0:
                    enc.add(num)
        return len(enc)

2025-08-24 17:02:11 +0300 MSK

Sun, 24 Aug 2025 17:02:11 +0300

Code

class Solution:
    def largestInteger(self, nums: List[int], k: int) -> int:
        n = len(nums)
        subarray_count = defaultdict(int)
        for i in range(n - k + 1):
            for num in set(nums[i:i+k]):
                subarray_count[num] += 1
        res = -1
        for num, count in subarray_count.items():
            if count == 1:
                res = max(res, num)
        return res

2025-08-24 16:02:46 +0300 MSK

Sun, 24 Aug 2025 16:02:46 +0300

Code

class Solution:
    def transformArray(self, nums: List[int]) -> List[int]:
        for i in range(len(nums)):
            val = nums[i]
            if val % 2 == 0:
                nums[i] = 0
            else:
                nums[i] = 1
        nums.sort()
        return nums

2025-08-24 16:00:53 +0300 MSK

Sun, 24 Aug 2025 16:00:53 +0300

Code

SELECT 
    *
FROM 
    Products
WHERE 
    description ~ '\mSN[0-9]{4}-[0-9]{4}\M'
ORDER BY 
    product_id ASC;

2025-08-24 15:55:14 +0300 MSK

Sun, 24 Aug 2025 15:55:14 +0300

Code

class Solution:
    def hasSameDigits(self, s: str) -> bool:
        stack = list(map(int, s))
        stack.reverse()
        while len(stack) > 2:
            prev = stack.pop()
            for i in reversed(range(len(stack))):
                stack[i], prev = (prev + stack[i]) % 10, stack[i]
        return stack[0] == stack[1]

2025-08-24 15:40:47 +0300 MSK

Sun, 24 Aug 2025 15:40:47 +0300

Code

class Solution:
    def hasSpecialSubstring(self, s: str, k: int) -> bool:
        cnt, n = 0, len(s)
        for i in range(n):
            if i > 0 and s[i] == s[i - 1]:
                cnt += 1
            else:
                cnt = 1
            if cnt != k:
                continue
            if (
                i - cnt >= 0 and s[i - cnt] == s[i]
            ) or (
                i + 1 < n and s[i + 1] == s[i]
            ):
                cnt = 1
            else:
                return True
        return False

2025-08-24 15:35:22 +0300 MSK

Sun, 24 Aug 2025 15:35:22 +0300

Code

class Solution:
    def sumOfGoodNumbers(self, nums: List[int], k: int) -> int:
        res, n = 0, len(nums)
        for i in range(n):
            left, right, cur = -1, -1, nums[i]
            if i - k >= 0:
                left = nums[i - k]
            if i + k < n:
                right = nums[i + k]
            if left < cur > right:
                res += cur
        return res

2025-08-24 15:32:58 +0300 MSK

Sun, 24 Aug 2025 15:32:58 +0300

Code

class Solution:
    def maxDifference(self, s: str) -> int:
        freqs, n = [0] * 26, len(s)
        for i in range(n):
            freqs[ord(s[i]) - 97] += 1
        max_odd, min_even = -math.inf, math.inf
        for i in range(26):
            freq = freqs[i]
            if freq == 0:
                continue
            if freq % 2 == 0:
                min_even =  min(min_even, freq)
            else:
                max_odd = max(max_odd, freq)
        return max_odd - min_even

2025-08-24 15:21:21 +0300 MSK

Sun, 24 Aug 2025 15:21:21 +0300

Code

class Solution:
    def findValidPair(self, s: str) -> str:
        freqs, n = [0] * 10, len(s)
        for i in range(n):
            freqs[int(s[i])] += 1
        for i in range(1, n):
            cur, prv = int(s[i]), int(s[i - 1])
            if cur != prv and freqs[cur] == cur and freqs[prv] == prv:
                return f"{prv}{cur}"
        return ""

2025-08-24 15:17:24 +0300 MSK

Sun, 24 Aug 2025 15:17:24 +0300

Code

SELECT 
    user_id,
    email
FROM 
    users
WHERE 
    email ~ '^\w+@[A-Za-z]+\.com$'
ORDER BY 
    user_id ASC;

2025-08-24 15:14:50 +0300 MSK

Sun, 24 Aug 2025 15:14:50 +0300

Code

class Solution:
    def countPartitions(self, nums: List[int]) -> int:
        sm, n = [0] * len(nums), len(nums)
        sm[0] = nums[0]
        for i in range(n):
            sm[i] = sm[i - 1] + nums[i]
        res = 0
        for i in range(n - 1):
            left = sm[i]
            right = sm[-1] - left
            res += abs(right - left) % 2 == 0
        return res

2025-08-24 15:11:09 +0300 MSK

Sun, 24 Aug 2025 15:11:09 +0300

Code

class Solution:
    def subarraySum(self, nums: List[int]) -> int:
        sm, n = [0] * len(nums), len(nums)
        sm[0] = nums[0]
        for i in range(1, n):
            sm[i] = sm[i - 1] + nums[i]
        res = 0
        for i in range(n):
            left = max(0, i - nums[i])
            left_sum = 0
            if left > 0:
                left_sum = sm[left - 1]
            res += sm[i] - left_sum
        return res

2025-08-24 15:07:53 +0300 MSK

Sun, 24 Aug 2025 15:07:53 +0300

Code

class Solution:
    def maxAdjacentDistance(self, nums: List[int]) -> int:
        res = abs(nums[0] - nums[-1])
        for i in range(1, len(nums)):
            res = max(res, abs(nums[i] - nums[i - 1]))
        return res

2025-08-24 15:06:30 +0300 MSK

Sun, 24 Aug 2025 15:06:30 +0300

Code

class Solution:
    def zigzagTraversal(self, grid: List[List[int]]) -> List[int]:
        m, n = len(grid), len(grid[0])
        res = []
        skip = False
        for row in range(m):
            if row % 2 == 0:
                start, end, step = 0, n, 1
            else:
                start, end, step = n - 1, -1, -1
            for col in range(start, end, step):
                if not skip:
                    res.append(grid[row][col])
                skip = not skip
        return res

2025-08-24 15:00:31 +0300 MSK

Sun, 24 Aug 2025 15:00:31 +0300

Code

class Solution:
    def maxLength(self, A: List[int]) -> int:
        N = len(A)
        ans = 2
        last = {}
        i = 0
        for j, x in enumerate(A):
            for p in prime_divisors(x):
                i = max(i, last.get(p, -1) + 1)
                last[p] = j
            ans = max(ans, j - i + 1)
        
        return ans

def prime_divisors(x):
    d = 2
    while d * d <= x:
        if x % d == 0:
            x //= d
            while x % d == 0:
                x //= d
            yield d
        d += 1 + d & 1
    
    if x > 1:
        yield x

2025-08-24 14:57:30 +0300 MSK

Sun, 24 Aug 2025 14:57:30 +0300

Code

class Solution:
    def hasMatch(self, string: str, pattern: str) -> bool:
        left_part, right_part = pattern.split("*")
        left_idx = string.find(left_part)
        right_idx = string.find(right_part, left_idx + len(left_part))
        return left_idx != -1 and right_idx != -1

2025-08-24 14:47:52 +0300 MSK

Sun, 24 Aug 2025 14:47:52 +0300

Code

class Solution:
    def minimumOperations(self, grid: List[List[int]]) -> int:
        m, n = len(grid), len(grid[0])
        res = 0
        for col in range(n):
            prv = grid[0][col]
            for row in range(1, m):
                val = grid[row][col]
                if val > prv:
                    prv = val
                else:
                    diff = (prv + 1) - val
                    res += diff
                    prv += 1
        return res

2025-08-24 14:42:38 +0300 MSK

Sun, 24 Aug 2025 14:42:38 +0300

Code

class Solution:
    def minimumOperations(self, nums: List[int]) -> int:
        freqs, n = [0] * 101, len(nums)
        for i in range(n):
            freqs[nums[i]] += 1
        res = 0
        for i in range(0, n, 3):
            if max(freqs) == 1:
                return res
            res += 1
            for j in range(i, min(i + 3, n)):
                freqs[nums[j]] -= 1
        return res

2025-08-24 14:38:49 +0300 MSK

Sun, 24 Aug 2025 14:38:49 +0300

Code

class Solution:
    def countSubarrays(self, nums: List[int]) -> int:
        res, n = 0, len(nums)
        for i in range(n - 2):
            if nums[i] + nums[i + 2] == nums[i + 1] / 2:
                res += 1
        return res

2025-08-24 14:36:54 +0300 MSK

Sun, 24 Aug 2025 14:36:54 +0300

Code

class Solution:
    def buttonWithLongestTime(self, events: List[List[int]]) -> int:
        (mx_idx, mx_time), n = events[0], len(events)
        for i in range(n):
            (cur_idx, cur_time), (prv_idx, prv_time) = events[i], events[i - 1]
            diff = cur_time - prv_time
            if diff > mx_time or (diff == mx_time and cur_idx < mx_idx):
                mx_idx, mx_time = cur_idx, diff
        return mx_idx

2025-08-24 14:33:39 +0300 MSK

Sun, 24 Aug 2025 14:33:39 +0300

Code

class Solution:
    def constructTransformedArray(self, nums: List[int]) -> List[int]:
        n = len(nums)
        res = [0] * n
        for i in range(n):
            num = nums[i]
            if num == 0:
                val = 0
            elif num > 0:
                val = nums[(i + num) % n]
            else:
                val = nums[(i - -num + n) % n]
            res[i] = val
        return res

2025-08-24 14:28:25 +0300 MSK

Sun, 24 Aug 2025 14:28:25 +0300

Code

class Solution:
    def smallestNumber(self, n: int) -> int:
        res = 0
        while n > 0:
            res = (res << 1) | 1
            n //= 2
        return res

2025-08-24 14:25:47 +0300 MSK

Sun, 24 Aug 2025 14:25:47 +0300

Code

class Solution:
    def minimumSumSubarray(self, nums: List[int], l: int, r: int) -> int:
        sm, n = [0] * len(nums), len(nums)
        cur = 0
        for i in range(n):
            cur += nums[i]
            sm[i] = cur
        res = math.inf
        for i in range(n):
            left = 0
            if i > 0:
                left = sm[i - 1]
            for j in range(i + l - 1, min(i + r, n)):
                cur = sm[j] - left
                if cur > 0:
                    res = min(res, cur)
        if res == math.inf:
            return -1
        return res

2025-08-24 14:09:37 +0300 MSK

Sun, 24 Aug 2025 14:09:37 +0300

Code

class Solution:
    def canAliceWin(self, n: int) -> bool:
        cnt = 10
        while True:
            if n >= cnt:
                n -= cnt
                cnt -= 1
            else:
                return False
            if n >= cnt:
                n -= cnt
                cnt -= 1
            else:
                return True

2025-08-24 14:03:51 +0300 MSK

Sun, 24 Aug 2025 14:03:51 +0300

Code

class Solution:
    def countValidSelections(self, nums: List[int]) -> int:
        n, res = len(nums), 0
        left, right = [0 for _ in range(n)], [0 for _ in range(n)]
        for i in range(1, n):
            left[i] = left[i - 1] + nums[i - 1]
            right[-i - 1] = right[-i] + nums[-i]
        for i, num in enumerate(nums):
            if num != 0: continue
            if left[i] == right[i]: res += 2
            if abs(left[i] - right[i]) == 1: res += 1
        return res

2025-08-24 13:57:16 +0300 MSK

Sun, 24 Aug 2025 13:57:16 +0300

Code

class Solution:
    def hasIncreasingSubarrays(self, nums: List[int], k: int) -> bool:
        n = len(nums)
        cnt = 1
        prv_cnt = 0
        for i in range(1, n):
            cur, prv = nums[i], nums[i - 1]
            if cur > prv:
                cnt += 1
            else:
                prv_cnt, cnt = cnt, 1
            if cnt >= 2 * k or prv_cnt >= k and cnt >= k:
                return True
        return False

2025-08-24 13:46:58 +0300 MSK

Sun, 24 Aug 2025 13:46:58 +0300

Code

class Solution:
    def smallestNumber(self, n: int, t: int) -> int:
        while True:
            cur = n
            prd = 1
            while cur > 0:
                prd *= cur % 10
                if prd == 0:
                    break
                cur //= 10
            if prd % t == 0:
                return n
            n += 1

2025-08-24 13:33:19 +0300 MSK

Sun, 24 Aug 2025 13:33:19 +0300

Code

class Solution:
    def isBalanced(self, num: str) -> bool:
        sm, n = 0, len(num)
        for i in range(n):
            if i % 2 == 0:
                sm += int(num[i])
            else:
                sm -= int(num[i])
        return sm == 0

2025-08-24 13:31:22 +0300 MSK

Sun, 24 Aug 2025 13:31:22 +0300

Code

class Solution:
    def possibleStringCount(self, word: str) -> int:
        res, n = 1, len(word)
        for i in range(1, n):
            cur, prev = word[i], word[i - 1]
            if cur == prev:
                res += 1
        return res

2025-08-24 13:27:05 +0300 MSK

Sun, 24 Aug 2025 13:27:05 +0300

Code

class Solution:
    def findXSum(self, nums: List[int], k: int, x: int) -> List[int]:

        def do_sum (idx: int)-> int:

            ctr = Counter(nums[idx:idx + k])
            most_freq = nlargest(x, ctr, key = lambda y: (ctr[y], y))

            return sum(map(lambda y: y * ctr[y], most_freq))


        return tuple(map(do_sum,range(len(nums)+1 - k)))

2025-08-24 13:21:47 +0300 MSK

Sun, 24 Aug 2025 13:21:47 +0300

Code

class Solution:
    def minBitwiseArray(self, nums: List[int]) -> List[int]:
        ans = []
        for i in nums:
            for j in range(i):
                if j | (j + 1) == i:
                    ans.append(j)
                    break
            else:
                ans.append(-1)
        return ans

2025-08-24 13:10:51 +0300 MSK

Sun, 24 Aug 2025 13:10:51 +0300

Code

class Solution:
    def kthCharacter(self, k: int) -> str:
        res = 0
        while k != 1:
            ln = k.bit_length() - 1
            if (1 << ln) == k:
                ln -= 1
            k -= 1 << ln
            res += 1
        return chr(res + 97)

2025-08-24 13:05:10 +0300 MSK

Sun, 24 Aug 2025 13:05:10 +0300

Code

class Solution:
    def minElement(self, nums: List[int]) -> int:
        res = math.inf
        for num in nums:
            cur = 0
            while num > 0:
                cur += num % 10
                num //= 10
            res = min(res, cur)
        return res

2025-08-24 12:59:57 +0300 MSK

Sun, 24 Aug 2025 12:59:57 +0300

Code

class Solution:
    def getSneakyNumbers(self, nums: List[int]) -> List[int]:
        n = len(nums) - 2
        xor_all = 0
        for num in nums:
            xor_all ^= num
        for num in range(n):
            xor_all ^= num
        rightmost_bit = xor_all & -xor_all
        dup1, dup2 = 0, 0
        for num in nums:
            if num & rightmost_bit:
                dup1 ^= num
            else:
                dup2 ^= num
        for num in range(n):
            if num & rightmost_bit:
                dup1 ^= num
            else:
                dup2 ^= num
        return [dup1, dup2]

2025-08-24 12:47:23 +0300 MSK

Sun, 24 Aug 2025 12:47:23 +0300

Code

class Solution:
    def stableMountains(self, height: List[int], threshold: int) -> List[int]:
        res, n = [], len(height)
        for i in range(1, n):
            cur, prv = height[i], height[i - 1]
            if prv > threshold:
                res.append(i)
        return res

2025-08-24 12:44:46 +0300 MSK

Sun, 24 Aug 2025 12:44:46 +0300

Code

class Solution:
    def convertDateToBinary(self, date: str) -> str:
        res, cur = [], []
        for num in map(int, (date[:4], date[5:7], date[-2:])):
            while num > 0:
                cur.append(num & 1)
                num >>= 1
            cur.reverse()
            res.append("".join(map(str, cur)))
            cur.clear()
        return "-".join(res)

2025-08-24 12:44:03 +0300 MSK

Sun, 24 Aug 2025 12:44:03 +0300

Code

class Solution:
    def convertDateToBinary(self, date: str) -> str:
        res, cur = [], []
        for num in map(int, (date[:4], date[5:7], date[-2:])):
            while num > 0:
                cur.append(num % 2)
                num //= 2
            cur.reverse()
            res.append("".join(map(str, cur)))
            cur.clear()
        return "-".join(res)

2025-08-24 12:38:10 +0300 MSK

Sun, 24 Aug 2025 12:38:10 +0300

Code

class Solution:
    def checkTwoChessboards(self, coordinate1: str, coordinate2: str) -> bool:
        row1, col1 = ord(coordinate1[0]) - 97, int(coordinate1[1]) - 1
        row2, col2 = ord(coordinate2[0]) - 97, int(coordinate2[1]) - 1
        if row1 % 2 == 0:
            is_black1 = col1 % 2 == 0
        else:
            is_black1 = col1 % 2 != 0
        if row2 % 2 == 0:
            is_black2 = col2 % 2 == 0
        else:
            is_black2 = col2 % 2 != 0
        return is_black1 == is_black2

2025-08-24 12:34:32 +0300 MSK

Sun, 24 Aug 2025 12:34:32 +0300

Code

class Solution:
    def generateKey(self, num1: int, num2: int, num3: int) -> int:
        res = 0
        cnt = 0
        while num1 > 0 and num2 > 0 and num3 > 0:
            res += min(num1 % 10, num2 % 10, num3 % 10) * (10 ** cnt)
            cnt += 1
            num1 //= 10
            num2 //= 10
            num3 //= 10
        return res

2025-08-24 12:31:27 +0300 MSK

Sun, 24 Aug 2025 12:31:27 +0300

Code

class Solution:
    def getFinalState(self, nums: List[int], k: int, multiplier: int):
        hp = [(val, i) for i, val in enumerate(nums)]
        heapq.heapify(hp)
        for _ in range(k):
            _, i = heapq.heappop(hp)
            nums[i] *= multiplier
            heapq.heappush(hp, (nums[i], i))
        return nums

2025-08-24 12:29:48 +0300 MSK

Sun, 24 Aug 2025 12:29:48 +0300

Code

class Solution:
    def getFinalState(self, nums: List[int], k: int, multiplier: int) -> List[int]:
        pos, n = defaultdict(list), len(nums)
        hp = nums.copy()
        heapq.heapify(hp)
        for i in reversed(range(n)):
            heapq.heappush(pos[nums[i]], i)
        while k > 0:
            k -= 1
            val = heapq.heappop(hp)
            new_val = val * multiplier
            heapq.heappush(hp, new_val)
            idx = heapq.heappop(pos[val])
            nums[idx] = new_val
            heapq.heappush(pos[new_val], idx)
        return nums

2025-08-24 12:20:45 +0300 MSK

Sun, 24 Aug 2025 12:20:45 +0300

Code

class Solution:
    def countKConstraintSubstrings(self, s: str, k: int) -> int:
        res, n, ones, l = 0, len(s), 0, 0
        for r in range(n):
            ones += int(s[r])
            while (ones > k) and ((r - l + 1) - ones) > k:
                ones -= int(s[l])
                l += 1
            res += r - l + 1
        return res

2025-08-24 11:46:23 +0300 MSK

Sun, 24 Aug 2025 11:46:23 +0300

Code

class Solution:
    def finalPositionOfSnake(self, n: int, commands: List[str]) -> int:
        col, row = 0, 0
        for cmd in commands:
            if cmd == "RIGHT":
                col += 1
            elif cmd == "UP":
                row -= 1
            elif cmd == "DOWN":
                row += 1
            else:
                col -= 1
        return row * n + col

2025-08-24 11:43:54 +0300 MSK

Sun, 24 Aug 2025 11:43:54 +0300

Code

class Solution:
    def winningPlayerCount(self, n: int, pick: List[List[int]]) -> int:
        res, n, freqs = 0, len(pick), [[0] * 11 for _ in range(11)]
        for i in range(n):
            pl, cl = pick[i]
            freqs[pl][cl] += 1
        for i in range(len(freqs)):
            if max(freqs[i]) > i:
                res += 1
        return res

2025-08-24 10:55:08 +0300 MSK

Sun, 24 Aug 2025 10:55:08 +0300

Code

class Solution:
    def longestSubarray(self, nums: List[int]) -> int:
        res, n, cnt1, cnt2 = 0, len(nums), 0, 0
        for i in range(len(nums)):
            cur = nums[i]
            if cur == 1:
                cnt2 += 1
                res = max(res, cnt1 + cnt2)
            elif cur == 0:
                cnt1, cnt2 = cnt2, 0
        if res == n:
            return res - 1
        return res

2025-08-23 20:17:19 +0300 MSK

Sat, 23 Aug 2025 20:17:19 +0300

Code

class Solution:
    def canAliceWin(self, nums: List[int]) -> bool:
        sm_single, sm_double, sm_all = 0, 0, 0
        for num in nums:
            if num < 10:
                sm_single += num
            elif num < 100:
                sm_double += num
            sm_all += num
        return sm_single > (sm_all - sm_single) or sm_double > (sm_all - sm_double)

2025-08-23 19:28:34 +0300 MSK

Sat, 23 Aug 2025 19:28:34 +0300

Code

class Solution:
    def minChanges(self, n: int, k: int) -> int:
        res = 0
        if n < k:
            return -1
        while k > 0 or n > 0:
            n1, k1 = n & 1, k & 1
            if n1 != k1 and n1 == 0 and k1 == 1:
                return -1
            if n1 != k1:
                res += 1
            n >>= 1
            k >>= 1
        return res

2025-08-23 18:30:08 +0300 MSK

Sat, 23 Aug 2025 18:30:08 +0300

Code

class Solution:
    def minimumSum2(
        self, grid: List[List[int]], u: int, d: int, l: int, r: int
    ) -> int:
        min_i = len(grid)
        max_i = 0
        min_j = len(grid[0])
        max_j = 0

        for i in range(u, d + 1):
            for j in range(l, r + 1):
                if grid[i][j] == 1:
                    min_i = min(min_i, i)
                    min_j = min(min_j, j)
                    max_i = max(max_i, i)
                    max_j = max(max_j, j)

        return (
            (max_i - min_i + 1) * (max_j - min_j + 1)
            if min_i <= max_i
            else sys.maxsize // 3
        )

    def rotate(self, vec: List[List[int]]) -> List[List[int]]:
        n = len(vec)
        m = len(vec[0]) if n > 0 else 0
        ret = [[0] * n for _ in range(m)]

        for i in range(n):
            for j in range(m):
                ret[m - j - 1][i] = vec[i][j]

        return ret

    def solve(self, grid: List[List[int]]) -> int:
        n = len(grid)
        m = len(grid[0]) if n > 0 else 0
        res = n * m

        for i in range(n - 1):
            for j in range(m - 1):
                res = min(
                    res,
                    self.minimumSum2(grid, 0, i, 0, m - 1)
                    + self.minimumSum2(grid, i + 1, n - 1, 0, j)
                    + self.minimumSum2(grid, i + 1, n - 1, j + 1, m - 1),
                )

                res = min(
                    res,
                    self.minimumSum2(grid, 0, i, 0, j)
                    + self.minimumSum2(grid, 0, i, j + 1, m - 1)
                    + self.minimumSum2(grid, i + 1, n - 1, 0, m - 1),
                )

        for i in range(n - 2):
            for j in range(i + 1, n - 1):
                res = min(
                    res,
                    self.minimumSum2(grid, 0, i, 0, m - 1)
                    + self.minimumSum2(grid, i + 1, j, 0, m - 1)
                    + self.minimumSum2(grid, j + 1, n - 1, 0, m - 1),
                )

        return res

    def minimumSum(self, grid: List[List[int]]) -> int:
        rgrid = self.rotate(grid)
        return min(self.solve(grid), self.solve(rgrid))

2025-08-22 21:36:17 +0300 MSK

Fri, 22 Aug 2025 21:36:17 +0300

Code

class Solution:
    def winningPlayer(self, x: int, y: int) -> str:
        y //= 4
        x = min(x, y)
        if x % 2 == 1:
            return "Alice"
        else:
            return "Bob"

2025-08-22 21:29:25 +0300 MSK

Fri, 22 Aug 2025 21:29:25 +0300

Code

class Solution:
    def getSmallestString(self, s: str) -> str:
        res = list(s)
        for i in range(len(s) - 1):
            cur, nxt = int(s[i]), int(s[i + 1])
            if cur % 2 == nxt % 2 and cur > nxt:
                res[i], res[i + 1] = s[i + 1], s[i]
                break        
        return "".join(res)

2025-08-22 21:16:52 +0300 MSK

Fri, 22 Aug 2025 21:16:52 +0300

Code

class Solution:
    def getEncryptedString(self, s: str, k: int) -> str:
        res = []
        for i in range(len(s)):
            res.append(s[(i + k) % len(s)])
        return "".join(res)

2025-08-22 21:13:56 +0300 MSK

Fri, 22 Aug 2025 21:13:56 +0300

Code

class Solution:
    def numberOfAlternatingGroups(self, colors: List[int]) -> int:
        res = 0
        if colors[0] != colors[-1] and colors[0] != colors[1]:
            res += 1
        if colors[-1] != colors[-2] and colors[-1] != colors[0]:
            res += 1
        for i in range(1, len(colors) - 1):
            if colors[i] != colors[i - 1] and colors[i] != colors[i + 1]:
                res += 1
        return res

2025-08-22 21:08:45 +0300 MSK

Fri, 22 Aug 2025 21:08:45 +0300

Code

class Solution:
    def minimumAverage(self, nums: List[int]) -> float:
        av = []
        nums.sort()
        for i in range(len(nums) // 2):
            heapq.heappush(av, nums[i] + nums[len(nums) - i - 1])
        return heapq.heappop(av) / 2

2025-08-22 21:06:36 +0300 MSK

Fri, 22 Aug 2025 21:06:36 +0300

Code

class Solution:
    def minimumOperations(self, nums: List[int]) -> int:
        res = 0
        for i in range(len(nums)):
            res += nums[i] % 3 != 0
        return res

2025-08-22 21:05:07 +0300 MSK

Fri, 22 Aug 2025 21:05:07 +0300

Code

class Solution:
    def minimumOperations(self, nums: List[int]) -> int:
        res = 0
        for i in range(len(nums)):
            res += min(nums[i] % 3, ((nums[i] // 3) + 1) * 3 - nums[i])
        return res

2025-08-22 21:02:15 +0300 MSK

Fri, 22 Aug 2025 21:02:15 +0300

Code

class Solution:
    def countCompleteDayPairs(self, hours: List[int]) -> int:
        freqs = [0] * 24
        for i in range(len(hours)):
            freqs[hours[i] % 24] += 1
        res = 0
        for i in range(len(hours)):
            hr = hours[i] % 24
            freqs[hr] -= 1
            if hr == 0:
                res += freqs[hr]
            else:
                res += freqs[24 - hr]
        return res

2025-08-22 20:53:33 +0300 MSK

Fri, 22 Aug 2025 20:53:33 +0300

Code

class Solution:
    def numberOfChild(self, n: int, k: int) -> int:
        circleback = (n - 1) * 2
        k %= circleback
        if k < n:
            return k
        return circleback - k

2025-08-22 20:44:21 +0300 MSK

Fri, 22 Aug 2025 20:44:21 +0300

Code

class Solution:
    def clearDigits(self, s: str) -> str:
        res = []
        for i in range(len(s)):
            ch = s[i]
            if not ch.isdigit():
                res.append(ch)
            elif res:
                res.pop()
        return "".join(res)

2025-08-22 20:41:37 +0300 MSK

Fri, 22 Aug 2025 20:41:37 +0300

Code

class Solution:
    def minimumChairs(self, s: str) -> int:
        left = 0
        res = 0
        for i in range(len(s)):
            if s[i] == "E":
                if left > 0:
                    left -= 1
                else:
                    res += 1
            else:
                left += 1
        return res

2025-08-22 20:34:34 +0300 MSK

Fri, 22 Aug 2025 20:34:34 +0300

Code

class Solution:
    def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:
        freqs = [0] * 51
        for i in range(len(nums2)):
            freqs[nums2[i]] += 1
        res = 0
        for i in range(len(nums1)):
            for num2 in range(1, len(freqs)):
                if nums1[i] % (num2 * k) == 0:
                    res += freqs[num2]
        return res

2025-08-22 20:29:48 +0300 MSK

Fri, 22 Aug 2025 20:29:48 +0300

Code

class Solution:
    def duplicateNumbersXOR(self, nums: List[int]) -> int:
        freqs = [0] * 51
        res = 0
        for i in range(len(nums)):
            freqs[nums[i]] += 1
            if freqs[nums[i]] == 2:
                res ^= nums[i]
        return res

2025-08-22 20:27:37 +0300 MSK

Fri, 22 Aug 2025 20:27:37 +0300

Code

class Solution:
    def isArraySpecial(self, nums: List[int]) -> bool:
        for i in range(1, len(nums)):
            cur, prev = nums[i] % 2 == 0, nums[i - 1] % 2 == 0
            if cur == prev:
                return False
        return True

2025-08-22 20:25:28 +0300 MSK

Fri, 22 Aug 2025 20:25:28 +0300

Code

class Solution:
    def findPermutationDifference(self, s: str, t: str) -> int:
        pos = [0] * 26
        for i in range(len(s)):
            pos[ord(s[i]) - 97] += i
        res = 0
        for i in range(len(t)):
            res += abs(i - pos[ord(t[i]) - 97])
        return res

2025-08-22 20:22:48 +0300 MSK

Fri, 22 Aug 2025 20:22:48 +0300

Code

class Solution:
    def satisfiesConditions(self, grid: List[List[int]]) -> bool:
        rows, cols = len(grid), len(grid[0])
        for row in range(rows):
            for col in range(cols):
                val = grid[row][col]
                if row + 1 < rows and val != grid[row + 1][col]:
                    return False
                if col + 1 < cols and val == grid[row][col + 1]:
                    return False
        return True

2025-08-22 20:20:58 +0300 MSK

Fri, 22 Aug 2025 20:20:58 +0300

Code

class Solution:
    def isValid(self, word: str) -> bool:
        vws = ('a', 'e', 'i', 'o', 'u')
        if len(word) < 3:
            return False
        has_vw, has_cons = False, False
        for i in range(len(word)):
            ch = word[i]
            if ch.isalpha():
                if ch.lower() in vws:
                    has_vw = True
                else:
                    has_cons = True
            elif not ch.isdigit():
                return False
        return has_vw and has_cons

2025-08-22 20:15:56 +0300 MSK

Fri, 22 Aug 2025 20:15:56 +0300

Code

class Solution:
    def addedInteger(self, nums1: List[int], nums2: List[int]) -> int:
        nums1.sort()
        nums2.sort()
        return nums2[0] - nums1[0]

2025-08-22 20:12:59 +0300 MSK

Fri, 22 Aug 2025 20:12:59 +0300

Code

class Solution:
    def canMakeSquare(self, grid: List[List[str]]) -> bool:
        rows, cols = len(grid), len(grid[0])
        moves = ((0, 0), (0, -1), (-1, -1), (-1, 0))
        for row in range(1, rows):
            for col in range(1, cols):
                cnt = 0
                for row_dlt, col_dlt in moves:
                    if grid[row + row_dlt][col + col_dlt] == "W":
                        cnt += 1
                    else:
                        cnt -= 1
                if cnt in (2, -2, 4, -4):
                    return True
        return False

2025-08-22 20:03:50 +0300 MSK

Fri, 22 Aug 2025 20:03:50 +0300

Code

class Solution:
    def numberOfSpecialChars(self, word: str) -> int:
        freqs = [0] * 26
        res = 0
        for i in range(len(word)):
            char = word[i]
            idx = ord(char)
            if char.isupper():
                idx -= 65
                freqs[idx] |= 0x01
            else:
                idx -= 97
                freqs[idx] |= 0x10
        for i in range(len(freqs)):
            freq = freqs[i]
            if freq ^ 0x11 == 0:
                res += 1
        return res

2025-08-22 19:58:17 +0300 MSK

Fri, 22 Aug 2025 19:58:17 +0300

Code

class Solution:
    def findLatestTime(self, time_str):
        len_time_str = len(time_str)
        ret_val = ''
        i = 0
        while (i < len_time_str):
            c = time_str[i]
            if (c == '?'):
                if (i == 0):
                    if (time_str[i+1] == '?'):
                        ret_val += '1'
                    elif (time_str[i+1] in ('0', '1')):
                        ret_val += '1'
                    else:
                        ret_val += '0'
                elif (i == 1):
                    if (time_str[i-1] == '?'):
                        ret_val += '1'
                    elif (time_str[i-1] in ('0')):
                        ret_val += '9'
                    elif (time_str[i-1] in ('1')):
                        ret_val += '1'
                    else:
                        ret_val += '0'
                elif (i == 3):
                    ret_val += '5'
                elif (i == 4):
                    ret_val += '9'
            else:
                ret_val += c
            i += 1
        return ret_val

2025-08-22 19:49:07 +0300 MSK

Fri, 22 Aug 2025 19:49:07 +0300

Code

class Solution:
    def longestMonotonicSubarray(self, nums: List[int]) -> int:
        inc_len, dec_len, cur_len, cur_state = 1, 1, 1, 0
        for i in range(1, len(nums)):
            cur, prev = nums[i], nums[i - 1]
            if cur > prev:
                if cur_state == 1:
                    cur_len += 1
                else:
                    cur_state = 1
                    cur_len = 2
                inc_len = max(inc_len, cur_len)
            elif cur == prev:
                cur_len = 1
                cur_state = 0
            else:
                if cur_state == -1:
                    cur_len += 1
                else:
                    cur_state = -1
                    cur_len = 2
                dec_len = max(dec_len, cur_len)
        return max(inc_len, dec_len)

2025-08-22 19:43:35 +0300 MSK

Fri, 22 Aug 2025 19:43:35 +0300

Code

class Solution:
    def sumOfTheDigitsOfHarshadNumber(self, x: int) -> int:
        cur = x
        sm = 0
        while cur > 0:
            sm += cur % 10
            cur //= 10
        if x % sm == 0:
            return sm
        return -1

2025-08-22 19:42:24 +0300 MSK

Fri, 22 Aug 2025 19:42:24 +0300

Code

class Solution:
    def minimumSubarrayLength(self, nums: List[int], k: int) -> int:
        n = len(nums)
        min_len = math.inf
        for i in range(n):
            curr = 0
            for j in range(i, n):
                curr |= nums[j]
                if curr >= k:
                    min_len = min(min_len , j - i + 1)
                    break
        if min_len == math.inf:
            return -1
        return min_len

2025-08-22 19:24:16 +0300 MSK

Fri, 22 Aug 2025 19:24:16 +0300

Code

class Solution:
    def maximumLengthSubstring(self, s: str) -> int:
        ans = ii = 0 
        freq = Counter()
        for i, ch in enumerate(s): 
            freq[ch] += 1
            while freq[ch] == 3: 
                freq[s[ii]] -= 1
                ii += 1
            ans = max(ans, i - ii + 1)
        return ans

2025-08-22 19:19:46 +0300 MSK

Fri, 22 Aug 2025 19:19:46 +0300

Code

class Solution:
    def isSubstringPresent(self, s: str) -> bool:
        for i in range(1, len(s)):
            cur, prev = s[i], s[i - 1]
            for j in range(i, len(s)):
                cur2, prev2 = s[j], s[j - 1]
                if cur == prev2 and prev == cur2:
                    return True
        return False

2025-08-22 19:14:44 +0300 MSK

Fri, 22 Aug 2025 19:14:44 +0300

Code

class Solution:
    def sumOfEncryptedInt(self, nums: List[int]) -> int:
        res = 0
        for i in range(len(nums)):
            cur = nums[i]
            max_dig = 0
            enc = 0
            cnt = 0
            while cur > 0:
                max_dig = max(max_dig, cur % 10)
                cur //= 10
                enc += 10 ** cnt
                cnt += 1
            enc *= max_dig
            res += enc
        return res

2025-08-22 19:10:19 +0300 MSK

Fri, 22 Aug 2025 19:10:19 +0300

Code

class Solution:
    def minimumBoxes(self, apple: List[int], capacity: List[int]) -> int:
        apples = sum(apple)
        capacity.sort(reverse=True)
        for i in range(len(capacity)):
            apples = max(apples - capacity[i], 0)
            if apples == 0:
                return i + 1
        raise Exception

2025-08-22 19:03:00 +0300 MSK

Fri, 22 Aug 2025 19:03:00 +0300

Code

class Solution:
    def resultArray(self, nums):
        len_nums = len(nums)
        arr1 = [nums[0]]
        arr2 = [nums[1]]
        for i in range(2, len(nums)):
            if arr1[-1] > arr2[-1]:
                arr1.append(nums[i])
            else:
                arr2.append(nums[i])
        arr1.extend(arr2)
        return arr1

2025-08-22 18:58:03 +0300 MSK

Fri, 22 Aug 2025 18:58:03 +0300

Code

class Solution:
    def minOperations(self, nums: List[int], k: int) -> int:
        nums.sort()
        for i in range(len(nums)):
            if nums[i] >= k:
                return i
        return len(nums)

2025-08-22 18:56:27 +0300 MSK

Fri, 22 Aug 2025 18:56:27 +0300

Code

class Solution:
    def isPossibleToSplit(self, nums: List[int]) -> bool:
        freqs = [0] * 101
        for num in nums:
            freqs[num] += 1
            if freqs[num] == 3:
                return False
        return True

2025-08-22 18:53:34 +0300 MSK

Fri, 22 Aug 2025 18:53:34 +0300

Code

class Solution:
    def countPrefixSuffixPairs(self, words: List[str]) -> int:
        res = 0
        for i in range(len(words)):
            w1 = words[i]
            for j in range(i + 1, len(words)):
                w2 = words[j]
                if w2.startswith(w1) and w2.endswith(w1):
                    res += 1
        return res

2025-08-22 18:48:54 +0300 MSK

Fri, 22 Aug 2025 18:48:54 +0300

Code

class Solution:
    def maxOperations(self, nums: List[int]) -> int:
        target = sum(nums[:2])
        res = 1
        for i in range(2, len(nums) - 1, 2):
            if sum(nums[i:i + 2]) == target:
                res += 1
            else:
                break
        return res

2025-08-22 18:46:45 +0300 MSK

Fri, 22 Aug 2025 18:46:45 +0300

Code

class Solution:
    def modifiedMatrix(self, matrix: List[List[int]]) -> List[List[int]]:
        rows, cols = len(matrix), len(matrix[0])
        for col in range(cols):
            max_val = -1
            for row in range(rows):
                max_val = max(max_val, matrix[row][col])
            for row in range(rows):
                if matrix[row][col] == -1:
                    matrix[row][col] = max_val
        return matrix

2025-08-22 18:44:22 +0300 MSK

Fri, 22 Aug 2025 18:44:22 +0300

Code

class Solution:
    def returnToBoundaryCount(self, nums: List[int]) -> int:
        res = 0
        pos = nums[0]
        for num in nums[1:]:
            pos += num
            if pos == 0:
                res += 1
        return res

2025-08-22 18:43:10 +0300 MSK

Fri, 22 Aug 2025 18:43:10 +0300

Code

class Solution:
    def triangleType(self, nums: List[int]) -> str:
        s1, s2, s3 = nums
        if s1 == s2 == s3:
            return "equilateral"
        if s1 + s2 <= s3 or s1 + s3 <= s2 or s2 + s3 <= s1:
            return "none"
        if s1 == s2 or s2 == s3 or s1 == s3:
            return "isosceles"
        if s1 != s2 and s2 != s3 and s1 != s3:
            return "scalene"
        return "none"

2025-08-22 18:39:40 +0300 MSK

Fri, 22 Aug 2025 18:39:40 +0300

Code

class Solution:
    def countKeyChanges(self, s: str) -> int:
        res = 0
        for i in range(1, len(s)):
            cur, prev = ord(s[i]), ord(s[i - 1])
            if cur < 97:
                cur += 32
            if prev < 97:
                prev += 32
            if cur != prev:
                res += 1
        return res

2025-08-22 18:38:14 +0300 MSK

Fri, 22 Aug 2025 18:38:14 +0300

Code

class Solution:
    def countKeyChanges(self, s: str) -> int:
        res = 0
        for i in range(1, len(s)):
            cur, prev = s[i].lower(), s[i - 1].lower()
            if cur != prev:
                res += 1
        return res

2025-08-22 18:36:52 +0300 MSK

Fri, 22 Aug 2025 18:36:52 +0300

Code

class Solution:
    def minimumPushes(self, word: str) -> int:
        freqs = [0] * 26
        for char in word:
            freqs[ord(char) - 97] += 1
        freqs.sort()
        res = 0
        for i in range(26):
            freq = freqs[26 - i - 1]
            if freq == 0:
                break
            res += freq * (i // 8 + 1)
        return res

2025-08-22 18:30:44 +0300 MSK

Fri, 22 Aug 2025 18:30:44 +0300

Code

class Solution:
    def minimumPushes(self, word: str) -> int:
        freqs = [0] * 26
        for char in word:
            freqs[ord(char) - 97] += 1
        freqs.sort()
        cost = 1
        res = 0
        while freqs and freqs[-1] != 0:
            for _ in range(8):
                if not freqs:
                    break
                freq = freqs.pop()
                if freq == 0:
                    break
                res += freq * cost
            cost += 1
        return res

2025-08-22 18:25:20 +0300 MSK

Fri, 22 Aug 2025 18:25:20 +0300

Code

class Solution:
    def minimumCost(self, nums: List[int]) -> int:
        nums.reverse()
        first = nums.pop()
        nums.sort()
        return first + sum(nums[:2])

2025-08-22 18:22:55 +0300 MSK

Fri, 22 Aug 2025 18:22:55 +0300

Code

class Solution:
    def areaOfMaxDiagonal(self, dimensions: List[List[int]]) -> int:
        max_diag, max_area = 0, 0
        for length, width in dimensions:
            diag = length ** 2 + width ** 2
            area = length * width
            if diag > max_diag or (diag == max_diag and area > max_area):
                max_diag, max_area = diag, area
        return max_area

2025-08-22 18:19:44 +0300 MSK

Fri, 22 Aug 2025 18:19:44 +0300

Code

class Solution:
    def missingInteger(self, nums: List[int]) -> int:
        s = set(nums)
        x = nums[0] - 1
        seqSum = 0
        for i in nums:
            if i - x == 1:
                seqSum += i
                x = i
            else:
                break
        index = seqSum
        while True:
            if index not in s:
                return index
            index += 1

2025-08-22 17:02:28 +0300 MSK

Fri, 22 Aug 2025 17:02:28 +0300

Code

class Solution:
    def hasTrailingZeros(self, nums: List[int]) -> bool:
        cnt = 0
        for num in nums:
            if num & 1 == 0:
                cnt += 1
                if cnt == 2:
                    return True
        return False

2025-08-22 16:56:33 +0300 MSK

Fri, 22 Aug 2025 16:56:33 +0300

Code

class Solution:
    def numberGame(self, nums: List[int]) -> List[int]:
        res = []
        nums.sort(reverse=True)
        while nums:
            al, bob = nums.pop(), nums.pop()
            res.extend((bob, al))
        return res

2025-08-22 14:49:18 +0300 MSK

Fri, 22 Aug 2025 14:49:18 +0300

Code

class Solution:
    def findMissingAndRepeatedValues(self, grid: List[List[int]]) -> List[int]:
        n = len(grid)
        freqs = [0] * (n ** 2 + 1)
        res1 = None
        for row in grid:
            for num in row:
                freqs[num] += 1
                if freqs[num] == 2:
                    res1 = num
        return res1, freqs[1:].index(0) + 1

2025-08-22 14:41:39 +0300 MSK

Fri, 22 Aug 2025 14:41:39 +0300

Code

class Solution:
    def countTestedDevices(self, batteryPercentages: List[int]) -> int:
        res = 0
        for i, perc in enumerate(batteryPercentages):
            if perc - res > 0:
                res += 1
        return res

2025-08-22 14:33:33 +0300 MSK

Fri, 22 Aug 2025 14:33:33 +0300

Code

class Solution:
    def findIntersectionValues(self, nums1: List[int], nums2: List[int]) -> List[int]:
        freqs1, freqs2 = [0] * 101, [0] * 101
        for num in nums1:
            freqs1[num] += 1
        for num in nums2:
            freqs2[num] += 1
        res1, res2 = 0, 0
        for num, freq in enumerate(freqs1):
            if freqs2[num] > 0:
                res1 += freq
        for num, freq in enumerate(freqs2):
            if freqs1[num] > 0:
                res2 += freq
        return res1, res2

2025-08-22 14:30:04 +0300 MSK

Fri, 22 Aug 2025 14:30:04 +0300

Code

class Solution:
    def findPeaks(self, mountain: List[int]) -> List[int]:
        res = []
        for i in range(1, len(mountain) - 1):
            if mountain[i - 1] < mountain[i] > mountain[i + 1]:
                res.append(i)
        return res

2025-08-22 14:28:05 +0300 MSK

Fri, 22 Aug 2025 14:28:05 +0300

Code

class Solution:
    def areSimilar(self, mat: List[List[int]], k: int) -> bool:
        cols = len(mat[0])
        for row in range(len(mat)):
            is_even = row % 2 == 0
            for col in range(cols):
                if is_even:
                    new_col = (col - k + cols) % cols
                else:
                    new_col = (col + k) % cols
                if mat[row][col] != mat[row][new_col]:
                    return False
        return True

Leetcode submissions on Alwaldend

2026-04-11 20:57:04 +0300 MSK

Links

Code

2026-04-10 21:12:54 +0300 MSK

Links

Code

2026-04-09 22:31:40 +0300 MSK

Links

Code

2026-04-08 20:09:31 +0300 MSK

Links

Code

2026-04-07 20:43:50 +0300 MSK

Links

Code

2026-04-06 20:15:21 +0300 MSK

Links

Code

2026-04-06 20:14:55 +0300 MSK

Links

Code

2026-04-04 20:41:56 +0300 MSK

Links

Code

2026-04-03 22:48:45 +0300 MSK

Links

Code

2026-04-02 19:46:57 +0300 MSK

Links

Code

2026-04-01 20:54:07 +0300 MSK

Links

Code

2026-03-31 23:43:31 +0300 MSK

Links

Code

2026-03-30 19:50:10 +0300 MSK

Links

Code

2026-03-29 23:45:59 +0300 MSK

Links

Code

2026-03-28 19:49:17 +0300 MSK

Links

Code

2026-03-27 09:35:17 +0300 MSK

Links

Code

2026-03-26 21:00:59 +0300 MSK

Links

Code

2026-03-25 23:26:40 +0300 MSK

Links

Code

2026-03-25 23:26:14 +0300 MSK

Links

Code

2026-03-23 21:09:09 +0300 MSK

Links

Code

2026-03-22 15:36:46 +0300 MSK

Links

Code

2026-03-21 19:43:30 +0300 MSK

Links

Code

2026-03-20 19:36:10 +0300 MSK

Links

Code

2026-03-19 23:36:34 +0300 MSK

Links

Code

2026-03-18 20:01:58 +0300 MSK

Links

Code

2026-03-17 21:22:16 +0300 MSK

Links

Code

2026-03-16 21:13:19 +0300 MSK