01/12/2020

Author: jameszu

Daily-challenge/Dec/01/README.md

@@ -0,0 +1,50 @@
+# Maximum Depth of Binary Tree
+Given the root of a binary tree, return its maximum depth.
+
+A binary tree's maximum depth is the number of nodes along the longest path from the root node down to the farthest leaf node.
+
+ 
+
+Example 1:
+
+
+Input: root = [3,9,20,null,null,15,7]
+Output: 3
+Example 2:
+
+Input: root = [1,null,2]
+Output: 2
+Example 3:
+
+Input: root = []
+Output: 0
+Example 4:
+
+Input: root = [0]
+Output: 1
+ 
+
+Constraints:
+
+The number of nodes in the tree is in the range [0, 104].
+-100 <= Node.val <= 100<br>
+
+## Idea
+Just do while loop and convert to decimal
+
+## Code
+```python
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution:
+    def getDecimalValue(self, head: ListNode) -> int:
+        string = ""
+        while head:
+            string += str(head.val)
+            head = head.next
+        # print(string)
+        return int(string, 2)
+```

Daily-challenge/Dec/01/sol.py

@@ -0,0 +1,12 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution:
+    def getDecimalValue(self, head: ListNode) -> int:
+        ans = ''
+        while head:
+            ans += str(head.val)
+            head = head.next
+        return int(ans, 2)

Daily-challenge/Dec/02/README.md

@@ -0,0 +1,52 @@
+# Insertion Sort List
+
+
+Sort a linked list using insertion sort.
+
+
+A graphical example of insertion sort. The partial sorted list (black) initially contains only the first element in the list.
+With each iteration one element (red) is removed from the input data and inserted in-place into the sorted list
+ 
+
+Algorithm of Insertion Sort:
+
+Insertion sort iterates, consuming one input element each repetition, and growing a sorted output list.
+At each iteration, insertion sort removes one element from the input data, finds the location it belongs within the sorted list, and inserts it there.
+It repeats until no input elements remain.
+
+Example 1:
+
+Input: 4->2->1->3
+Output: 1->2->3->4
+Example 2:
+
+Input: -1->5->3->4->0
+Output: -1->0->3->4->5 <br>
+
+## Idea
+two ways, one is to use a list and cheat, or we can use standard while loop and extra space for the dummy nodes and etc.
+## Code
+```python
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution:
+    def insertionSortList(self, head: ListNode) -> ListNode:
+        dum = ListNode(0)
+        prev = dum
+        
+        while head:
+            temp = head.next
+            if prev.val >= head.val:
+                prev = dum
+            while prev.next and prev.next.val < head.val:
+                prev = prev.next
+                
+            head.next = prev.next
+            prev.next = head
+            head = temp
+        return dum.next
+        
+```

Daily-challenge/Dec/02/sol.py

@@ -0,0 +1,44 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution:
+    def insertionSortList(self, head: ListNode) -> ListNode:
+        mylist=[]
+        ptr=head
+        while ptr:
+            mylist.append(ptr.val)
+            ptr=ptr.next
+            
+        mylist.sort()
+        
+        ptr=head
+        for val in mylist:
+            ptr.val=val
+            ptr=ptr.next
+            
+        return head
+
+# Definition for singly-linked list.
+class ListNode:
+    def __init__(self, val=0, next=None):
+        self.val = val
+        self.next = next
+class Solution:
+    def insertionSortList(self, head: ListNode) -> ListNode:
+        dum = ListNode(0)
+        prev = dum
+        
+        while head:
+            temp = head.next
+            if prev.val >= head.val:
+                prev = dum
+            while prev.next and prev.next.val < head.val:
+                prev = prev.next
+                
+            head.next = prev.next
+            prev.next = head
+            head = temp
+        return dum.next
+        

Daily-challenge/Dec/03/README.md

@@ -0,0 +1,60 @@
+# Consecutive Characters
+
+Solution
+Given a string s, the power of the string is the maximum length of a non-empty substring that contains only one unique character.
+
+Return the power of the string.
+
+ 
+
+Example 1:
+
+Input: s = "leetcode"
+Output: 2
+Explanation: The substring "ee" is of length 2 with the character 'e' only.
+Example 2:
+
+Input: s = "abbcccddddeeeeedcba"
+Output: 5
+Explanation: The substring "eeeee" is of length 5 with the character 'e' only.
+Example 3:
+
+Input: s = "triplepillooooow"
+Output: 5
+Example 4:
+
+Input: s = "hooraaaaaaaaaaay"
+Output: 11
+Example 5:
+
+Input: s = "tourist"
+Output: 1
+ 
+
+Constraints:
+
+1 <= s.length <= 500
+s contains only lowercase English letters. <br>
+
+## Idea
+Just a while loop or for loop is fine
+
+## Code
+
+```python
+class Solution:
+    def maxPower(self, s: str) -> int:
+        i = 1
+        n = len(s)
+        count = 1
+        res = 1
+        while i < n:
+            if s[i] == s[i-1]:
+                count += 1
+                res = max(res, count)
+            else:
+                # res = max(res, count)
+                count = 1
+            i += 1
+        return res
+```

Daily-challenge/Dec/03/sol.py

@@ -0,0 +1,15 @@
+class Solution:
+    def maxPower(self, s: str) -> int:
+        i = 1
+        n = len(s)
+        count = 1
+        res = 1
+        while i < n:
+            if s[i] == s[i-1]:
+                count += 1
+                res = max(res, count)
+            else:
+                # res = max(res, count)
+                count = 1
+            i += 1
+        return res

Daily-challenge/Dec/04/README.md

@@ -0,0 +1,65 @@
+# Minimum Height Trees
+
+Solution
+A tree is an undirected graph in which any two vertices are connected by exactly one path. In other words, any connected graph without simple cycles is a tree.
+
+Given a tree of n nodes labelled from 0 to n - 1, and an array of n - 1 edges where edges[i] = [ai, bi] indicates that there is an undirected edge between the two nodes ai and bi in the tree, you can choose any node of the tree as the root. When you select a node x as the root, the result tree has height h. Among all possible rooted trees, those with minimum height (i.e. min(h))  are called minimum height trees (MHTs).
+
+Return a list of all MHTs' root labels. You can return the answer in any order.
+
+The height of a rooted tree is the number of edges on the longest downward path between the root and a leaf.
+
+ 
+
+Example 1:
+
+
+Input: n = 4, edges = [[1,0],[1,2],[1,3]]
+Output: [1]
+Explanation: As shown, the height of the tree is 1 when the root is the node with label 1 which is the only MHT.
+Example 2:
+
+
+Input: n = 6, edges = [[3,0],[3,1],[3,2],[3,4],[5,4]]
+Output: [3,4]
+Example 3:
+
+Input: n = 1, edges = []
+Output: [0]
+Example 4:
+
+Input: n = 2, edges = [[0,1]]
+Output: [0,1]
+ 
+
+Constraints:
+
+1 <= n <= 2 * 104
+edges.length == n - 1
+0 <= ai, bi < n
+ai != bi
+All the pairs (ai, bi) are distinct.
+The given input is guaranteed to be a tree and there will be no repeated edges. <br>
+
+## Idea
+It is a really really hard one for me
+
+## Code
+```python
+class Solution:
+    def findMinHeightTrees(self, n, edges):
+        neighbors = collections.defaultdict(set)
+        for v, w in edges:
+            neighbors[v].add(w)
+            neighbors[w].add(v)
+        def maxpath(v, visited):
+            visited.add(v)
+            paths = [maxpath(w, visited) for w in neighbors[v] if w not in visited]
+            path = max(paths or [[]], key=len)
+            path.append(v)
+            return path
+        path = maxpath(0, set())
+        path = maxpath(path[0], set())
+        m = len(path)
+        return path[(m-1)//2:m//2+1]
+```

Daily-challenge/Dec/04/sol.py

@@ -0,0 +1,16 @@
+class Solution:
+    def findMinHeightTrees(self, n, edges):
+        neighbors = collections.defaultdict(set)
+        for v, w in edges:
+            neighbors[v].add(w)
+            neighbors[w].add(v)
+        def maxpath(v, visited):
+            visited.add(v)
+            paths = [maxpath(w, visited) for w in neighbors[v] if w not in visited]
+            path = max(paths or [[]], key=len)
+            path.append(v)
+            return path
+        path = maxpath(0, set())
+        path = maxpath(path[0], set())
+        m = len(path)
+        return path[(m-1)//2:m//2+1]

Daily-challenge/Dec/05/README.md

@@ -0,0 +1,51 @@
+# Minimum Cost to Move Chips to The Same Position
+We have n chips, where the position of the ith chip is position[i].
+
+We need to move all the chips to the same position. In one step, we can change the position of the ith chip from position[i] to:
+
+position[i] + 2 or position[i] - 2 with cost = 0.
+position[i] + 1 or position[i] - 1 with cost = 1.
+Return the minimum cost needed to move all the chips to the same position.
+
+ 
+
+Example 1:
+
+
+Input: position = [1,2,3]
+Output: 1
+Explanation: First step: Move the chip at position 3 to position 1 with cost = 0.
+Second step: Move the chip at position 2 to position 1 with cost = 1.
+Total cost is 1.
+Example 2:
+
+
+Input: position = [2,2,2,3,3]
+Output: 2
+Explanation: We can move the two chips at poistion 3 to position 2. Each move has cost = 1. The total cost = 2.
+Example 3:
+
+Input: position = [1,1000000000]
+Output: 1
+ 
+
+Constraints:
+
+1 <= position.length <= 100
+1 <= position[i] <= 10^9<br>
+## Idea
+It is really intestring, it is not a good question. THere is a very very simple solution but u need to be really abstract
+## Code
+```python
+class Solution:
+    def minCostToMoveChips(self, position: List[int]) -> int:
+        eve = 0
+        odd = 0
+        for i in position:
+            if i % 2 == 0:
+                eve += 1
+            else:
+                odd += 1
+                
+        return min(eve, odd)
+```

Daily-challenge/Dec/05/sol.py

@@ -0,0 +1,11 @@
+class Solution:
+    def minCostToMoveChips(self, position: List[int]) -> int:
+        eve = 0
+        odd = 0
+        for i in position:
+            if i % 2 == 0:
+                eve += 1
+            else:
+                odd += 1
+                
+        return min(eve, odd)