20/12/2020

Author: jameszu

Daily-challenge/Dec/19/README.md

@@ -55,26 +55,22 @@ Just do while loop and convert to decimal
 ## Code
 ```python
 class Solution:
-    def decodeString(self, s: str) -> str:
-        stack = []
-        curnum = 0
-        curstring = ''
-        
-        for c in s:
-            if c == '[':
-                stack.append(curstring)
-                stack.append(curnum)
-                curstring = ''
-                curnum = 0
-                
-            elif c == ']':
-                num = stack.pop()
-                prevstring = stack.pop()
-                curstring = prevstring + num* curstring
-            elif c.isdigit():
-                curnum = curnum * 10 + int(c)
-            else:
-                curstring += c
-                
-        return curstring
+    def cherryPickup(self, grid: List[List[int]]) -> int:
+        moves = [(1,-1),(1,0),(1,1)]
+        m,n = len(grid), len(grid[0])
+        @functools.lru_cache(None)
+        def dp(r1,c1,r2,c2):
+            if(c1>c2): return dp(r2,c2,r1,c1)
+            if not (r1<m and r2<m and 0<=c1<n and 0<=c2<n):
+                return float("-inf")
+            if r1==m-1:
+                return grid[r1][c1]+grid[r2][c2] if r1!=r2 or c1!=c2 else 0
+            maxi = 0
+            for d1 in moves:
+                for d2 in moves:
+                    dr1,dc1=r1+d1[0],c1+d1[1]
+                    dr2,dc2=r2+d2[0],c2+d2[1]
+                    maxi = max(maxi, dp(dr1,dc1,dr2,dc2)+grid[r1][c1]+grid[r2][c2] if r1!=r2 or c1!=c2 else 0)
+            return maxi
+        return dp(0,0,0,n-1)
 ```

Daily-challenge/Dec/19/sol.py

@@ -1,23 +1,19 @@
 class Solution:
-    def decodeString(self, s: str) -> str:
-        stack = []
-        curnum = 0
-        curstring = ''
-        
-        for c in s:
-            if c == '[':
-                stack.append(curstring)
-                stack.append(curnum)
-                curstring = ''
-                curnum = 0
-                
-            elif c == ']':
-                num = stack.pop()
-                prevstring = stack.pop()
-                curstring = prevstring + num* curstring
-            elif c.isdigit():
-                curnum = curnum * 10 + int(c)
-            else:
-                curstring += c
-                
-        return curstring
+    def cherryPickup(self, grid: List[List[int]]) -> int:
+        moves = [(1,-1),(1,0),(1,1)]
+        m,n = len(grid), len(grid[0])
+        @functools.lru_cache(None)
+        def dp(r1,c1,r2,c2):
+            if(c1>c2): return dp(r2,c2,r1,c1)
+            if not (r1<m and r2<m and 0<=c1<n and 0<=c2<n):
+                return float("-inf")
+            if r1==m-1:
+                return grid[r1][c1]+grid[r2][c2] if r1!=r2 or c1!=c2 else 0
+            maxi = 0
+            for d1 in moves:
+                for d2 in moves:
+                    dr1,dc1=r1+d1[0],c1+d1[1]
+                    dr2,dc2=r2+d2[0],c2+d2[1]
+                    maxi = max(maxi, dp(dr1,dc1,dr2,dc2)+grid[r1][c1]+grid[r2][c2] if r1!=r2 or c1!=c2 else 0)
+            return maxi
+        return dp(0,0,0,n-1)

Daily-challenge/Dec/20/README.md

@@ -1,22 +1,41 @@
-# Search in Rotated Sorted Array II
-Suppose an array sorted in ascending order is rotated at some pivot unknown to you beforehand.
+# Decoded String at Index
+An encoded string S is given.  To find and write the decoded string to a tape, the encoded string is read one character at a time and the following steps are taken:
 
-(i.e., [0,0,1,2,2,5,6] might become [2,5,6,0,0,1,2]).
+If the character read is a letter, that letter is written onto the tape.
+If the character read is a digit (say d), the entire current tape is repeatedly written d-1 more times in total.
+Now for some encoded string S, and an index K, find and return the K-th letter (1 indexed) in the decoded string.
 
-You are given a target value to search. If found in the array return true, otherwise return false.
+ 
 
 Example 1:
 
-Input: nums = [2,5,6,0,0,1,2], target = 0
-Output: true
+Input: S = "leet2code3", K = 10
+Output: "o"
+Explanation: 
+The decoded string is "leetleetcodeleetleetcodeleetleetcode".
+The 10th letter in the string is "o".
 Example 2:
 
-Input: nums = [2,5,6,0,0,1,2], target = 3
-Output: false
-Follow up:
-
-This is a follow up problem to Search in Rotated Sorted Array, where nums may contain duplicates.
-Would this affect the run-time complexity? How and why?<br>
+Input: S = "ha22", K = 5
+Output: "h"
+Explanation: 
+The decoded string is "hahahaha".  The 5th letter is "h".
+Example 3:
+
+Input: S = "a2345678999999999999999", K = 1
+Output: "a"
+Explanation: 
+The decoded string is "a" repeated 8301530446056247680 times.  The 1st letter is "a".
+ 
+
+Constraints:
+
+2 <= S.length <= 100
+S will only contain lowercase letters and digits 2 through 9.
+S starts with a letter.
+1 <= K <= 10^9
+It's guaranteed that K is less than or equal to the length of the decoded string.
+The decoded string is guaranteed to have less than 2^63 letters.<br>
 
 ## Idea
 Just do while loop and convert to decimal