idk

Author: jameszu

Daily-challenge/2021/Jan/04/README.md

@@ -1,56 +1,52 @@
-# The kth Factor of n
-Given two positive integers n and k.
+# Merge Two Sorted Lists
 
-A factor of an integer n is defined as an integer i where n % i == 0.
-
-Consider a list of all factors of n sorted in ascending order, return the kth factor in this list or return -1 if n has less than k factors.
+Solution
+Merge two sorted linked lists and return it as a sorted list. The list should be made by splicing together the nodes of the first two lists.
 
 
 
 Example 1:
 
-Input: n = 12, k = 3
-Output: 3
-Explanation: Factors list is [1, 2, 3, 4, 6, 12], the 3rd factor is 3.
+
+Input: l1 = [1,2,4], l2 = [1,3,4]
+Output: [1,1,2,3,4,4]
 Example 2:
 
-Input: n = 7, k = 2
-Output: 7
-Explanation: Factors list is [1, 7], the 2nd factor is 7.
+Input: l1 = [], l2 = []
+Output: []
 Example 3:
 
-Input: n = 4, k = 4
-Output: -1
-Explanation: Factors list is [1, 2, 4], there is only 3 factors. We should return -1.
-Example 4:
-
-Input: n = 1, k = 1
-Output: 1
-Explanation: Factors list is [1], the 1st factor is 1.
-Example 5:
-
-Input: n = 1000, k = 3
-Output: 4
-Explanation: Factors list is [1, 2, 4, 5, 8, 10, 20, 25, 40, 50, 100, 125, 200, 250, 500, 1000].
+Input: l1 = [], l2 = [0]
+Output: [0]
 
 
 Constraints:
 
-1 <= k <= n <= 1000 <br>
+The number of nodes in both lists is in the range [0, 50].
+-100 <= Node.val <= 100
+Both l1 and l2 are sorted in non-decreasing order. <br>
 
 ## Idea
 It is a really really hard one for me
 
 ## 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 kthFactor(self, n: int, k: int) -> int:
-        lst = []
-        
-        for i in range(1, n+1):
-            if n % i == 0:
-                lst += [i]
-        if len(lst) < k:
-            return -1
-        return lst[k-1]
+    def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
+        dummny = cur = ListNode(0)
+        while l1 and l2:
+            if l1.val < l2.val:
+                cur.next = l1
+                l1 = l1.next
+            else:
+                cur.next = l2
+                l2 = l2.next
+            cur = cur.next
+        cur.next = l1 or l2
+        return dummny.next
 ```

Daily-challenge/2021/Jan/04/sol.py

@@ -1,10 +1,18 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
 class Solution:
-    def kthFactor(self, n: int, k: int) -> int:
-        lst = []
-        
-        for i in range(1, n+1):
-            if n % i == 0:
-                lst += [i]
-        if len(lst) < k:
-            return -1
-        return lst[k-1]
+    def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
+        dummny = cur = ListNode(0)
+        while l1 and l2:
+            if l1.val < l2.val:
+                cur.next = l1
+                l1 = l1.next
+            else:
+                cur.next = l2
+                l2 = l2.next
+            cur = cur.next
+        cur.next = l1 or l2
+        return dummny.next

Daily-challenge/2021/Jan/05/README.md

@@ -1,51 +1,49 @@
-# Can Place Flowers
-
-Solution
-You have a long flowerbed in which some of the plots are planted, and some are not. However, flowers cannot be planted in adjacent plots.
-
-Given an integer array flowerbed containing 0's and 1's, where 0 means empty and 1 means not empty, and an integer n, return if n new flowers can be planted in the flowerbed without violating the no-adjacent-flowers rule.
+# Remove Duplicates from Sorted List II
+Given the head of a sorted linked list, delete all nodes that have duplicate numbers, leaving only distinct numbers from the original list. Return the linked list sorted as well.
 
 
 
 Example 1:
 
-Input: flowerbed = [1,0,0,0,1], n = 1
-Output: true
+
+Input: head = [1,2,3,3,4,4,5]
+Output: [1,2,5]
 Example 2:
 
-Input: flowerbed = [1,0,0,0,1], n = 2
-Output: false
+
+Input: head = [1,1,1,2,3]
+Output: [2,3]
 
 
 Constraints:
 
-1 <= flowerbed.length <= 2 * 104
-flowerbed[i] is 0 or 1.
-There are no two adjacent flowers in flowerbed.
-0 <= n <= flowerbed.length<br>
+The number of nodes in the list is in the range [0, 300].
+-100 <= Node.val <= 100
+The list is guaranteed to be sorted in ascending order.<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
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
 class Solution:
-    def canPlaceFlowers(self, flowerbed: List[int], n: int) -> bool:
-        i = 0
-        lenz = len(flowerbed)
-        count = 0
-        
-        while i < lenz and count < n:
-            if flowerbed[i] == 0:
-                if i == lenz - 1: 
-                    nex = 0 
-                else: nex = flowerbed[i+1]
-                if i == 0: 
-                    prev = 0 
-                else: 
-                    prev = flowerbed[i-1]
-                if nex == 0 and prev == 0:
-                    flowerbed[i] = 1
-                    count += 1
-                    
-            i += 1
-        return count == n
+    def deleteDuplicates(self, head: ListNode) -> ListNode:
+        dummy = ListNode(0);  
+        dummy.next = head 
+
+        pre = dummy           
+        cur = head
+        while cur:
+            if cur.next and cur.val == cur.next.val:
+                while cur and cur.next and cur.val == cur.next.val:
+                    cur = cur.next
+                pre.next = cur.next  
+                                     
+            else:
+                pre = pre.next 
+            cur = cur.next
+        return dummy.next
 ```

Daily-challenge/2021/Jan/05/sol.py

@@ -1,21 +1,22 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
 class Solution:
-    def canPlaceFlowers(self, flowerbed: List[int], n: int) -> bool:
-        i = 0
-        lenz = len(flowerbed)
-        count = 0
-        
-        while i < lenz and count < n:
-            if flowerbed[i] == 0:
-                if i == lenz - 1: 
-                    nex = 0 
-                else: nex = flowerbed[i+1]
-                if i == 0: 
-                    prev = 0 
-                else: 
-                    prev = flowerbed[i-1]
-                if nex == 0 and prev == 0:
-                    flowerbed[i] = 1
-                    count += 1
-                    
-            i += 1
-        return count == n
+    def deleteDuplicates(self, head: ListNode) -> ListNode:
+        dummy = ListNode(0);  
+        dummy.next = head 
+
+        pre = dummy           
+        cur = head
+        while cur:
+            if cur.next and cur.val == cur.next.val:
+                while cur and cur.next and cur.val == cur.next.val:
+                    cur = cur.next
+                pre.next = cur.next  
+                                     
+            else:
+                pre = pre.next 
+            cur = cur.next
+        return dummy.next