AlgoExpert Four Number Sum

Author: raul-sauco

README.md

@@ -1083,6 +1083,7 @@ First column links to the problem in AlgoExpert, second is the problem's difficu
 | [Dijkstra's Algorithm][ae&dijkstra's-algorithm]                             | 🔴 Hard      | [![python](res/py.png)][ae&dijkstra's-algorithm#py]               |
 | [First Duplicate Value][ae&first-duplicate-value]                           | 🟠 Medium    | [![python](res/py.png)][ae&first-duplicate-value#py]              |
 | [First Non-Repeating Character][ae&first-non-repeating-character]           | 🟢 Easy      | [![python](res/py.png)][ae&first-non-repeating-character#py]      |
+| [Four Number Sum][ae&four-number-sum]                                       | 🔴 Hard      | [![python](res/py.png)][ae&four-number-sum#py]                    |
 | [Generate Document][ae&generate-document]                                   | 🟢 Easy      | [![python](res/py.png)][ae&generate-document#py]                  |
 | [Insertion Sort][ae&insertion-sort]                                         | 🟢 Easy      | [![python](res/py.png)][ae&insertion-sort#py]                     |
 | [Kadane's Algorithm][ae&kadane's-algorithm]                                 | 🟠 Medium    | [![python](res/py.png)][ae&kadane's-algorithm#py]                 |
@@ -1130,6 +1131,8 @@ First column links to the problem in AlgoExpert, second is the problem's difficu
 [ae&dijkstra's-algorithm#py]: algoexpert/dijkstras-algorithm.py
 [ae&first-duplicate-value]: https://www.algoexpert.io/questions/first-duplicate-value
 [ae&first-duplicate-value#py]: algoexpert/first-duplicate-value.py
+[ae&four-number-sum]: https://www.algoexpert.io/questions/four-number-sum
+[ae&four-number-sum#py]: algoexpert/four-number-sum.py
 [ae&first-non-repeating-character]: https://www.algoexpert.io/questions/first-non-repeating-character
 [ae&first-non-repeating-character#py]: algoexpert/first-non-repeating-character.py
 [ae&generate-document]: https://www.algoexpert.io/questions/generate-document

algoexpert/four-number-sum.py

@@ -0,0 +1,93 @@
+# Four Number Sum
+# 🔴 Hard
+#
+# https://www.algoexpert.io/questions/four-number-sum
+#
+# Tags: Array - Sorting
+
+import timeit
+from collections import defaultdict
+
+
+# The brute force solution explores all options using nested loops.
+#
+# Time complexity: O(n^4) - Four levels deep nested loops.
+# Space complexity: O(1) - Constant space is used.
+class BruteForce:
+    def fourNumberSum(self, array, targetSum):
+        res = []
+        for i in range(len(array) - 3):
+            for j in range(i + 1, len(array) - 2):
+                for k in range(j + 1, len(array) - 1):
+                    for m in range(k + 1, len(array)):
+                        vals = [array[i], array[j], array[k], array[m]]
+                        if sum(vals) == targetSum:
+                            res.append(vals)
+        return res
+
+
+# Use a hashmap of pair sums to find target quadruplets in O(n^2) time.
+#
+# Time complexity: O(n^2) - Nested loops with constant time operations
+# in the inner loop.
+# Space complexity: O(n^2) - The hashmap will hold the sum of all pairs.
+class Solution:
+    def fourNumberSum(self, array, targetSum):
+        # Use a hashmap of pair sums to the pairs that add up to them.
+        # Use a set to store quadruplets to eliminate duplicates. The OJ
+        # accepts a set of tuples as the result.
+        sums, res = defaultdict(set), set()
+        # Iterate over all pairs in O(n^2).
+        for i in range(len(array) - 1):
+            for j in range(i + 1, len(array)):
+                vals = (array[i], array[j])
+                s = array[i] + array[j]
+                if targetSum - s in sums:
+                    for pair in sums[targetSum - s]:
+                        if array[i] not in pair and array[j] not in pair:
+                            res.add(
+                                tuple(
+                                    sorted(
+                                        [pair[0], pair[1], array[i], array[j]]
+                                    )
+                                )
+                            )
+                sums[s].add(vals)
+        return res
+
+
+def test():
+    executors = [
+        BruteForce,
+        Solution,
+    ]
+    tests = [
+        [[1, 2, 3, 4, 5, 6, 7], 10, [[1, 2, 3, 4]]],
+        [[7, 6, 4, -1, 1, 2], 16, [[7, 6, 4, -1], [7, 6, 1, 2]]],
+        [
+            [5, -5, -2, 2, 3, -3],
+            0,
+            [[-5, -3, 3, 5], [-5, -2, 2, 5], [-3, -2, 2, 3]],
+        ],
+    ]
+    for executor in executors:
+        start = timeit.default_timer()
+        for _ in range(1):
+            for col, t in enumerate(tests):
+                sol = executor()
+                result = sol.fourNumberSum(t[0], t[1])
+                # The result could be in any order.
+                result = sorted(map(sorted, result))
+                exp = sorted(map(sorted, t[2]))
+                assert result == exp, (
+                    f"\033[93m» {result} <> {exp}\033[91m for"
+                    + f" test {col} using \033[1m{executor.__name__}"
+                )
+        stop = timeit.default_timer()
+        used = str(round(stop - start, 5))
+        cols = "{0:20}{1:10}{2:10}"
+        res = cols.format(executor.__name__, used, "seconds")
+        print(f"\033[92m» {res}\033[0m")
+
+
+test()