no message

Author: Chris Wu

README.md

@@ -165,7 +165,11 @@ These are the interview resources I personally used and only if it is really hel
 <https://youtu.be/YJZCUhxNCv8>
 
 3. CS DoJo on "How I Got a Job at Google as a Software Engineer". There are also lots of technique on coding interview in his channel.  
-<https://www.youtube.com/watch?v=UPO-9iMjBpc>
+<https://www.youtube.com/watch?v=UPO-9iMjBpc>  
+
+4. The #1 Daily Habit of Those Who Dominate with Andy Frisella (Also on Spotify or Youtube, just google it.)
+<https://podcasts.apple.com/tw/podcast/the-mfceo-project/id1012570406?i=1000412624447>
+
 
 ## Prepare in a Structural Way
 1. <https://www.quora.com/How-should-I-prepare-for-my-Google-interview-if-I-have-1-month-left-and-I%E2%80%99m-applying-for-a-software-engineer-role/answer/Anthony-D-Mays?ch=10&share=5c488000&srid=W0jqp>
@@ -182,8 +186,8 @@ Basic data structure and algorithm online course taught in Python. This course i
 <https://classroom.udacity.com/courses/ud513>
 
 ## Interview Question Survey
-<https://www.glassdoor.com/index.htm>  
-<https://www.careercup.com/>
+1. <https://www.glassdoor.com/index.htm>
+2. <https://www.careercup.com/>
 
 
 # Interview Knowledge Base Quesion

problems/letter-combinations-of-a-phone-number.py

@@ -0,0 +1,30 @@
+"""
+I put all the posible answer in the `ans`.
+For every digit in the input, we got whole new sets of answers, which is generated from the previous input.
+"""
+class Solution(object):
+    def letterCombinations(self, digits):
+        def helper(A, digit):
+            if not A: return memo[digit]
+
+            opt = []
+            for letter in memo[digit]:
+                for string in A:
+                    opt.append(string+letter)
+            return opt
+
+        ans = []
+        memo = {
+            '2': ['a', 'b', 'c'],
+            '3': ['d', 'e', 'f'],
+            '4': ['g', 'h', 'i'],
+            '5': ['j', 'k', 'l'],
+            '6': ['m', 'n', 'o'],
+            '7': ['p', 'q', 'r', 's'],
+            '8': ['t', 'u', 'v'],
+            '9': ['w', 'x', 'y', 'z']
+        }
+
+        for digit in digits:
+            ans = helper(ans, digit)
+        return ans

problems/score-of-parentheses.py

@@ -0,0 +1,55 @@
+"""
+We parse the content in the parentheses and evaluate it.
+If the content is empty string then the value is 1.
+Otherwise, the value is the value of the content multiply by 2
+And we use the exact the same function to evaluate the value of the content (recursion).
+We can know the start and the end of the parentheses (so we can extract the content) by `depth`, which is the level of parentheses.
+
+Even though this looks efficient the time complexity is high. O(N^depth).
+You can think of a case like this
+```
+(((((((((( ... content ... ))))))))))
+```
+Where in every level you have to go through the whole thing again.
+
+The Space complexity is O(depth).
+Even we only use O(1) in each function, but the recursion takes stack memory of O(depth).
+"""
+class Solution(object):
+    def scoreOfParentheses(self, S):
+        depth = 0
+        start = 0
+        score = 0
+        for i, s in enumerate(S):
+            if s=='(': depth+=1
+            if s==')': depth-=1
+            if depth==0:
+                content = S[start+1:i]
+                if content == '':
+                    score+=1
+                else:
+                    score+=self.scoreOfParentheses(content)*2
+                start = i+1
+        return score
+
+"""
+If we take a closer look, we will notice that `()` are the only structure that provides value, the outer parentheses just add some multiplier.
+So we only need to be concerned with `depth`.
+For level we multiply the inner content by 2, so for each `()`, its value is `1 * 2**depth`
+
+The time complexity is O(N).
+The space complexity is O(1).
+"""
+class Solution(object):
+    def scoreOfParentheses(self, S):
+        score = 0
+        depth = 0
+
+        for i, s in enumerate(S):
+            if s=='(':
+                depth+=1
+            else:
+                depth-=1
+                if S[i-1]=='(':
+                    score+=2**depth
+        return score