class Solution:
    def separateDigits(self, nums: List[int]) -> List[int]:
        result = []
        
        for num in nums:
            digits = []
            while num > 0:
                digits.append(num % 10)  # Extract the last digit
                num //= 10  # Remove the last digit
            
            result.extend(digits[::-1])  # Reverse to maintain order
        
        return result

class Solution:
    def fizzBuzz(self, n: int) -> List[str]:
        return ["FizzBuzz" if i % 3 == 0 and i % 5 == 0 else
                "Fizz" if i % 3 == 0 else
                "Buzz" if i % 5 == 0 else str(i)
                for i in range(1, n + 1)]

class Solution:
    def passThePillow(self, n: int, time: int) -> int:
        cycle = (time % (2 * (n - 1)))
        return n - abs(n - 1 - cycle)

class Solution:
    def finalValueAfterOperations(self, operations: List[str]) -> int:
        return sum(1 if '+' in op else -1 for op in operations)

class Solution:
    def transformedArray(self, arr: List[int]) -> List[int]:
        while True:
            new_arr = arr[:]
            changed = False
            for i in range(1, len(arr) - 1):
                new_val = (arr[i-1] + arr[i+1]) // 2
                if new_val != arr[i]:
                    new_arr[i] = new_val
                    changed = True
            if not changed:
                return arr
            arr = new_arr

class Solution:
    def getLucky(self, s: str, k: int) -> int:
        num = ''.join(str(ord(c) - ord('a') + 1) for c in s)
        for _ in range(k):
            num = str(sum(int(d) for d in num))
        return int(num)

class Solution:
    def lengthOfLastWord(self, s: str) -> int:
        return len(s.strip().split()[-1])

🟢 Time Complexity: O(n)  
🟢 Space Complexity: O(1)  

---

▎2️⃣ Find Three Consecutive Integers That Sum to a Given Number (Problem Link)

Problem: Find three consecutive integers whose sum equals num. If not possible, return an empty array.  

Python Solution:  

class Solution:
    def sumOfThree(self, num: int) -> List[int]:
        if num % 3 != 0:
            return []
        x = num // 3
        return [x - 1, x, x + 1]

🟢 Time Complexity: O(1)  
🟢 Space Complexity: O(1)  

---

▎3️⃣ Rotate String (Problem Link)

Problem: Given two strings s and goal, check if s can become goal after some number of left rotations.  

Python Solution:  

class Solution:
    def rotateString(self, s: str, goal: str) -> bool:
        return len(s) == len(goal) and goal in (s + s)

🟢 Time Complexity: O(n)  
🟢 Space Complexity: O(n)  

---

class Solution:
    def rotateString(self, s: str, goal: str) -> bool:
        if len(s) != len(goal):
            return False
        return goal in (s + s)

class Solution:
    def findDiagonalOrder(self, matrix: List[List[int]]) -> List[int]:
        # Check for empty matrix
        if not matrix or not matrix[0]:
            return []
        
        m, n = len(matrix), len(matrix[0])
        result = []
        row, col = 0, 0
        # direction = 1 means moving up-right; direction = -1 means moving down-left.
        direction = 1
        
        while len(result) < m * n:
            result.append(matrix[row][col])
            
            if direction == 1:  # Moving up-right.
                # If we're at the last column, we can only go down.
                if col == n - 1:
                    row += 1
                    direction = -1
                # If we're at the top row, we can only go right.
                elif row == 0:
                    col += 1
                    direction = -1
                else:
                    row -= 1
                    col += 1
            else:  # direction == -1, Moving down-left.
                # If we're at the bottom row, we can only go right.
                if row == m - 1:
                    col += 1
                    direction = 1
                # If we're at the first column, we can only go down.
                elif col == 0:
                    row += 1
                    direction = 1
                else:
                    row += 1
                    col -= 1
        
        return result

total = (sum on main diagonal) + (sum on anti-diagonal) - (value of cell)

def solve():
    import sys
    input = sys.stdin.readline

    t = int(input())
    for _ in range(t):
        n, m = map(int, input().split())
        board = [list(map(int, input().split())) for _ in range(n)]
        
        diag_main = {}  # Sums for main diagonal (i - j)
        diag_anti = {}  # Sums for anti-diagonal (i + j)
        
        # Precompute the sums for both types of diagonals
        for i in range(n):
            for j in range(m):
                d1 = i - j
                d2 = i + j
                diag_main[d1] = diag_main.get(d1, 0) + board[i][j]
                diag_anti[d2] = diag_anti.get(d2, 0) + board[i][j]
        
        max_sum = 0
        # Evaluate maximum bishop sum for every possible cell placement
        for i in range(n):
            for j in range(m):
                d1 = i - j
                d2 = i + j
                # Sum of both diagonals minus the overlapping cell (i, j)
                total = diag_main[d1] + diag_anti[d2] - board[i][j]
                if total > max_sum:
                    max_sum = total
        print(max_sum)

if __name__ == "__main__":
    solve()

▎Summary of the Approach in Simple Terms:

1. For each cell, determine which main and anti-diagonals it belongs to.

2. Sum all values on each diagonal.

3. For each cell, the bishop's attack sum equals the sum of its main diagonal plus the sum of its anti-diagonal, minus the cell’s own value (to correct for double counting).

4. Find the maximum of these sums over all cells.

def findMaxLength(nums):
    # Replace 0 with -1 for transformation
    for i in range(len(nums)):
        if nums[i] == 0:
            nums[i] = -1

    cumulative_sum = 0
    max_length = 0
    sum_index_map = {}  # To store the first occurrence of each cumulative sum

    for i, num in enumerate(nums):
        cumulative_sum += num

        # Check if cumulative_sum is 0, which means subarray from index 0 to i is valid
        if cumulative_sum == 0:
            max_length = i + 1

        # If cumulative_sum has been seen before, update max_length accordingly
        if cumulative_sum in sum_index_map:
            max_length = max(max_length, i - sum_index_map[cumulative_sum])
        else:
            sum_index_map[cumulative_sum] = i

    return max_length

# Testing the function with provided examples
print(findMaxLength([0, 1]))    # Output: 2
print(findMaxLength([0, 1, 0])) # Output: 2

class Solution:
    def findMaxLength(self, nums: List[int]) -> int:
        s = {0:-1}
        t = 0
        maxm = 0
        c1 = 0
        c0 = 0
        for i in range(len(nums)):
            if nums[i]:
                c1+=1
            else:
                c0+=1
            if c1-c0 not in s:
                s[c1-c0] = i
            else:
                maxm = max(maxm,i-s[c1-c0])
        return maxm