A. A Number After a Double Reversal (opens new window)

Check if it has any trailing 0.

DETAILS

bool isSameAfterReversals(int num) {
    return num == 0 || num % 10;
}

public boolean isSameAfterReversals(int num) {
         return num == 0 || num % 10 != 0;
    }

def isSameAfterReversals(self, num: int) -> bool:
        return num == 0 or str(num)[-1] != '0'

B. Execution of All Suffix Instructions Staying in a Grid (opens new window)

Do as it says.

DETAILS

def executeInstructions(self, n: int, startPos: List[int], s: str) -> List[int]:
        dirs = {'R': (0, 1), 'L': (0, -1), 'U': (-1, 0), 'D': (1, 0)}
        def helper(idx):
            ans = 0
            cx, cy = startPos
            for d in s[idx:]:
                dx, dy = dirs[d]
                if 0 <= cx + dx < n and 0 <= cy + dy < n:
                    cx += dx
                    cy += dy
                    ans += 1
                else:
                    return ans
            return ans
        
        ans = []
        for i in range(len(s)):
            ans.append(helper(i))
        
        return ans

C. Intervals Between Identical Elements (opens new window)

Prefix.

DETAILS

 def getDistances(self, arr: List[int]) -> List[int]:
        pos = collections.defaultdict(list)
        for i, x in enumerate(arr):
            pos[x].append(i)
            
        def helper(A):
            n = len(A)
            if n == 1: return [0]
            cur = 0
            for i in range(1, n):
                cur += A[i] - A[0]
            ans = [cur]
            for i in range(1, n):
                cur += (A[i] - A[i - 1]) * (2 * i - n)
                ans.append(cur)
            return ans
        
        res = {i : helper(pos[i]) for i in pos.keys()}
        idx = {i : 0 for i in pos.keys()}
        
        ans = []
        for i, a in enumerate(arr):
            ans.append(res[a][idx[a]])
            idx[a] += 1
        return ans

D. Recover the Original Array (opens new window)

DETAILS

def recoverArray(self, A: List[int]) -> List[int]:
        n = len(A)
        A.sort()
        
        def helper(k):
            c = collections.Counter(A)
            for key in A:
                if c[key] == 0: continue
                if c[key + k] == 0: return False
                else:
                    c[key] -= 1
                    c[key + k] -= 1
            return True
        
        start = A[0]
        for i in range(1, n):
            if (A[i] - A[0]) % 2 == 0 and A[i] - A[0] > 0:
                if helper(A[i] - A[0]):
                    ans = []
                    k = A[i] - A[0]
                    c = collections.Counter(A)
                    for key in A:
                        if c[key] == 0: 
                            continue
                        else:
                            ans.append(key + k // 2)
                            c[key] -= 1
                            c[key + k] -= 1
                    return ans