refactor

Author: lilyhe123

src/001.py

@@ -0,0 +1,44 @@
+# uncomments the following line when need to debug stack overflow error
+# import sys
+# sys.setrecursionlimit(10)
+
+# 1 - 50
+"""
+!! question 1
+Given a list of numbers and a number k, return whether any two numbers from
+the list add up to k.
+For example, given [10, 15, 3, 7] and k of 17, return true since 10 + 7 is 17.
+Bonus: Can you do this in one pass?
+-------------------
+
+## Understand the problem
+The input is a list of numbers and a number k, the output is a boolean...
+
+## !! brain storming
+1. brute-force approach
+the most straight-forward approach is to find every possible pair of numbers
+ in the list,
+For every pair check whether the sum is equal to k
+time O(n^2), space O(1)
+
+2. sort the array and use two-pointers to find the pair that sum up to k.
+3, 7, 10, 15
+   ^
+      ^
+18 > 17, 13 < 17, 17 == 17 return true
+Time O(nlgn), space O(1)
+
+3. !!  to do this in one pass? This means we can only iterate the list once.
+ We need an effective way to check whether we've already encountered the
+ complement of the current number needed to reach K.
+So we can introduce a hashset data structure to add all the already-visited
+ numvers to it.
+10, 15, 3, 7
+7   2   14 10       ^
+k=17
+set: [10, 15, 3] return true
+"""
+
+
+def test_1():
+    pass

src/002.py

@@ -0,0 +1,56 @@
+"""
+!! question 2
+Given an array of integers, return a new array such that each element at index
+ i of the new array is the product of all the numbers in the original array
+ except the one at i.
+
+For example, if our input was [1, 2, 3, 4, 5],
+the expected output would be [120, 60, 40, 30, 24].
+If our input was [3, 2, 1], the expected output would be [2, 3, 6].
+
+Follow-up: what if you can't use division?
+-------------------
+
+## brainstorming
+1. brute-force: for every number, calculate the product of all the
+   other number.
+   time O(n^2), space O(1)
+2. in the brute force, we do many duplcated calculation:
+   the product of the same numbers.
+   if we can prevent the duplicated calculation we can optimize it.
+   We can first calculate the product of all the numbers in the array.
+   for every element, we only need to use the current nuber to divide
+   the total product and get the result we need.
+   time O(n), space O(1)
+3. what if we can't use division?
+  brute-force approach doesn't use division, but can we optimize it?
+
+  formula for #2 is totalProduct/currentNumber
+  new formula: product of numbers in its left * product of numbers
+  in its right
+  prefix and suffix products
+  so we need two arrays, the first is the product of left numbers
+  and the second is the product of right numbers.
+  left_prod[i] = arr[0]*arr[1]..*arr[i-1]
+  right_prod[i] = arr[i+1]* arr[i+2]...arr[n-1]
+  output[i] = left_prod[i] * right_prod[i]
+
+  !! optimze space - in-place calculation
+  do the calculation directly in the result
+  result[0] = 1
+  i from 1 to n-1:
+    result[i] = result[i-1] * nums[i-1]
+  prod = 1
+  i form n-2 to 0:
+    prod *= nums[i+1]
+    result[i] *= prod
+
+   time O(n), space O(n)
+
+  edge case: if there is a zero in the input array, the approach without
+  division works correctly without specific handling this case.
+"""
+
+
+def test_2():
+    pass

src/003.py

@@ -0,0 +1,23 @@
+"""
+question 3
+Given the root to a binary tree, implement serialize(root),
+which serializes the tree into a string,
+and deserialize(s), which deserializes the string back into the tree.
+
+For example, given the following Node class
+
+class Node:
+    def __init__(self, val, left=None, right=None):
+        self.val = val
+        self.left = left
+        self.right = right
+
+The following test should pass:
+
+node = Node('root', Node('left', Node('left.left')), Node('right'))
+assert deserialize(serialize(node)).left.left.val == 'left.left'
+"""
+
+
+def test_3():
+    pass

src/004.py

@@ -0,0 +1,44 @@
+"""
+question 4
+Given an array of integers, find the first missing positive integer in linear
+time and constant space. In other words, find the lowest positive integer
+that does not exist in the array. The array can contain duplicates
+and negative numbers as well.
+
+For example, the input [3, 4, -1, 1] should give 2.
+The input [1, 2, 0] should give 3.
+
+You can modify the input array in-place.
+-------------------
+
+ 1  2   3  4
+ 2 3 1 4
+ 1 2 3 4
+[3, 4, -1, 1]
+[1, -1, 3, 4]
+for i in range():
+  val = nums[i]
+  if val in range(1, n+1):
+    # swap elements in i and val+1
+nums[i] = i+1
+"""
+
+
+def findLowest(nums: int) -> int:
+    n = len(nums)
+    for i in range(n):
+        while nums[i] in range(1, n + 1) and i + 1 != nums[i]:
+            # swap element in i and nums[i]-1
+            j = nums[i] - 1
+            tt = nums[i]
+            nums[i] = nums[j]
+            nums[j] = tt
+    for i in range(n):
+        if nums[i] != i + 1:
+            return i + 1
+    return n + 1
+
+
+def test_4():
+    assert findLowest([3, 4, -1, 1]) == 2
+    assert findLowest([1, 2, 0]) == 3

src/005.py

@@ -0,0 +1,45 @@
+"""
+question 5
+cons(a, b) constructs a pair, and car(pair) and cdr(pair) returns the
+first and last element of that pair. For example, car(cons(3, 4)) returns 3,
+and cdr(cons(3, 4)) returns 4.
+
+Given this implementation of cons:
+
+def cons(a, b):
+    def pair(f):
+        return f(a, b)
+    return pair
+Implement car and cdr.
+
+-------------------
+Understand the problem
+cons() return a function 'pair and 'pair' takes another function 'f' as input.
+So car() and cdr() need to provide its own impl of function 'f' and pass it to 'pair'.
+"""
+
+
+def cons(a, b):
+    def pair(f):
+        return f(a, b)
+
+    return pair
+
+
+def car(pair):
+    def getFirst(a, b):
+        return a
+
+    return pair(getFirst)
+
+
+def cdr(pair):
+    def getSecond(a, b):
+        return b
+
+    return pair(getSecond)
+
+
+def test_5():
+    assert car(cons(3, 4)) == 3
+    assert cdr(cons(3, 4)) == 4

src/006.py

@@ -0,0 +1,19 @@
+"""
+question 6
+An XOR linked list is a more memory efficient doubly linked list.
+Instead of each node holding next and prev fields, it holds a field
+named both, which is an XOR of the next node and the previous node.
+Implement an XOR linked list; it has an add(element) which adds the
+element to the end, and a get(index) which returns the node at index.
+
+If using a language that has no pointers (such as Python), you can assume
+you have access to get_pointer and dereference_pointer functions that
+converts between nodes and memory addresses.
+
+both: an XOR of the next node and the pre node.
+how to get next node and pre node by both field?
+"""
+
+
+def test_6():
+    pass

src/007.py

@@ -0,0 +1,60 @@
+"""
+question 7
+Given the mapping a = 1, b = 2, ... z = 26, and an encoded message, count
+ the number of ways it can be decoded.
+
+For example, the message '111' would give 3, since it could be decoded
+as 'aaa', 'ka', and 'ak'.
+
+You can assume that the messages are decodable. For example,
+'001' is not allowed.
+-------------------
+
+[1, 26] valid code
+'1234'
+  ^
+f('n1n2...ni'):
+  count = 0
+  if int('n1') in range(1, 10):
+    count += f('n2...ni')
+  if int('n1n2') in range(10, 27):
+    count += f('n3...ni')
+
+dp = [0] * len(msg)
+'d1d2d3....dn'
+
+if d1>0: dp(0) = 1
+
+if d2>0: dp(1) += dp(0)
+if d1d2 in range(10, 27):
+  dp(1) += 1
+
+for i in range(2, len(msg)):
+   if int(msg[i]) > 0:
+     dp[i] += dp[i-1]
+    if int(msg[i-1:i+1]) in range(10, 27):
+      dp[i] += dp[i-2]
+ return dp[len(msg)-1]
+"""
+
+
+def getDecodingWays(msg: str) -> int:
+    dp0, dp1, dp2 = 1, 0, 0
+    # '111' 1,2,3
+    if int(msg[0]) > 0:
+        dp1 = 1
+
+    for i in range(1, len(msg)):
+        if int(msg[i]) > 0:
+            dp2 += dp1
+        if int(msg[i - 1 : i + 1]) in range(10, 27):
+            dp2 += dp0
+        dp0 = dp1
+        dp1 = dp2
+        dp2 = 0
+    return dp1
+
+
+def test_7():
+    assert getDecodingWays("111") == 3
+    assert getDecodingWays("1111111") == 21

src/008.py

@@ -0,0 +1,86 @@
+"""
+question 8
+A unival tree (which stands for "universal value") is a tree where
+all nodes under it have the same value.
+Given the root to a binary tree, count the number of unival subtrees.
+For example, the following tree has 5 unival subtrees:
+   0
+  / \
+ 1   0
+    / \
+   1   0
+  / \
+ 1   1
+-------------------
+
+first element means whether the tree is unival tree or not.
+second element means the number of unival tree in this tree
+ [True|False, int]
+
+ f(node):
+   if isLeaf: return [True, 0]
+
+   if node.left:
+     return [False, f(node.left)[1]]
+   elif node.right:
+     return [False, f(node.right)[1]]
+   # both left and right not None
+
+"""
+
+
+class TreeNode:
+    def __init__(self, val: int, left: object = None, right: object = None):
+        self.val = val
+        self.left = left
+        self.right = right
+
+    def print(self):
+        print(self.val)
+
+    def print_inorder(self):
+        if self.left:
+            self.print_inorder(self.left)
+        self.print()
+        if self.right:
+            self.print_inorder(self.right)
+
+
+def getUnivalTreeNum(node: object) -> int:
+    def dfs(node: object) -> list:
+        if not node:
+            return [True, 0]
+        # leaf node
+        if not node.left and not node.right:
+            return [True, 1]
+
+        # handle one subtree is None.
+        if not node.left:
+            return [False, dfs(node.right)[1]]
+        elif not node.right:
+            return [False, dfs(node.left)[1]]
+
+        # handle both subtrees are not None
+        rtn = dfs(node.left)
+        isLeftUnival, leftCount = rtn
+        rtn = dfs(node.right)
+        isRightUnival, rightCount = rtn
+        total = leftCount + rightCount
+        isUnival = False
+        if isLeftUnival and isRightUnival and node.left.val == node.right.val:
+            isUnival = True
+            total += 1
+        return [isUnival, total]
+
+    return dfs(node)[1]
+
+
+def test_8():
+    root = TreeNode(
+        0,
+        left=TreeNode(1),
+        right=TreeNode(
+            0, left=TreeNode(1, left=TreeNode(1), right=TreeNode(1)), right=TreeNode(0)
+        ),
+    )
+    assert getUnivalTreeNum(root) == 5