no message

Author: Chris Wu

problems/decode-string.py

@@ -0,0 +1,58 @@
+#recursion
+#the main idea is to only calculate the mosr outer layer. (which is when stack is empty.)
+#we put all the inner layer to another `decodeString()` to get its value.
+#time: O(N), N is the length of the string.
+#space: O(N).
+class Solution(object):
+    def decodeString(self, s):
+        opt = ''
+        k = ''
+        stack = []
+
+        for i, c in enumerate(s):
+            if c=='[':
+                stack.append(i)
+            elif c==']':
+                i_start = stack.pop()
+                if not stack:
+                    opt += int(k)*self.decodeString(s[i_start+1:i])
+                    k = ''
+            elif c.isdigit() and not stack:
+                k+=c
+            elif not stack:
+                opt+=c
+        return opt or s
+
+#stack
+#as we iterate the string, we will dive into different level of brackets.
+#we store the value of the current level in the `opt`
+#and store the outer level in the stack
+#when we get out of this level, we calculate the value.
+#time: O(N), N is the length of the string.
+#space: O(N).
+class Solution(object):
+    def decodeString(self, s):
+        opt = ''
+        stack = []
+        k = ''
+
+        for c in s:
+            if c=='[':
+                stack.append(opt)
+                stack.append(k)
+                opt = ''
+                k = ''
+            elif c==']':
+                n = stack.pop()
+                pre = stack.pop()
+                opt = pre+int(n)*opt
+            elif c.isdigit():
+                k+=c
+            else:
+                opt+=c
+        return opt
+
+
+
+
+

problems/split-array-into-fibonacci-sequence.py

@@ -1,28 +1,34 @@
 class Solution(object):
     def splitIntoFibonacci(self, S):
-        def findIndex(s, num):
-            for i, c in enumerate(num):
-                if i>=len(s): break
-                if c!=s[i]: break
-                if i==len(num)-1: return i+1
-            return -1
-
-        def search(fab, s):
-            if len(s)==0: return fab
-            if len(fab)<2: return []
-
-            target = fab[-1]+fab[-2]
-            if target>2147483648: return []
-            i = findIndex(s, str(target))
-            if i>0: return search(fab+[target], s[i:])
-            return []
-
-        for i in xrange(1, len(S)-2):
-            for j in xrange(i+1, len(S)-1):
-                #skip leading zero
-                if (S[:i][0]!='0' and S[:i][0]=='0') or (S[i:j][0]!='0' and S[i:j][0]=='0'): continue
-                opt = search([int(S[:i]), int(S[i:j])], S[j:])
-                if len(opt)>0: return opt
-        return []
+        def is_bibonacci(opt, num):
+            return num == opt[-1]+opt[-2]
+
+        def helper(s, first):
+            if first==len(s) and len(opt)>=3:
+                return True
+
+            for i in xrange(first, len(s)):
+                if s[first]=='0' and i!=first: break #skip leading zero
+                num = int(s[first:i+1])
+
+                if num>2147483648: break
+
+                #early termination
+                if len(opt)>=2 and num>opt[-1]+opt[-2]:
+                    break
+
+                if len(opt)<=1 or is_bibonacci(opt, num):
+                    opt.append(int(num))
+                    if helper(s, i+1): return True
+                    opt.pop()
+            return False
+
+        opt = []
+        helper(S, 0)
+        return opt
+
+
+
+