:squirrel:

Author: angelgladin

.gitignore

@@ -0,0 +1,27 @@
+# General
+.DS_Store
+.AppleDouble
+.LSOverride
+
+# Icon must end with two \r
+Icon
+
+
+# Thumbnails
+._*
+
+# Files that might appear in the root of a volume
+.DocumentRevisions-V100
+.fseventsd
+.Spotlight-V100
+.TemporaryItems
+.Trashes
+.VolumeIcon.icns
+.com.apple.timemachine.donotpresent
+
+# Directories potentially created on remote AFP share
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+.apdisk

add-binary.py

@@ -0,0 +1,32 @@
+# https://leetcode.com/problems/add-binary/
+
+class Solution:
+    def addBinary(self, a: str, b: str) -> str:
+        carry = 0
+        ans = ''
+        i, j = len(a)-1, len(b)-1
+        while i >= 0 or j >= 0:
+            n = carry
+            if i >= 0:
+                n += int(a[i])
+            if j >= 0:
+                n += int(b[j])
+                
+            if n == 3:
+                ans += '1'
+                carry = 1
+            elif n == 2:
+                ans += '0'
+                carry = 1
+            elif n == 1:
+                ans += '1'
+                carry = 0
+            elif n == 0:
+                ans += '0'
+                carry = 0
+            i -= 1
+            j -= 1
+        if carry == 1:
+            ans += '1'
+        
+        return ans[::-1]

add-two-numbers.py

@@ -0,0 +1,31 @@
+# https://leetcode.com/problems/add-two-numbers/
+
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution:
+    def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
+        carry = 0
+        p = ListNode(-1)
+        ans = p
+        while l1 is not None or l2 is not None:
+            aux = carry
+            if l1 is not None:
+                aux += l1.val
+                l1 = l1.next
+            if l2 is not None:
+                aux += l2.val
+                l2 = l2.next
+            if aux > 9:
+                carry = 1
+            else:
+                carry = 0
+            aux_node = ListNode(aux%10)
+            p.next = aux_node
+            p = p.next
+        if carry == 1:
+            p.next = ListNode(1)
+        return ans.next

alien-dictionary.py

@@ -0,0 +1,51 @@
+class Solution:
+    def alienOrder(self, words: List[str]) -> str:
+        from collections import defaultdict
+
+        def build_graph(words):
+            graph = defaultdict(set)
+            indegree = dict()
+
+            for word in words:
+                for c in word:
+                    indegree[c] = 0
+            
+            for i in range(len(words)-1):
+                w1, w2 = words[i], words[i+1]
+                length = min(len(w1), len(w2))
+                for j in range(length):
+                    c1, c2 = w1[j], w2[j]
+                    if c1 != c2:
+                        graph[c1].add(c2)
+                        break
+            
+            for (u, neighbors,) in graph.items():
+                for v in neighbors:
+                    indegree[v] += 1
+                    
+            return (graph, indegree,)
+                
+                
+        def topological_traversal(graph):
+            g = graph[0]
+            indegree = graph[1]
+            
+            ans = []
+            queue = []
+            
+            for (u, k,) in indegree.items():
+                if k == 0:
+                    queue.append(u)
+            
+            while queue:
+                u = queue.pop(0)
+                ans.append(u)
+                for v in g[u]:
+                    indegree[v] -= 1
+                    if indegree[v] == 0:
+                        queue.append(v)
+            
+            return ''.join(ans) if len(ans) == len(indegree) else ''
+
+        g = build_graph(words)
+        return topological_traversal(g)

backspace-string-compare.py

@@ -0,0 +1,25 @@
+# https://leetcode.com/problems/backspace-string-compare/
+
+class Solution:
+    def backspaceCompare(self, S: str, T: str) -> bool:
+        stack1, stack2 = [], []
+        i, j = 0, 0
+        n1, n2, = len(S), len(T)
+
+        while i<n1:
+            if S[i] == '#':
+                if stack1:
+                    stack1.pop()
+            else:
+                stack1.append(S[i])
+            i += 1
+
+        while j<n2:
+            if T[j] == '#':
+                if stack2:
+                    stack2.pop()
+            else:
+                stack2.append(T[j])
+            j += 1
+
+        return stack1 == stack2

binary-search-tree-iterator.py

@@ -0,0 +1,41 @@
+# https://leetcode.com/problems/binary-search-tree-iterator/
+
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class BSTIterator:
+
+    def __init__(self, root: TreeNode):
+        self.stack = []
+        self._left_most_node(root)
+    
+    def _left_most_node(self, node: TreeNode):
+        while node is not None:
+            self.stack.append(node)
+            node = node.left
+
+    def next(self) -> int:
+        """
+        @return the next smallest number
+        """
+        aux = self.stack.pop()
+        if aux.right is not None:
+            self._left_most_node(aux.right)
+        return aux.val
+
+    def hasNext(self) -> bool:
+        """
+        @return whether we have a next smallest number
+        """
+        return len(self.stack) > 0
+        
+
+
+# Your BSTIterator object will be instantiated and called as such:
+# obj = BSTIterator(root)
+# param_1 = obj.next()
+# param_2 = obj.hasNext()

combination-sum-ii.py

@@ -0,0 +1,18 @@
+# https://leetcode.com/problems/combination-sum-ii/
+
+class Solution:
+    def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:
+        def backtrack(l, n, idx, aux, current_sum, k, ans):
+            if current_sum > k:
+                return
+            if current_sum == k:
+                ans.add(tuple(sorted(aux)))
+                return
+            for i in range(idx, n):
+                aux.append(l[i])
+                backtrack(l, n, i+1, aux, current_sum+l[i], k, ans)
+                aux.pop()
+        
+        ans = set()
+        backtrack(candidates, len(candidates), 0, [], 0, target, ans)
+        return list(ans)

confusing-number.py

@@ -0,0 +1,19 @@
+# https://leetcode.com/problems/confusing-number/
+
+class Solution:
+    def confusingNumber(self, N: int) -> bool:
+        invalid = ['2','3','4','5','7']
+        s = str(N)
+        for x in s:
+            if x in invalid:
+                return False
+        m = dict()
+        m['0'] = '0'
+        m['1'] = '1'
+        m['6'] = '9'
+        m['8'] = '8'
+        m['9'] = '6'
+        aux = ''
+        for x in s[::-1]:
+            aux += m[x]
+        return s != aux

design-phone-directory.py

@@ -0,0 +1,41 @@
+# https://leetcode.com/problems/design-phone-directory/
+
+class PhoneDirectory:
+
+    def __init__(self, maxNumbers: int):
+        """
+        Initialize your data structure here
+        @param maxNumbers - The maximum numbers that can be stored in the phone directory.
+        """
+        self.occupied_numbers = set()
+        self.not_occupied_numbers = { x for x in range(maxNumbers) }
+        
+
+    def get(self) -> int:
+        """
+        Provide a number which is not assigned to anyone.
+        @return - Return an available number. Return -1 if none is available.
+        """
+        number = -1
+        for x in self.not_occupied_numbers:
+            number = x
+        if number != -1:
+            self.occupied_numbers.add(number)
+            self.not_occupied_numbers.remove(number)
+        return number
+        
+
+    def check(self, number: int) -> bool:
+        """
+        Check if a number is available or not.
+        """
+        return number in self.not_occupied_numbers
+        
+
+    def release(self, number: int) -> None:
+        """
+        Recycle or release a number.
+        """
+        if number in self.occupied_numbers:
+            self.occupied_numbers.remove(number)
+            self.not_occupied_numbers.add(number)

diameter-of-binary-tree.py

@@ -0,0 +1,23 @@
+# https://leetcode.com/problems/diameter-of-binary-tree/
+
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution:
+    def diameterOfBinaryTree(self, root: TreeNode) -> int:
+        if root is None:
+            return 0
+        self.ans = 0
+        def f(v):
+            if v is None:
+                return 0
+            l_depth = f(v.left)
+            r_depth = f(v.right)
+            self.ans = max(self.ans, l_depth + r_depth + 1)
+            return max(l_depth, r_depth) + 1
+        f(root)
+        return self.ans-1