alphaCoder

setup adb

Add platform-tools to your path

echo 'export ANDROID_HOME=/Users/$USER/Library/Android/sdk' >> ~/.bash_profile
echo 'export PATH=${PATH}:$ANDROID_HOME/tools:$ANDROID_HOME/platform-tools' >> ~/.bash_profile

Refresh your bash profile (or restart your terminal app)

source ~/.bash_profile

alphaCoder

class Solution:
    def findOrder(self, numCourses: int, prerequisites: List[List[int]]) -> List[int]:
        marked = set()
        order = []
        g = {}
        cycle = False
        onStack = [False for _ in range(numCourses)]

        for v in range(numCourses):
            g[v] = set()

alphaCoder

class Solution:
    def solve(self, board: List[List[str]]) -> None:
        if not board or len(board) == 0:
            return
        
        topRow, bottomRow = 0, len(board) - 1
        leftBorder, rightBorder = 0, len(board[0]) - 1
       
        def inBounds(i, j):
            return i >= topRow and i <= bottomRow and j >= leftBorder and j <= rightBorder

alphaCoder

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def isValidBST(self, root: TreeNode) -> bool:
        def helper(tree, mi, mx):

alphaCoder

class Solution:
    def merge(self, intervals: List[List[int]]) -> List[List[int]]:
        if len(intervals) < 2:
            return intervals
        res = []
        for pair in sorted(intervals, key = lambda p:p[0]):
            if res and res[-1][1] >= pair[0]:
                res[-1][1] = max(res[-1][1], pair[1])
            else:
                res.extend([pair])

alphaCoder

class Solution:
    def merge(self, intervals: List[List[int]]) -> List[List[int]]:
        if len(intervals) < 2:
            return intervals
        res = []
        for pair in sorted(intervals, key = lambda p:p[0]):
            if res and res[-1][1] >= pair[0]:
                res[-1][1] = max(res[-1][1], pair[1])
            else:
                res.extend([pair])

alphaCoder

from collections import OrderedDict
class LRUCache:

    def __init__(self, capacity: int):
        self.capacity = capacity
        self.cache = OrderedDict()

    def get(self, key: int) -> int:
        val = -1
        if key in self.cache:

alphaCoder

class Solution:
    def reorderLogFiles(self, logs: List[str]) -> List[str]:
        digits = []
        letters = []
        for log in logs:
            if log.split()[1].isdigit():
                digits.append(log)
            else:
                letters.append(log)
        letters.sort(key=lambda x: x.split()[0])

alphaCoder

class Solution:
    def isValid(self, s: str) -> bool:
        stack = []
        bracketsMap = {"(": ")", "{": "}", "[": "]" }
        for k in s:
            if k in bracketsMap:
                stack.append(k)
            else:
                if not stack:
                    return False

alphaCoder

class Solution:
    def isValid(self, s: str) -> bool:
        stack = []
        for i, k in enumerate(s):
            if k == '{' or k == '(' or k == '[':
                stack.append(k)
            else:
                if not stack:
                    return False
                else: