22/12/2020

Author: jameszu

Daily-challenge/Dec/21/README.md

@@ -1,37 +1,50 @@
-# class Solution(object):
-    def decodeAtIndex(self, S, K):
-        size = 0
-        # Find size = length of decoded string
-        for c in S:
-            if c.isdigit():
-                size *= int(c)
-            else:
-                size += 1
-
-        for c in reversed(S):
-            K %= size
-            if K == 0 and c.isalpha():
-                return c
-
-            if c.isdigit():
-                size /= int(c)
-            else:
-                size -= 1<br>
+# Smallest Range II
 
+Solution
+Given an array A of integers, for each integer A[i] we need to choose either x = -K or x = K, and add x to A[i] (only once).
+
+After this process, we have some array B.
+
+Return the smallest possible difference between the maximum value of B and the minimum value of B.
+
+ 
+
+Example 1:
+
+Input: A = [1], K = 0
+Output: 0
+Explanation: B = [1]
+Example 2:
+
+Input: A = [0,10], K = 2
+Output: 6
+Explanation: B = [2,8]
+Example 3:
+
+Input: A = [1,3,6], K = 3
+Output: 3
+Explanation: B = [4,6,3]
+ 
+
+Note:
+
+1 <= A.length <= 10000
+0 <= A[i] <= 10000
+0 <= K <= 10000
 ## Idea
 Just do while loop and convert to decimal
 
 ## Code
 ```python
 class Solution:
-    def atMostNGivenDigitSet(self, D: List[str], N: int) -> int:
-        N = str(N)
-        n = len(N)
-        res = sum(len(D) ** i for i in range(1, n))
-        i = 0
-        while i < len(N):
-            res += sum(c < N[i] for c in D) * (len(D) ** (n - i - 1))
-            if N[i] not in D: break
-            i += 1
-        return res + (i == n)
+    def smallestRangeII(self, A, K):
+        A.sort()
+        res = A[-1] - A[0]
+        
+        for i in range(len(A) - 1):
+            big = max(A[-1], A[i] + 2 * K)
+            small = min(A[i+1], A[0] + 2 * K)
+            res = min(res, big - small)
+        return res
+        
 ```

Daily-challenge/Dec/21/sol.py

@@ -1,11 +1,11 @@
 class Solution:
-    def atMostNGivenDigitSet(self, D: List[str], N: int) -> int:
-        N = str(N)
-        n = len(N)
-        res = sum(len(D) ** i for i in range(1, n))
-        i = 0
-        while i < len(N):
-            res += sum(c < N[i] for c in D) * (len(D) ** (n - i - 1))
-            if N[i] not in D: break
-            i += 1
-        return res + (i == n)
+    def smallestRangeII(self, A, K):
+        A.sort()
+        res = A[-1] - A[0]
+        
+        for i in range(len(A) - 1):
+            big = max(A[-1], A[i] + 2 * K)
+            small = min(A[i+1], A[0] + 2 * K)
+            res = min(res, big - small)
+        return res
+        

Daily-challenge/Dec/22/README.md

@@ -1,30 +1,32 @@
-# Unique Morse Code Words
-International Morse Code defines a standard encoding where each letter is mapped to a series of dots and dashes, as follows: "a" maps to ".-", "b" maps to "-...", "c" maps to "-.-.", and so on.
+# Balanced Binary Tree
+Given a binary tree, determine if it is height-balanced.
 
-For convenience, the full table for the 26 letters of the English alphabet is given below:
+For this problem, a height-balanced binary tree is defined as:
 
-[".-","-...","-.-.","-..",".","..-.","--.","....","..",".---","-.-",".-..","--","-.","---",".--.","--.-",".-.","...","-","..-","...-",".--","-..-","-.--","--.."]
-Now, given a list of words, each word can be written as a concatenation of the Morse code of each letter. For example, "cab" can be written as "-.-..--...", (which is the concatenation "-.-." + ".-" + "-..."). We'll call such a concatenation, the transformation of a word.
+a binary tree in which the left and right subtrees of every node differ in height by no more than 1.
 
-Return the number of different transformations among all words we have.
+ 
 
-Example:
-Input: words = ["gin", "zen", "gig", "msg"]
-Output: 2
-Explanation: 
-The transformation of each word is:
-"gin" -> "--...-."
-"zen" -> "--...-."
-"gig" -> "--...--."
-"msg" -> "--...--."
+Example 1:
 
-There are 2 different transformations, "--...-." and "--...--.".
-Note:
 
-The length of words will be at most 100.
-Each words[i] will have le
-gth in range [1, 12].
-words[i] will only consist of lowercase letters.<br>
+Input: root = [3,9,20,null,null,15,7]
+Output: true
+Example 2:
+
+
+Input: root = [1,2,2,3,3,null,null,4,4]
+Output: false
+Example 3:
+
+Input: root = []
+Output: true
+ 
+
+Constraints:
+
+The number of nodes in the tree is in the range [0, 5000].
+-104 <= Node.val <= 104<br>
 
 ## Idea
 Just do while loop and convert to decimal