08/12/2020

Author: jameszu

Daily-challenge/Dec/07/README.md

@@ -22,31 +22,16 @@ Constraints:
 
 ## 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 addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
-        s1, s2 = [], []
-        while l1:
-            s1.append(l1.val)
-            l1 = l1.next
-        
-        while l2:
-            s2.append(l2.val)
-            l2 = l2.next
-            
-        carry = 0
-        head = ListNode(0)
-        while s1 or s2 or carry:
-            if s1:
-                carry += s1.pop()
-            if s2:
-                carry += s2.pop()
-            carry, val = divmod(carry, 10)
-            head.next, head.next.next = ListNode(val), head.next
-        return head.next07
+    def generateMatrix(self, n: int) -> List[List[int]]:
+        A = [[0] * n for _ in range(n)]
+        i, j, di, dj = 0, 0, 0, 1
+        for k in range(n*n):
+            A[i][j] = k + 1
+            if A[(i+di)%n][(j+dj)%n]:
+                di, dj = dj, -di
+            i += di
+            j += dj
+        return A
 
 ```

Daily-challenge/Dec/07/sol.py

@@ -1,26 +1,11 @@
-# Definition for singly-linked list.
-# class ListNode:
-#     def __init__(self, val=0, next=None):
-#         self.val = val
-#         self.next = next
 class Solution:
-    def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
-        s1, s2 = [], []
-        while l1:
-            s1.append(l1.val)
-            l1 = l1.next
-        
-        while l2:
-            s2.append(l2.val)
-            l2 = l2.next
-            
-        carry = 0
-        head = ListNode(0)
-        while s1 or s2 or carry:
-            if s1:
-                carry += s1.pop()
-            if s2:
-                carry += s2.pop()
-            carry, val = divmod(carry, 10)
-            head.next, head.next.next = ListNode(val), head.next
-        return head.next
+    def generateMatrix(self, n: int) -> List[List[int]]:
+        A = [[0] * n for _ in range(n)]
+        i, j, di, dj = 0, 0, 0, 1
+        for k in range(n*n):
+            A[i][j] = k + 1
+            if A[(i+di)%n][(j+dj)%n]:
+                di, dj = dj, -di
+            i += di
+            j += dj
+        return A

Daily-challenge/Dec/08/README.md

@@ -1,44 +1,29 @@
-# Binary Tree Tilt
-Given the root of a binary tree, return the sum of every tree node's tilt.
+# Pairs of Songs With Total Durations Divisible by 60
+You are given a list of songs where the ith song has a duration of time[i] seconds.
 
-The tilt of a tree node is the absolute difference between the sum of all left subtree node values and all right subtree node values. If a node does not have a left child, then the sum of the left subtree node values is treated as 0. The rule is similar if there the node does not have a right child.
+Return the number of pairs of songs for which their total duration in seconds is divisible by 60. Formally, we want the number of indices i, j such that i < j with (time[i] + time[j]) % 60 == 0.
 
 
 
 Example 1:
 
-
-Input: root = [1,2,3]
-Output: 1
-Explanation: 
-Tilt of node 2 : |0-0| = 0 (no children)
-Tilt of node 3 : |0-0| = 0 (no children)
-Tile of node 1 : |2-3| = 1 (left subtree is just left child, so sum is 2; right subtree is just right child, so sum is 3)
-Sum of every tilt : 0 + 0 + 1 = 1
+Input: time = [30,20,150,100,40]
+Output: 3
+Explanation: Three pairs have a total duration divisible by 60:
+(time[0] = 30, time[2] = 150): total duration 180
+(time[1] = 20, time[3] = 100): total duration 120
+(time[1] = 20, time[4] = 40): total duration 60
 Example 2:
 
-
-Input: root = [4,2,9,3,5,null,7]
-Output: 15
-Explanation: 
-Tilt of node 3 : |0-0| = 0 (no children)
-Tilt of node 5 : |0-0| = 0 (no children)
-Tilt of node 7 : |0-0| = 0 (no children)
-Tilt of node 2 : |3-5| = 2 (left subtree is just left child, so sum is 3; right subtree is just right child, so sum is 5)
-Tilt of node 9 : |0-7| = 7 (no left child, so sum is 0; right subtree is just right child, so sum is 7)
-Tilt of node 4 : |(3+5+2)-(9+7)| = |10-16| = 6 (left subtree values are 3, 5, and 2, which sums to 10; right subtree values are 9 and 7, which sums to 16)
-Sum of every tilt : 0 + 0 + 0 + 2 + 7 + 6 = 15
-Example 3:
-
-
-Input: root = [21,7,14,1,1,2,2,3,3]
-Output: 9
+Input: time = [60,60,60]
+Output: 3
+Explanation: All three pairs have a total duration of 120, which is divisible by 60.
 
 
 Constraints:
 
-The number of nodes in the tree is in the range [0, 104].
--1000 <= Node.val <= 1000 <br>
+1 <= time.length <= 6 * 104
+1 <= time[i] <= 500 <br>
 
 ## Idea