Add weekly contest questions

Author: tabletenniser

5179_balance_bst.py

@@ -0,0 +1,39 @@
+'''
+
+5179. Balance a Binary Search Tree
+User Accepted:0
+User Tried:0
+Total Accepted:0
+Total Submissions:0
+Difficulty:Medium
+Given a binary search tree, return a balanced binary search tree with the same node values.
+
+A binary search tree is balanced if and only if the depth of the two subtrees of every node never differ by more than 1.
+
+If there is more than one answer, return any of them.
+
+
+Input: root = [1,null,2,null,3,null,4,null,null]
+Output: [2,1,3,null,null,null,4]
+Explanation: This is not the only correct answer, [3,1,4,null,2,null,null] is also correct.
+
+Constraints:
+
+The number of nodes in the tree is between 1 and 10^4.
+The tree nodes will have distinct values between 1 and 10^5.
+
+'''
+# Definition for a binary tree node.
+class TreeNode:
+    def __init__(self, x):
+        self.val = x
+        self.left = None
+        self.right = None
+
+class Solution:
+    def balanceBST(self, root: TreeNode) -> TreeNode:
+
+
+s = Solution()
+m = [[3,7,8],[9,11,13],[15,16,17]]
+print(s.luckyNumbers(m))

5356_luck_number_in_matrix.py

@@ -0,0 +1,49 @@
+'''
+
+Given a m * n matrix of distinct numbers, return all lucky numbers in the matrix in any order.
+
+A lucky number is an element of the matrix such that it is the minimum element in its row and maximum in its column.
+
+
+
+Example 1:
+
+Input: matrix = [[3,7,8],[9,11,13],[15,16,17]]
+Output: [15]
+Explanation: 15 is the only lucky number since it is the minimum in its row and the maximum in its column
+Example 2:
+
+Input: matrix = [[1,10,4,2],[9,3,8,7],[15,16,17,12]]
+Output: [12]
+Explanation: 12 is the only lucky number since it is the minimum in its row and the maximum in its column.
+Example 3:
+
+Input: matrix = [[7,8],[1,2]]
+Output: [7]
+
+
+Constraints:
+
+m == mat.length
+n == mat[i].length
+1 <= n, m <= 50
+1 <= matrix[i][j] <= 10^5.
+All elements in the matrix are distinct.
+
+'''
+class Solution(object):
+    def luckyNumbers(self, matrix):
+        min_nums_in_rows = set()
+        max_nums_in_cols = set()
+        for row in matrix:
+            min_nums_in_rows.add(min(row))
+        for i in range(len(matrix[0])):
+            col = [matrix[j][i] for j in range(len(matrix))]
+            max_nums_in_cols.add(max(col))
+        result = min_nums_in_rows.intersection(max_nums_in_cols)
+
+        return list(result)
+
+s = Solution()
+m = [[3,7,8],[9,11,13],[15,16,17]]
+print(s.luckyNumbers(m))

5357_design_stack.py

@@ -0,0 +1,80 @@
+'''
+
+Design a stack which supports the following operations.
+
+Implement the CustomStack class:
+
+CustomStack(int maxSize) Initializes the object with maxSize which is the maximum number of elements in the stack or do nothing if the stack reached the maxSize.
+void push(int x) Adds x to the top of the stack if the stack hasn't reached the maxSize.
+int pop() Pops and returns the top of stack or -1 if the stack is empty.
+void inc(int k, int val) Increments the bottom k elements of the stack by val. If there are less than k elements in the stack, just increment all the elements in the stack.
+
+Input
+["CustomStack","push","push","pop","push","push","push","increment","increment","pop","pop","pop","pop"]
+[[3],[1],[2],[],[2],[3],[4],[5,100],[2,100],[],[],[],[]]
+Output
+[null,null,null,2,null,null,null,null,null,103,202,201,-1]
+Explanation
+CustomStack customStack = new CustomStack(3); // Stack is Empty []
+customStack.push(1);                          // stack becomes [1]
+customStack.push(2);                          // stack becomes [1, 2]
+customStack.pop();                            // return 2 --> Return top of the stack 2, stack becomes [1]
+customStack.push(2);                          // stack becomes [1, 2]
+customStack.push(3);                          // stack becomes [1, 2, 3]
+customStack.push(4);                          // stack still [1, 2, 3], Don't add another elements as size is 4
+customStack.increment(5, 100);                // stack becomes [101, 102, 103]
+customStack.increment(2, 100);                // stack becomes [201, 202, 103]
+customStack.pop();                            // return 103 --> Return top of the stack 103, stack becomes [201, 202]
+customStack.pop();                            // return 202 --> Return top of the stack 102, stack becomes [201]
+customStack.pop();                            // return 201 --> Return top of the stack 101, stack becomes []
+customStack.pop();                            // return -1 --> Stack is empty return -1.
+
+'''
+
+class CustomStack:
+
+    def __init__(self, maxSize: int):
+        self._max_size = maxSize
+        self._stack = [None for _ in range(maxSize)]
+        self._cur_index = 0
+        self._cur_size = 0
+
+    def push(self, x: int) -> None:
+        if self._cur_size >= self._max_size:
+            return
+        self._stack[self._cur_index % self._max_size] = x
+        self._cur_index += 1
+        self._cur_size += 1
+
+    def pop(self) -> int:
+        if self._cur_size <= 0:
+            return -1
+        num = self._stack[self._cur_index % self._max_size - 1]
+        self._cur_index -= 1
+        self._cur_size -= 1
+        return num
+
+    def increment(self, k: int, val: int) -> None:
+        k = min(k, self._max_size)
+        start_index = self._cur_index - self._cur_size
+        for i in range(start_index, start_index + k):
+            self._stack[i % self._max_size] += val
+
+# Your CustomStack object will be instantiated and called as such:
+obj = CustomStack(3)
+obj.push(1)
+obj.push(2)
+print(obj._stack, obj._cur_size, obj._cur_index)
+param_2 = obj.pop()
+assert(param_2==2)
+obj.push(2)
+obj.push(3)
+obj.push(4)
+print(obj._stack, obj._cur_size, obj._cur_index)
+obj.increment(5,100)
+print(obj._stack, obj._cur_size, obj._cur_index)
+obj.increment(2,100)
+assert(obj.pop() == 103)
+assert(obj.pop() == 202)
+assert(obj.pop() == 201)
+assert(obj.pop() == -1)

5359_max_perf.py

@@ -0,0 +1,87 @@
+'''
+
+There are n engineers numbered from 1 to n and two arrays: speed and efficiency, where speed[i] and efficiency[i] represent the speed and efficiency for the i-th engineer respectively. Return the maximum performance of a team composed of at most k engineers, since the answer can be a huge number, return this modulo 10^9 + 7.
+
+The performance of a team is the sum of their engineers' speeds multiplied by the minimum efficiency among their engineers.
+
+Example 1:
+
+Input: n = 6, speed = [2,10,3,1,5,8], efficiency = [5,4,3,9,7,2], k = 2
+Output: 60
+Explanation:
+We have the maximum performance of the team by selecting engineer 2 (with speed=10 and efficiency=4) and engineer 5 (with speed=5 and efficiency=7). That is, performance = (10 + 5) * min(4, 7) = 60.
+Example 2:
+
+Input: n = 6, speed = [2,10,3,1,5,8], efficiency = [5,4,3,9,7,2], k = 3
+Output: 68
+Explanation:
+This is the same example as the first but k = 3. We can select engineer 1, engineer 2 and engineer 5 to get the maximum performance of the team. That is, performance = (2 + 10 + 5) * min(5, 4, 7) = 68.
+Example 3:
+
+Input: n = 6, speed = [2,10,3,1,5,8], efficiency = [5,4,3,9,7,2], k = 4
+Output: 72
+
+
+Constraints:
+
+1 <= n <= 10^5
+speed.length == n
+efficiency.length == n
+1 <= speed[i] <= 10^5
+1 <= efficiency[i] <= 10^8
+1 <= k <= n
+
+'''
+class Solution(object):
+    def maxPerfRec(self, n, k):
+        assert(n > 0 and k > 0)
+        speed, efficiency = self.speed, self.efficiency
+        if (n,k) in self.ht:
+            return self.ht[(n,k)]
+        result = None
+        if n == 1:
+            result = speed[0], efficiency[0]
+        elif k == 1:
+            cur_max_perf = 0
+            for i in range(n):
+                perf = speed[i-1] * efficiency[i-1]
+                if perf > cur_max_perf:
+                    cur_max_perf = perf
+                    result = speed[i-1], efficiency[i-1]
+        else:
+            s_no_new_p, e_no_new_p = self.maxPerfRec(n - 1, k)
+            perf_no_new_p = s_no_new_p * e_no_new_p
+
+            s_less_p, e_less_p = self.maxPerfRec(n, k - 1)
+            perf_less_p = s_less_p * e_less_p
+
+            prev_s, prev_e = self.maxPerfRec(n - 1, k - 1)
+            choose_s = prev_s + speed[n-1]
+            choose_e = min(prev_e, efficiency[n-1])
+            perf_choose_p = choose_s * choose_e
+
+            if perf_choose_p > perf_no_new_p and perf_choose_p > perf_less_p:
+                result = choose_s, choose_e
+            elif perf_no_new_p > perf_choose_p and perf_no_new_p > perf_less_p:
+                result = s_no_new_p, e_no_new_p
+            else:
+                result = s_less_p, e_less_p
+        self.ht[(n, k)] = result
+        return result
+
+    def maxPerformance(self, n, speed, efficiency, k):
+        self.speed = speed
+        self.efficiency = efficiency
+        self.ht = dict()
+        max_s, max_e = self.maxPerfRec(n, k)
+
+        return (max_s * max_e) % (10 ** 9 + 7)
+
+s = Solution()
+# speed = [2,10,3,1,5,8]
+# efficiency = [5,4,3,9,7,2]
+# print(s.maxPerformance(3, speed, efficiency, 2))
+speed = [1,4,1,9,4,4,4]
+efficiency = [8,2,1,7,1,8,4]
+print(s.maxPerformance(7, speed, efficiency, 6))
+print(s.ht)