time limit exceeded

Author: ngocquanai

215. Kth Largest Element in an Array.py

@@ -0,0 +1,32 @@
+class Solution:
+    def findKthLargest(self, nums, k):
+        array = nums[:k]
+        array.sort()
+        current = array[0]
+        if len(nums) == k:
+            return current
+        for i in range(k, len(nums)):
+            # If nums[i] < current, it do not appear in largest k element array
+            if nums[i] <= current:
+                continue
+            # ELSE
+            # ensure that exactly k-element in the array
+            array.pop(0)
+            # Now array only has k-1 element
+            # Move nums[i] to the correct index
+            for idx in range(k - 1):
+                if array[idx] >= nums[i]:
+                    array.insert(idx, nums[i])
+                    break
+            else:
+                # If not inserted, then nums[i] is the largest element
+                array.append(nums[i])
+
+            current = array[0]
+        return array[0]
+
+
+nums = [3, 2, 3, 1, 2, 4, 5, 5, 6]
+k = 4
+obj = Solution()
+print(obj.findKthLargest(nums, k))

test.py

@@ -1,33 +1,36 @@
 class Solution:
-    def countQuadruplets(self, nums):
-        # Runtime-Memory trade-off using hash table
-        # a + b + c = d means a + b = d - c, so
-        # we store all d - c values in a hash table, then check for each a + b
-        abstract = dict()
-        ans = 0
-        for c in range(2, len(nums) - 1):  # Due to a < b < c < d
-            for d in range(c + 1, len(nums)):
-                minus = nums[d] - nums[c]
-                if minus not in abstract:
-                    abstract[minus] = [[c, d]]
-                else:
-                    abstract[minus].append([c, d])
+    def change(self, amount, coins):
+        coins = sorted(coins)
+        coins.insert(0, 0)
+        coin_num = len(coins)
+        array = [[0 for i in range(coin_num)] for j in range(amount + 1)]
+        # array[b][c] means the number of combination that sum = b,
+        # in the case we only use first c coins
+        # Base case with c = 1
+        array[0] = [1] * coin_num
+        for b in range(0, amount + 1):
+            # If coins[1] divided by b, then we have 1 combination
+            # that contain b/coins[1] element, else we do not have
+            # any combination
+            if b % coins[1] == 0:
+                array[b][1] = 1
+            # else array[b][1] = 0, but we initialize with 0, so we do nothing
 
-        # Then check for each sum a + b
-        for a in range(len(nums) - 3):
-            for b in range(a + 1, len(nums) - 2):
-                current_sum = nums[a] + nums[b]
-                if current_sum not in abstract:
-                    # Can not find any (a,b,c,d) satisfy
-                    continue
+        for c in range(2, len(coins)):
+            # c is the number of coin we use
+            c_amount = coins[c]
+            for b in range(1, amount + 1):
+                # The case we use maximun max_num c-th coins
+                max_num = int(b / c_amount)
+                # Each element in part is the case we use exactly i c-th coins
+                part = [array[b - i * c_amount][c - 1] for i in range(max_num + 1)]
+                array[b][c] += sum(part)
 
-                for element in abstract[current_sum]:
-                    if element[0] > b:  # Due to b < c
-                        ans += 1
-        return ans
+        return array[amount][coin_num - 1]
 
 
 obj = Solution()
-
-arr = [3, 3, 6, 4, 5]
-print(obj.countQuadruplets(arr))
+amount = 5
+coins = [1, 2, 5]
+ans = obj.change(amount, coins)
+print(ans)