009007153e1fb3c00adfa6056e3b4d69e5a432d0d5b347b5515111c51f9bc8ad

.gitattributes

@@ -185,3 +185,6 @@ maximum_or/meta.json filter=lfs diff=lfs merge=lfs -text
 maximum_points_after_collecting_coins_from_all_nodes/haskell_tests/Main.hs filter=lfs diff=lfs merge=lfs -text
 maximum_points_after_collecting_coins_from_all_nodes/meta.json filter=lfs diff=lfs merge=lfs -text
 maximum_points_after_collecting_coins_from_all_nodes/scala_tests/MySuite.scala filter=lfs diff=lfs merge=lfs -text
+maximum_prime_difference/meta.json filter=lfs diff=lfs merge=lfs -text
+maximum_score_after_applying_operations_on_a_tree/meta.json filter=lfs diff=lfs merge=lfs -text
+maximum_score_of_a_node_sequence/meta.json filter=lfs diff=lfs merge=lfs -text

maximum_prime_difference/meta.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4d5af2ad5c3a464a6a741cf51aeb1a3ceb184bb0c9bcf28c0bca89b5be3a88ba
+size 16319832

maximum_product_after_k_increments/haskell_tests/Main.hs

@@ -0,0 +1,24 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (maximumProduct [0,4] 5)," 20 (maximumProduct [0,4] 5))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (maximumProduct [6,3,3,2] 2)," 216 (maximumProduct [6,3,3,2] 2))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

maximum_product_after_k_increments/java_tests/Main.java

@@ -0,0 +1,21 @@
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+import java.util.List;
+import java.util.Arrays;
+import java.util.ArrayList;
+public class Main {
+    //Program start
+    
+    //Program end
+
+    @Test
+public void test1() {
+    assertEquals(20, maximumProduct(new ArrayList<>(Arrays.asList(0,4)), 5));
+}
+@Test
+public void test2() {
+    assertEquals(216, maximumProduct(new ArrayList<>(Arrays.asList(6,3,3,2)), 2));
+}
+
+}

maximum_product_after_k_increments/meta.json

@@ -0,0 +1,26 @@
+{
+    "id": 2329,
+    "name": "maximum_product_after_k_increments",
+    "difficulty": "Medium",
+    "link": "https://leetcode.com/problems/maximum-product-after-k-increments/",
+    "date": "1648944000000",
+    "task_description": "You are given an array of non-negative integers `nums` and an integer `k`. In one operation, you may choose **any** element from `nums` and **increment** it by `1`. Return_ the **maximum** **product** of _`nums`_ after **at most** _`k`_ operations. _Since the answer may be very large, return it modulo `109 + 7`. Note that you should maximize the product before taking the modulo. **Example 1:** ``` **Input:** nums = [0,4], k = 5 **Output:** 20 **Explanation:** Increment the first number 5 times. Now nums = [5, 4], with a product of 5 * 4 = 20. It can be shown that 20 is maximum product possible, so we return 20. Note that there may be other ways to increment nums to have the maximum product. ``` **Example 2:** ``` **Input:** nums = [6,3,3,2], k = 2 **Output:** 216 **Explanation:** Increment the second number 1 time and increment the fourth number 1 time. Now nums = [6, 4, 3, 3], with a product of 6 * 4 * 3 * 3 = 216. It can be shown that 216 is maximum product possible, so we return 216. Note that there may be other ways to increment nums to have the maximum product. ``` **Constraints:** `1 <= nums.length, k <= 105` `0 <= nums[i] <= 106`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "nums = [0,4], k = 5",
+            "output": "20 "
+        },
+        {
+            "label": "Example 2",
+            "input": "nums = [6,3,3,2], k = 2",
+            "output": "216 "
+        }
+    ],
+    "private_test_cases": [],
+    "haskell_template": "maximumProduct :: [Int] -> Int -> Int\nmaximumProduct nums k ",
+    "ocaml_template": "let maximumProduct (nums: int list) (k: int) : int =  ",
+    "scala_template": "def maximumProduct(nums: List[Int],k: Int): Int = { \n    \n}",
+    "java_template": "public static int maximumProduct(List<Integer> nums, int k) {\n\n}",
+    "python_template": "class Solution(object):\n    def maximumProduct(self, nums, k):\n        \"\"\"\n        :type nums: List[int]\n        :type k: int\n        :rtype: int\n        \"\"\"\n        "
+}

maximum_product_after_k_increments/ocaml_tests/main.ml

@@ -0,0 +1,26 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 20 (maximumProduct [0;4] 5)
+
+let test2 _ = assert_equal 216 (maximumProduct [6;3;3;2] 2)
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for maximumProduct" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

maximum_product_after_k_increments/scala_tests/MySuite.scala

@@ -0,0 +1,12 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.maximumProduct(List(0,4),5), 20)
+  }
+
+  test("test2") {
+    assertEquals(Main.maximumProduct(List(6,3,3,2),2), 216)
+  }
+
+}

maximum_rows_covered_by_columns/haskell_tests/Main.hs

@@ -0,0 +1,24 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (maximumRows [[0,0,0],[1,0,1],[0,1,1],[0,0,1]] 2)," 3 (maximumRows [[0,0,0],[1,0,1],[0,1,1],[0,0,1]] 2))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (maximumRows [[1],[0]] 1)," 2 (maximumRows [[1],[0]] 1))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

maximum_rows_covered_by_columns/java_tests/Main.java

@@ -0,0 +1,21 @@
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+import java.util.List;
+import java.util.Arrays;
+import java.util.ArrayList;
+public class Main {
+    //Program start
+    
+    //Program end
+
+    @Test
+public void test1() {
+    assertEquals(3, maximumRows(new ArrayList<>(Arrays.asList(new ArrayList<>(Arrays.asList(0,0,0)),new ArrayList<>(Arrays.asList(1,0,1)),new ArrayList<>(Arrays.asList(0,1,1)),new ArrayList<>(Arrays.asList(0,0,1)))), 2));
+}
+@Test
+public void test2() {
+    assertEquals(2, maximumRows(new ArrayList<>(Arrays.asList(new ArrayList<>(Arrays.asList(1)),new ArrayList<>(Arrays.asList(0)))), 1));
+}
+
+}

maximum_rows_covered_by_columns/meta.json

@@ -0,0 +1,26 @@
+{
+    "id": 2482,
+    "name": "maximum_rows_covered_by_columns",
+    "difficulty": "Medium",
+    "link": "https://leetcode.com/problems/maximum-rows-covered-by-columns/",
+    "date": "1660953600000",
+    "task_description": "You are given an `m x n` binary matrix `matrix` and an integer `numSelect`. Your goal is to select exactly `numSelect` **distinct **columns from `matrix` such that you cover as many rows as possible. A row is considered **covered** if all the `1`'s in that row are also part of a column that you have selected. If a row does not have any `1`s, it is also considered covered. More formally, let us consider `selected = {c1, c2, ...., cnumSelect}` as the set of columns selected by you. A row `i` is **covered** by `selected` if: For each cell where `matrix[i][j] == 1`, the column `j` is in `selected`. Or, no cell in row `i` has a value of `1`. Return the **maximum** number of rows that can be **covered** by a set of `numSelect` columns. **Example 1:** **Input:** matrix = [[0,0,0],[1,0,1],[0,1,1],[0,0,1]], numSelect = 2 **Output:** 3 **Explanation:** One possible way to cover 3 rows is shown in the diagram above. We choose s = {0, 2}. - Row 0 is covered because it has no occurrences of 1. - Row 1 is covered because the columns with value 1, i.e. 0 and 2 are present in s. - Row 2 is not covered because matrix[2][1] == 1 but 1 is not present in s. - Row 3 is covered because matrix[2][2] == 1 and 2 is present in s. Thus, we can cover three rows. Note that s = {1, 2} will also cover 3 rows, but it can be shown that no more than three rows can be covered. **Example 2:** **Input:** matrix = [[1],[0]], numSelect = 1 **Output:** 2 **Explanation:** Selecting the only column will result in both rows being covered since the entire matrix is selected. **Constraints:** `m == matrix.length` `n == matrix[i].length` `1 <= m, n <= 12` `matrix[i][j]` is either `0` or `1`. `1 <= numSelect <= n`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "matrix = [[0,0,0],[1,0,1],[0,1,1],[0,0,1]], numSelect = 2",
+            "output": "3 "
+        },
+        {
+            "label": "Example 2",
+            "input": "matrix = [[1],[0]], numSelect = 1",
+            "output": "2 "
+        }
+    ],
+    "private_test_cases": [],
+    "haskell_template": "maximumRows :: [[Int]] -> Int -> Int\nmaximumRows matrix numSelect ",
+    "ocaml_template": "let maximumRows (matrix: int list list) (numSelect: int) : int =  ",
+    "scala_template": "def maximumRows(matrix: List[List[Int]],numSelect: Int): Int = { \n    \n}",
+    "java_template": "public static int maximumRows(List<List<Integer>> matrix, int numSelect) {\n\n}",
+    "python_template": "class Solution(object):\n    def maximumRows(self, matrix, numSelect):\n        \"\"\"\n        :type matrix: List[List[int]]\n        :type numSelect: int\n        :rtype: int\n        \"\"\"\n        "
+}

maximum_rows_covered_by_columns/ocaml_tests/main.ml

@@ -0,0 +1,26 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 3 (maximumRows [[0;0;0];[1;0;1];[0;1;1];[0;0;1]] 2)
+
+let test2 _ = assert_equal 2 (maximumRows [[1];[0]] 1)
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for maximumRows" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

maximum_rows_covered_by_columns/scala_tests/MySuite.scala

@@ -0,0 +1,12 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.maximumRows(List(List(0,0,0),List(1,0,1),List(0,1,1),List(0,0,1)),2), 3)
+  }
+
+  test("test2") {
+    assertEquals(Main.maximumRows(List(List(1),List(0)),1), 2)
+  }
+
+}

maximum_running_time_of_n_computers/haskell_tests/Main.hs

@@ -0,0 +1,24 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (maxRunTime 2 [3,3,3])," 4 (maxRunTime 2 [3,3,3]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (maxRunTime 2 [1,1,1,1])," 2 (maxRunTime 2 [1,1,1,1]))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

maximum_running_time_of_n_computers/java_tests/Main.java

@@ -0,0 +1,21 @@
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+import java.util.List;
+import java.util.Arrays;
+import java.util.ArrayList;
+public class Main {
+    //Program start
+    
+    //Program end
+
+    @Test
+public void test1() {
+    assertEquals(4, maxRunTime(2, new ArrayList<>(Arrays.asList(3,3,3))));
+}
+@Test
+public void test2() {
+    assertEquals(2, maxRunTime(2, new ArrayList<>(Arrays.asList(1,1,1,1))));
+}
+
+}

maximum_running_time_of_n_computers/ocaml_tests/main.ml

@@ -0,0 +1,26 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 4 (maxRunTime 2 [3;3;3])
+
+let test2 _ = assert_equal 2 (maxRunTime 2 [1;1;1;1])
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for maxRunTime" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

maximum_running_time_of_n_computers/scala_tests/MySuite.scala

@@ -0,0 +1,12 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.maxRunTime(2,List(3,3,3)), 4)
+  }
+
+  test("test2") {
+    assertEquals(Main.maxRunTime(2,List(1,1,1,1)), 2)
+  }
+
+}

maximum_score_after_applying_operations_on_a_tree/java_tests/Main.java

@@ -0,0 +1,21 @@
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+import java.util.List;
+import java.util.Arrays;
+import java.util.ArrayList;
+public class Main {
+    //Program start
+    
+    //Program end
+
+    @Test
+public void test1() {
+    assertEquals(11, maximumScoreAfterOperations(new ArrayList<>(Arrays.asList(new ArrayList<>(Arrays.asList(0,1)),new ArrayList<>(Arrays.asList(0,2)),new ArrayList<>(Arrays.asList(0,3)),new ArrayList<>(Arrays.asList(2,4)),new ArrayList<>(Arrays.asList(4,5)))), new ArrayList<>(Arrays.asList(5,2,5,2,1,1))));
+}
+@Test
+public void test2() {
+    assertEquals(40, maximumScoreAfterOperations(new ArrayList<>(Arrays.asList(new ArrayList<>(Arrays.asList(0,1)),new ArrayList<>(Arrays.asList(0,2)),new ArrayList<>(Arrays.asList(1,3)),new ArrayList<>(Arrays.asList(1,4)),new ArrayList<>(Arrays.asList(2,5)),new ArrayList<>(Arrays.asList(2,6)))), new ArrayList<>(Arrays.asList(20,10,9,7,4,3,5))));
+}
+
+}

maximum_score_after_applying_operations_on_a_tree/meta.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:def33c56c5143efab27ee337b56fe9dfb467d67defde9b84ba3f444b574bf48b
+size 11113724

maximum_score_from_grid_operations/java_tests/Main.java

@@ -0,0 +1,20 @@
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+import java.util.List;
+import java.util.Arrays;
+public class Main {
+    //Program start
+
+    //Program end
+
+    @Test
+public void test1() {
+    assertEquals(11, maximumScore(Arrays.asList(Arrays.asList(0,0,0,0,0),Arrays.asList(0,0,3,0,0),Arrays.asList(0,1,0,0,0),Arrays.asList(5,0,0,3,0),Arrays.asList(0,0,0,0,2))));
+}
+@Test
+public void test2() {
+    assertEquals(94, maximumScore(Arrays.asList(Arrays.asList(10,9,0,0,15),Arrays.asList(7,1,0,8,0),Arrays.asList(5,20,0,11,0),Arrays.asList(0,0,0,1,2),Arrays.asList(8,12,1,10,3))));
+}
+
+}

maximum_score_of_a_node_sequence/haskell_tests/Main.hs

@@ -0,0 +1,24 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (maximumScore [5,2,9,8,4] [[0,1],[1,2],[2,3],[0,2],[1,3],[2,4]])," 24 (maximumScore [5,2,9,8,4] [[0,1],[1,2],[2,3],[0,2],[1,3],[2,4]]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (maximumScore [9,20,6,4,11,12] [[0,3],[5,3],[2,4],[1,3]])," (-1) (maximumScore [9,20,6,4,11,12] [[0,3],[5,3],[2,4],[1,3]]))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

maximum_score_of_a_node_sequence/java_tests/Main.java

@@ -0,0 +1,21 @@
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+import java.util.List;
+import java.util.Arrays;
+import java.util.ArrayList;
+public class Main {
+    //Program start
+    
+    //Program end
+
+    @Test
+public void test1() {
+    assertEquals(24, maximumScore(new ArrayList<>(Arrays.asList(5,2,9,8,4)), new ArrayList<>(Arrays.asList(new ArrayList<>(Arrays.asList(0,1)),new ArrayList<>(Arrays.asList(1,2)),new ArrayList<>(Arrays.asList(2,3)),new ArrayList<>(Arrays.asList(0,2)),new ArrayList<>(Arrays.asList(1,3)),new ArrayList<>(Arrays.asList(2,4))))));
+}
+@Test
+public void test2() {
+    assertEquals(-1, maximumScore(new ArrayList<>(Arrays.asList(9,20,6,4,11,12)), new ArrayList<>(Arrays.asList(new ArrayList<>(Arrays.asList(0,3)),new ArrayList<>(Arrays.asList(5,3)),new ArrayList<>(Arrays.asList(2,4)),new ArrayList<>(Arrays.asList(1,3))))));
+}
+
+}

maximum_score_of_a_node_sequence/meta.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:25e6d327b5f519ce29d5ca1a65e49ae727057585878bb32c55eac15be008163c
+size 30794206

maximum_score_of_a_node_sequence/ocaml_tests/main.ml

@@ -0,0 +1,26 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 24 (maximumScore [5;2;9;8;4] [[0;1];[1;2];[2;3];[0;2];[1;3];[2;4]])
+
+let test2 _ = assert_equal (-1) (maximumScore [9;20;6;4;11;12] [[0;3];[5;3];[2;4];[1;3]])
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for maximumScore" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

maximum_score_of_a_node_sequence/scala_tests/MySuite.scala

@@ -0,0 +1,12 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.maximumScore(List(5,2,9,8,4),List(List(0,1),List(1,2),List(2,3),List(0,2),List(1,3),List(2,4))), 24)
+  }
+
+  test("test2") {
+    assertEquals(Main.maximumScore(List(9,20,6,4,11,12),List(List(0,3),List(5,3),List(2,4),List(1,3))), -1)
+  }
+
+}

maximum_segment_sum_after_removals/haskell_tests/Main.hs

@@ -0,0 +1,24 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (maximumSegmentSum [1,2,5,6,1] [0,3,2,4,1])," [14,7,2,2,0] (maximumSegmentSum [1,2,5,6,1] [0,3,2,4,1]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (maximumSegmentSum [3,2,11,1] [3,2,1,0])," [16,5,3,0] (maximumSegmentSum [3,2,11,1] [3,2,1,0]))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

maximum_segment_sum_after_removals/java_tests/Main.java

@@ -0,0 +1,21 @@
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+import java.util.List;
+import java.util.Arrays;
+import java.util.ArrayList;
+public class Main {
+    //Program start
+    
+    //Program end
+
+    @Test
+public void test1() {
+    assertEquals(new ArrayList<>(Arrays.asList(14,7,2,2,0)), maximumSegmentSum(new ArrayList<>(Arrays.asList(1,2,5,6,1)), new ArrayList<>(Arrays.asList(0,3,2,4,1))));
+}
+@Test
+public void test2() {
+    assertEquals(new ArrayList<>(Arrays.asList(16,5,3,0)), maximumSegmentSum(new ArrayList<>(Arrays.asList(3,2,11,1)), new ArrayList<>(Arrays.asList(3,2,1,0))));
+}
+
+}

maximum_segment_sum_after_removals/meta.json

@@ -0,0 +1,26 @@
+{
+    "id": 2466,
+    "name": "maximum_segment_sum_after_removals",
+    "difficulty": "Hard",
+    "link": "https://leetcode.com/problems/maximum-segment-sum-after-removals/",
+    "date": "1659744000000",
+    "task_description": "You are given two **0-indexed** integer arrays `nums` and `removeQueries`, both of length `n`. For the `ith` query, the element in `nums` at the index `removeQueries[i]` is removed, splitting `nums` into different segments. A **segment** is a contiguous sequence of **positive** integers in `nums`. A **segment sum** is the sum of every element in a segment. Return_ an integer array _`answer`_, of length _`n`_, where _`answer[i]`_ is the **maximum** segment sum after applying the _`ith` _removal._ **Note:** The same index will **not** be removed more than once. **Example 1:** ``` **Input:** nums = [1,2,5,6,1], removeQueries = [0,3,2,4,1] **Output:** [14,7,2,2,0] **Explanation:** Using 0 to indicate a removed element, the answer is as follows: Query 1: Remove the 0th element, nums becomes [0,2,5,6,1] and the maximum segment sum is 14 for segment [2,5,6,1]. Query 2: Remove the 3rd element, nums becomes [0,2,5,0,1] and the maximum segment sum is 7 for segment [2,5]. Query 3: Remove the 2nd element, nums becomes [0,2,0,0,1] and the maximum segment sum is 2 for segment [2]. Query 4: Remove the 4th element, nums becomes [0,2,0,0,0] and the maximum segment sum is 2 for segment [2]. Query 5: Remove the 1st element, nums becomes [0,0,0,0,0] and the maximum segment sum is 0, since there are no segments. Finally, we return [14,7,2,2,0]. ``` **Example 2:** ``` **Input:** nums = [3,2,11,1], removeQueries = [3,2,1,0] **Output:** [16,5,3,0] **Explanation:** Using 0 to indicate a removed element, the answer is as follows: Query 1: Remove the 3rd element, nums becomes [3,2,11,0] and the maximum segment sum is 16 for segment [3,2,11]. Query 2: Remove the 2nd element, nums becomes [3,2,0,0] and the maximum segment sum is 5 for segment [3,2]. Query 3: Remove the 1st element, nums becomes [3,0,0,0] and the maximum segment sum is 3 for segment [3]. Query 4: Remove the 0th element, nums becomes [0,0,0,0] and the maximum segment sum is 0, since there are no segments. Finally, we return [16,5,3,0]. ``` **Constraints:** `n == nums.length == removeQueries.length` `1 <= n <= 105` `1 <= nums[i] <= 109` `0 <= removeQueries[i] < n` All the values of `removeQueries` are **unique**.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "nums = [1,2,5,6,1], removeQueries = [0,3,2,4,1]",
+            "output": "[14,7,2,2,0] "
+        },
+        {
+            "label": "Example 2",
+            "input": "nums = [3,2,11,1], removeQueries = [3,2,1,0]",
+            "output": "[16,5,3,0] "
+        }
+    ],
+    "private_test_cases": [],
+    "haskell_template": "maximumSegmentSum :: [Int] -> [Int] -> [Int]\nmaximumSegmentSum nums removeQueries ",
+    "ocaml_template": "let maximumSegmentSum (nums: int list) (removeQueries: int list) : int list =  ",
+    "scala_template": "def maximumSegmentSum(nums: List[Int],removeQueries: List[Int]): List[Int] = { \n    \n}",
+    "java_template": "public static List<Integer> maximumSegmentSum(List<Integer> nums, List<Integer> removeQueries) {\n\n}",
+    "python_template": "class Solution(object):\n    def maximumSegmentSum(self, nums, removeQueries):\n        \"\"\"\n        :type nums: List[int]\n        :type removeQueries: List[int]\n        :rtype: List[int]\n        \"\"\"\n        "
+}

maximum_segment_sum_after_removals/ocaml_tests/main.ml

@@ -0,0 +1,26 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal [14;7;2;2;0] (maximumSegmentSum [1;2;5;6;1] [0;3;2;4;1])
+
+let test2 _ = assert_equal [16;5;3;0] (maximumSegmentSum [3;2;11;1] [3;2;1;0])
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for maximumSegmentSum" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

maximum_segment_sum_after_removals/scala_tests/MySuite.scala

@@ -0,0 +1,12 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.maximumSegmentSum(List(1,2,5,6,1),List(0,3,2,4,1)), List(14,7,2,2,0))
+  }
+
+  test("test2") {
+    assertEquals(Main.maximumSegmentSum(List(3,2,11,1),List(3,2,1,0)), List(16,5,3,0))
+  }
+
+}

maximum_size_of_a_set_after_removals/haskell_tests/Main.hs

@@ -0,0 +1,45 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (maximumSetSize [1,2,1,2] [1,1,1,1])," 2 (maximumSetSize [1,2,1,2] [1,1,1,1]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (maximumSetSize [1,2,3,4,5,6] [2,3,2,3,2,3])," 5 (maximumSetSize [1,2,3,4,5,6] [2,3,2,3,2,3]))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (maximumSetSize [1,1,2,2,3,3] [4,4,5,5,6,6])," 6 (maximumSetSize [1,1,2,2,3,3] [4,4,5,5,6,6]))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (maximumSetSize [78348302, 940136119] [563590893, 159155844])," 2 (maximumSetSize [78348302, 940136119] [563590893, 159155844]))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (maximumSetSize [84945860, 193669162, 75904079, 788997068, 615456342, 414731580, 32456705, 521831271, 973822800, 326942852, 973829744, 873758845, 110226437, 683915270, 73686147, 951051910, 886569395, 548200754, 111615160, 161794210] [794087442, 82007194, 535441721, 741847875, 280877434, 783658908, 209706906, 161571603, 235709125, 689307543, 170781132, 912591602, 506074507, 639465755, 49523677, 740061735, 799782716, 470606595, 25980800, 478767626])," 20 (maximumSetSize [84945860, 193669162, 75904079, 788997068, 615456342, 414731580, 32456705, 521831271, 973822800, 326942852, 973829744, 873758845, 110226437, 683915270, 73686147, 951051910, 886569395, 548200754, 111615160, 161794210] [794087442, 82007194, 535441721, 741847875, 280877434, 783658908, 209706906, 161571603, 235709125, 689307543, 170781132, 912591602, 506074507, 639465755, 49523677, 740061735, 799782716, 470606595, 25980800, 478767626]))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (maximumSetSize [299994885, 933582513, 979747875, 561478244, 573543605, 955527439, 597760136, 223191707, 201186171, 69420566] [415956545, 537619489, 800287594, 358497998, 716334237, 495182359, 285307109, 376266466, 893022625, 64419341])," 10 (maximumSetSize [299994885, 933582513, 979747875, 561478244, 573543605, 955527439, 597760136, 223191707, 201186171, 69420566] [415956545, 537619489, 800287594, 358497998, 716334237, 495182359, 285307109, 376266466, 893022625, 64419341]))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (maximumSetSize [137423384, 664756341] [641695145, 438783830])," 2 (maximumSetSize [137423384, 664756341] [641695145, 438783830]))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (maximumSetSize [586071719, 580750612, 28731609, 154299027, 49684461, 131328257, 198807994, 4466555, 868846624, 910580591, 76432445, 974122675, 354592709, 848354224, 96921773, 274307178, 843594802, 194158012, 668622775, 335612555] [754311207, 795289464, 571259690, 816582315, 839440676, 653320358, 544979615, 737298458, 305875561, 489021621, 712859740, 711264575, 929537279, 680639902, 688884196, 814751791, 782534470, 906115758, 976991494, 763267422])," 20 (maximumSetSize [586071719, 580750612, 28731609, 154299027, 49684461, 131328257, 198807994, 4466555, 868846624, 910580591, 76432445, 974122675, 354592709, 848354224, 96921773, 274307178, 843594802, 194158012, 668622775, 335612555] [754311207, 795289464, 571259690, 816582315, 839440676, 653320358, 544979615, 737298458, 305875561, 489021621, 712859740, 711264575, 929537279, 680639902, 688884196, 814751791, 782534470, 906115758, 976991494, 763267422]))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (maximumSetSize [775787406, 920380915, 239993800, 280240273, 830880667, 345060909, 705426545, 384911700, 917388331, 956276476] [826473730, 399089989, 344913684, 285884189, 916971175, 536603624, 300393064, 848410248, 433097531, 310638834])," 10 (maximumSetSize [775787406, 920380915, 239993800, 280240273, 830880667, 345060909, 705426545, 384911700, 917388331, 956276476] [826473730, 399089989, 344913684, 285884189, 916971175, 536603624, 300393064, 848410248, 433097531, 310638834]))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1, TestLabel "Test2" test2, TestLabel "Test3" test3, TestLabel "Test4" test4, TestLabel "Test5" test5, TestLabel "Test6" test6, TestLabel "Test7" test7, TestLabel "Test8" test8, TestLabel "Test9" test9]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

maximum_size_of_a_set_after_removals/java_tests/Main.java

@@ -0,0 +1,25 @@
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+import java.util.List;
+import java.util.Arrays;
+import java.util.ArrayList;
+public class Main {
+    //Program start
+    
+    //Program end
+
+    @Test
+public void test1() {
+    assertEquals(2, maximumSetSize(new ArrayList<>(Arrays.asList(1,2,1,2)), new ArrayList<>(Arrays.asList(1,1,1,1))));
+}
+@Test
+public void test2() {
+    assertEquals(5, maximumSetSize(new ArrayList<>(Arrays.asList(1,2,3,4,5,6)), new ArrayList<>(Arrays.asList(2,3,2,3,2,3))));
+}
+@Test
+public void test3() {
+    assertEquals(6, maximumSetSize(new ArrayList<>(Arrays.asList(1,1,2,2,3,3)), new ArrayList<>(Arrays.asList(4,4,5,5,6,6))));
+}
+
+}

maximum_size_of_a_set_after_removals/meta.json

@@ -0,0 +1,334 @@
+{
+    "id": 3228,
+    "name": "maximum_size_of_a_set_after_removals",
+    "difficulty": "Medium",
+    "link": "https://leetcode.com/problems/maximum-size-of-a-set-after-removals/",
+    "date": "2023-12-31 00:00:00",
+    "task_description": "You are given two **0-indexed** integer arrays `nums1` and `nums2` of even length `n`. You must remove `n / 2` elements from `nums1` and `n / 2` elements from `nums2`. After the removals, you insert the remaining elements of `nums1` and `nums2` into a set `s`. Return _the **maximum** possible size of the set_ `s`. **Example 1:** ``` **Input:** nums1 = [1,2,1,2], nums2 = [1,1,1,1] **Output:** 2 **Explanation:** We remove two occurences of 1 from nums1 and nums2. After the removals, the arrays become equal to nums1 = [2,2] and nums2 = [1,1]. Therefore, s = {1,2}. It can be shown that 2 is the maximum possible size of the set s after the removals. ``` **Example 2:** ``` **Input:** nums1 = [1,2,3,4,5,6], nums2 = [2,3,2,3,2,3] **Output:** 5 **Explanation:** We remove 2, 3, and 6 from nums1, as well as 2 and two occurrences of 3 from nums2. After the removals, the arrays become equal to nums1 = [1,4,5] and nums2 = [2,3,2]. Therefore, s = {1,2,3,4,5}. It can be shown that 5 is the maximum possible size of the set s after the removals. ``` **Example 3:** ``` **Input:** nums1 = [1,1,2,2,3,3], nums2 = [4,4,5,5,6,6] **Output:** 6 **Explanation:** We remove 1, 2, and 3 from nums1, as well as 4, 5, and 6 from nums2. After the removals, the arrays become equal to nums1 = [1,2,3] and nums2 = [4,5,6]. Therefore, s = {1,2,3,4,5,6}. It can be shown that 6 is the maximum possible size of the set s after the removals. ``` **Constraints:** `n == nums1.length == nums2.length` `1 <= n <= 2 * 104` `n` is even. `1 <= nums1[i], nums2[i] <= 109`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "nums1 = [1,2,1,2], nums2 = [1,1,1,1]",
+            "output": "2 "
+        },
+        {
+            "label": "Example 2",
+            "input": "nums1 = [1,2,3,4,5,6], nums2 = [2,3,2,3,2,3]",
+            "output": "5 "
+        },
+        {
+            "label": "Example 3",
+            "input": "nums1 = [1,1,2,2,3,3], nums2 = [4,4,5,5,6,6]",
+            "output": "6 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                [
+                    78348302,
+                    940136119
+                ],
+                [
+                    563590893,
+                    159155844
+                ]
+            ],
+            "output": 2
+        },
+        {
+            "input": [
+                [
+                    84945860,
+                    193669162,
+                    75904079,
+                    788997068,
+                    615456342,
+                    414731580,
+                    32456705,
+                    521831271,
+                    973822800,
+                    326942852,
+                    973829744,
+                    873758845,
+                    110226437,
+                    683915270,
+                    73686147,
+                    951051910,
+                    886569395,
+                    548200754,
+                    111615160,
+                    161794210
+                ],
+                [
+                    794087442,
+                    82007194,
+                    535441721,
+                    741847875,
+                    280877434,
+                    783658908,
+                    209706906,
+                    161571603,
+                    235709125,
+                    689307543,
+                    170781132,
+                    912591602,
+                    506074507,
+                    639465755,
+                    49523677,
+                    740061735,
+                    799782716,
+                    470606595,
+                    25980800,
+                    478767626
+                ]
+            ],
+            "output": 20
+        },
+        {
+            "input": [
+                [
+                    299994885,
+                    933582513,
+                    979747875,
+                    561478244,
+                    573543605,
+                    955527439,
+                    597760136,
+                    223191707,
+                    201186171,
+                    69420566
+                ],
+                [
+                    415956545,
+                    537619489,
+                    800287594,
+                    358497998,
+                    716334237,
+                    495182359,
+                    285307109,
+                    376266466,
+                    893022625,
+                    64419341
+                ]
+            ],
+            "output": 10
+        },
+        {
+            "input": [
+                [
+                    137423384,
+                    664756341
+                ],
+                [
+                    641695145,
+                    438783830
+                ]
+            ],
+            "output": 2
+        },
+        {
+            "input": [
+                [
+                    586071719,
+                    580750612,
+                    28731609,
+                    154299027,
+                    49684461,
+                    131328257,
+                    198807994,
+                    4466555,
+                    868846624,
+                    910580591,
+                    76432445,
+                    974122675,
+                    354592709,
+                    848354224,
+                    96921773,
+                    274307178,
+                    843594802,
+                    194158012,
+                    668622775,
+                    335612555
+                ],
+                [
+                    754311207,
+                    795289464,
+                    571259690,
+                    816582315,
+                    839440676,
+                    653320358,
+                    544979615,
+                    737298458,
+                    305875561,
+                    489021621,
+                    712859740,
+                    711264575,
+                    929537279,
+                    680639902,
+                    688884196,
+                    814751791,
+                    782534470,
+                    906115758,
+                    976991494,
+                    763267422
+                ]
+            ],
+            "output": 20
+        },
+        {
+            "input": [
+                [
+                    775787406,
+                    920380915,
+                    239993800,
+                    280240273,
+                    830880667,
+                    345060909,
+                    705426545,
+                    384911700,
+                    917388331,
+                    956276476
+                ],
+                [
+                    826473730,
+                    399089989,
+                    344913684,
+                    285884189,
+                    916971175,
+                    536603624,
+                    300393064,
+                    848410248,
+                    433097531,
+                    310638834
+                ]
+            ],
+            "output": 10
+        },
+        {
+            "input": [
+                [
+                    451407306,
+                    470197668,
+                    51243526,
+                    733482987
+                ],
+                [
+                    805151922,
+                    10593079,
+                    417714201,
+                    15071541
+                ]
+            ],
+            "output": 4
+        },
+        {
+            "input": [
+                [
+                    442524239,
+                    876643870,
+                    990601996,
+                    448210324
+                ],
+                [
+                    262261265,
+                    383531389,
+                    403424825,
+                    659441841
+                ]
+            ],
+            "output": 4
+        },
+        {
+            "input": [
+                [
+                    403896182,
+                    910000407,
+                    110765169,
+                    291709086,
+                    789940105,
+                    966265117,
+                    820206463,
+                    58393824,
+                    194529173,
+                    103791568,
+                    420765163,
+                    792588126,
+                    408601928,
+                    140802791,
+                    562736216,
+                    693798082
+                ],
+                [
+                    783148362,
+                    264252138,
+                    326951764,
+                    625241775,
+                    457064359,
+                    153352361,
+                    298387201,
+                    599859562,
+                    558792114,
+                    383729333,
+                    348128344,
+                    953037178,
+                    161775352,
+                    642535465,
+                    432991683,
+                    963297645
+                ]
+            ],
+            "output": 16
+        },
+        {
+            "input": [
+                [
+                    700983308,
+                    873251868,
+                    352449770,
+                    551310030,
+                    855033706,
+                    478237705,
+                    874313351,
+                    258632857,
+                    5219950,
+                    792335543,
+                    358783405,
+                    932274480,
+                    285646142,
+                    163663665,
+                    414387346,
+                    747497148,
+                    171635457,
+                    789073340
+                ],
+                [
+                    122620025,
+                    379775582,
+                    363272717,
+                    752514122,
+                    106914848,
+                    505674445,
+                    783171987,
+                    452148287,
+                    53505032,
+                    870856996,
+                    637980204,
+                    477924079,
+                    74294892,
+                    443840515,
+                    171040824,
+                    270669481,
+                    871958398,
+                    932448448
+                ]
+            ],
+            "output": 18
+        }
+    ],
+    "haskell_template": "maximumSetSize :: [Int] -> [Int] -> Int\nmaximumSetSize nums1 nums2 ",
+    "ocaml_template": "let maximumSetSize (nums1: int list) (nums2: int list) : int =  ",
+    "scala_template": "def maximumSetSize(nums1: List[Int],nums2: List[Int]): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public int maximumSetSize(int[] nums1, int[] nums2) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def maximumSetSize(self, nums1, nums2):\n        \"\"\"\n        :type nums1: List[int]\n        :type nums2: List[int]\n        :rtype: int\n        \"\"\"\n        "
+}

maximum_size_of_a_set_after_removals/ocaml_tests/main.ml

@@ -0,0 +1,50 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 2 (maximumSetSize [1;2;1;2] [1;1;1;1])
+
+let test2 _ = assert_equal 5 (maximumSetSize [1;2;3;4;5;6] [2;3;2;3;2;3])
+
+let test3 _ = assert_equal 6 (maximumSetSize [1;1;2;2;3;3] [4;4;5;5;6;6])
+
+let test4 _ = assert_equal 2 (maximumSetSize [78348302; 940136119] [563590893; 159155844])
+
+let test5 _ = assert_equal 20 (maximumSetSize [84945860; 193669162; 75904079; 788997068; 615456342; 414731580; 32456705; 521831271; 973822800; 326942852; 973829744; 873758845; 110226437; 683915270; 73686147; 951051910; 886569395; 548200754; 111615160; 161794210] [794087442; 82007194; 535441721; 741847875; 280877434; 783658908; 209706906; 161571603; 235709125; 689307543; 170781132; 912591602; 506074507; 639465755; 49523677; 740061735; 799782716; 470606595; 25980800; 478767626])
+
+let test6 _ = assert_equal 10 (maximumSetSize [299994885; 933582513; 979747875; 561478244; 573543605; 955527439; 597760136; 223191707; 201186171; 69420566] [415956545; 537619489; 800287594; 358497998; 716334237; 495182359; 285307109; 376266466; 893022625; 64419341])
+
+let test7 _ = assert_equal 2 (maximumSetSize [137423384; 664756341] [641695145; 438783830])
+
+let test8 _ = assert_equal 20 (maximumSetSize [586071719; 580750612; 28731609; 154299027; 49684461; 131328257; 198807994; 4466555; 868846624; 910580591; 76432445; 974122675; 354592709; 848354224; 96921773; 274307178; 843594802; 194158012; 668622775; 335612555] [754311207; 795289464; 571259690; 816582315; 839440676; 653320358; 544979615; 737298458; 305875561; 489021621; 712859740; 711264575; 929537279; 680639902; 688884196; 814751791; 782534470; 906115758; 976991494; 763267422])
+
+let test9 _ = assert_equal 10 (maximumSetSize [775787406; 920380915; 239993800; 280240273; 830880667; 345060909; 705426545; 384911700; 917388331; 956276476] [826473730; 399089989; 344913684; 285884189; 916971175; 536603624; 300393064; 848410248; 433097531; 310638834])
+
+let test10 _ = assert_equal 4 (maximumSetSize [451407306; 470197668; 51243526; 733482987] [805151922; 10593079; 417714201; 15071541])
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for maximumSetSize" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+  "test3" >:: test3;
+  "test4" >:: test4;
+  "test5" >:: test5;
+  "test6" >:: test6;
+  "test7" >:: test7;
+  "test8" >:: test8;
+  "test9" >:: test9;
+  "test10" >:: test10;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

maximum_size_of_a_set_after_removals/scala_tests/MySuite.scala

@@ -0,0 +1,44 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.maximumSetSize(List(1,2,1,2),List(1,1,1,1)), 2)
+  }
+
+  test("test2") {
+    assertEquals(Main.maximumSetSize(List(1,2,3,4,5,6),List(2,3,2,3,2,3)), 5)
+  }
+
+  test("test3") {
+    assertEquals(Main.maximumSetSize(List(1,1,2,2,3,3),List(4,4,5,5,6,6)), 6)
+  }
+
+  test("test4") {
+    assertEquals(Main.maximumSetSize(List(78348302, 940136119),List(563590893, 159155844)), 2)
+  }
+
+  test("test5") {
+    assertEquals(Main.maximumSetSize(List(84945860, 193669162, 75904079, 788997068, 615456342, 414731580, 32456705, 521831271, 973822800, 326942852, 973829744, 873758845, 110226437, 683915270, 73686147, 951051910, 886569395, 548200754, 111615160, 161794210),List(794087442, 82007194, 535441721, 741847875, 280877434, 783658908, 209706906, 161571603, 235709125, 689307543, 170781132, 912591602, 506074507, 639465755, 49523677, 740061735, 799782716, 470606595, 25980800, 478767626)), 20)
+  }
+
+  test("test6") {
+    assertEquals(Main.maximumSetSize(List(299994885, 933582513, 979747875, 561478244, 573543605, 955527439, 597760136, 223191707, 201186171, 69420566),List(415956545, 537619489, 800287594, 358497998, 716334237, 495182359, 285307109, 376266466, 893022625, 64419341)), 10)
+  }
+
+  test("test7") {
+    assertEquals(Main.maximumSetSize(List(137423384, 664756341),List(641695145, 438783830)), 2)
+  }
+
+  test("test8") {
+    assertEquals(Main.maximumSetSize(List(586071719, 580750612, 28731609, 154299027, 49684461, 131328257, 198807994, 4466555, 868846624, 910580591, 76432445, 974122675, 354592709, 848354224, 96921773, 274307178, 843594802, 194158012, 668622775, 335612555),List(754311207, 795289464, 571259690, 816582315, 839440676, 653320358, 544979615, 737298458, 305875561, 489021621, 712859740, 711264575, 929537279, 680639902, 688884196, 814751791, 782534470, 906115758, 976991494, 763267422)), 20)
+  }
+
+  test("test9") {
+    assertEquals(Main.maximumSetSize(List(775787406, 920380915, 239993800, 280240273, 830880667, 345060909, 705426545, 384911700, 917388331, 956276476),List(826473730, 399089989, 344913684, 285884189, 916971175, 536603624, 300393064, 848410248, 433097531, 310638834)), 10)
+  }
+
+  test("test10") {
+    assertEquals(Main.maximumSetSize(List(451407306, 470197668, 51243526, 733482987),List(805151922, 10593079, 417714201, 15071541)), 4)
+  }
+
+}

maximum_spending_after_buying_items/haskell_tests/Main.hs

@@ -0,0 +1,41 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+maxSpending :: [[Int]] -> Int
+maxSpending values = undefined
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (maxSpending [[8,5,2],[6,4,1],[9,7,3]])," 285 (maxSpending [[8,5,2],[6,4,1],[9,7,3]]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (maxSpending [[10,8,6,4,2],[9,7,5,3,2]])," 386 (maxSpending [[10,8,6,4,2],[9,7,5,3,2]]))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (maxSpending [[], [], [], [], [], []])," 227062941115574 (maxSpending [[], [], [], [], [], []]))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (maxSpending [[], [], [], [], [], [], [], [], [], []])," 292180159082858 (maxSpending [[], [], [], [], [], [], [], [], [], []]))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (maxSpending [[], [], [], [], []])," 479098599181096 (maxSpending [[], [], [], [], []]))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (maxSpending [[], [], [], [], [], [], [], [], []])," 783782248325 (maxSpending [[], [], [], [], [], [], [], [], []]))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (maxSpending [[], [], [], [], [], [], [], []])," 1619183756973107 (maxSpending [[], [], [], [], [], [], [], []]))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1, TestLabel "Test2" test2, TestLabel "Test3" test3, TestLabel "Test4" test4, TestLabel "Test5" test5, TestLabel "Test6" test6]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests