c0858bc5e7f8bd0ad3db5ff53452fafdaa09386d3c620ed5a58ef4fe07dfb1dc

.gitattributes

@@ -213,3 +213,5 @@ minimize_or_of_remaining_elements_using_operations/meta.json filter=lfs diff=lfs
 minimize_the_maximum_difference_of_pairs/meta.json filter=lfs diff=lfs merge=lfs -text
 minimum_absolute_difference_between_elements_with_constraint/meta.json filter=lfs diff=lfs merge=lfs -text
 minimum_array_length_after_pair_removals/meta.json filter=lfs diff=lfs merge=lfs -text
+minimum_cost_to_equalize_array/meta.json filter=lfs diff=lfs merge=lfs -text
+minimum_cost_to_make_arrays_identical/meta.json filter=lfs diff=lfs merge=lfs -text

minimum_cost_of_a_path_with_special_roads/haskell_tests/Main.hs

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

minimum_cost_of_a_path_with_special_roads/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(5, minimumCost(new ArrayList<>(Arrays.asList(1,1)), new ArrayList<>(Arrays.asList(4,5)), new ArrayList<>(Arrays.asList(new ArrayList<>(Arrays.asList(1,2,3,3,2)),new ArrayList<>(Arrays.asList(3,4,4,5,1))))));
+}
+@Test
+public void test2() {
+    assertEquals(7, minimumCost(new ArrayList<>(Arrays.asList(3,2)), new ArrayList<>(Arrays.asList(5,7)), new ArrayList<>(Arrays.asList(new ArrayList<>(Arrays.asList(5,7,3,2,1)),new ArrayList<>(Arrays.asList(3,2,3,4,4)),new ArrayList<>(Arrays.asList(3,3,5,5,5)),new ArrayList<>(Arrays.asList(3,4,5,6,6))))));
+}
+@Test
+public void test3() {
+    assertEquals(8, minimumCost(new ArrayList<>(Arrays.asList(1,1)), new ArrayList<>(Arrays.asList(10,4)), new ArrayList<>(Arrays.asList(new ArrayList<>(Arrays.asList(4,2,1,1,3)),new ArrayList<>(Arrays.asList(1,2,7,4,4)),new ArrayList<>(Arrays.asList(10,3,6,1,2)),new ArrayList<>(Arrays.asList(6,1,1,2,3))))));
+}
+
+}

minimum_cost_of_a_path_with_special_roads/ocaml_tests/main.ml

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

minimum_cost_of_a_path_with_special_roads/scala_tests/MySuite.scala

@@ -0,0 +1,16 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.minimumCost(List(1,1),List(4,5),List(List(1,2,3,3,2),List(3,4,4,5,1))), 5)
+  }
+
+  test("test2") {
+    assertEquals(Main.minimumCost(List(3,2),List(5,7),List(List(5,7,3,2,1),List(3,2,3,4,4),List(3,3,5,5,5),List(3,4,5,6,6))), 7)
+  }
+
+  test("test3") {
+    assertEquals(Main.minimumCost(List(1,1),List(10,4),List(List(4,2,1,1,3),List(1,2,7,4,4),List(10,3,6,1,2),List(6,1,1,2,3))), 8)
+  }
+
+}

minimum_cost_of_buying_candies_with_discount/haskell_tests/Main.hs

@@ -0,0 +1,27 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (minimumCost [1,2,3])," 5 (minimumCost [1,2,3]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (minimumCost [6,5,7,9,2,2])," 23 (minimumCost [6,5,7,9,2,2]))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (minimumCost [5,5])," 10 (minimumCost [5,5]))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1, TestLabel "Test2" test2]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

minimum_cost_of_buying_candies_with_discount/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(5, minimumCost(new ArrayList<>(Arrays.asList(1,2,3))));
+}
+@Test
+public void test2() {
+    assertEquals(23, minimumCost(new ArrayList<>(Arrays.asList(6,5,7,9,2,2))));
+}
+@Test
+public void test3() {
+    assertEquals(10, minimumCost(new ArrayList<>(Arrays.asList(5,5))));
+}
+
+}

minimum_cost_of_buying_candies_with_discount/meta.json

@@ -0,0 +1,533 @@
+{
+    "id": 2248,
+    "name": "minimum_cost_of_buying_candies_with_discount",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/minimum-cost-of-buying-candies-with-discount/",
+    "date": "1641600000000",
+    "task_description": "A shop is selling candies at a discount. For **every two** candies sold, the shop gives a **third** candy for **free**. The customer can choose **any** candy to take away for free as long as the cost of the chosen candy is less than or equal to the **minimum** cost of the two candies bought. For example, if there are `4` candies with costs `1`, `2`, `3`, and `4`, and the customer buys candies with costs `2` and `3`, they can take the candy with cost `1` for free, but not the candy with cost `4`. Given a **0-indexed** integer array `cost`, where `cost[i]` denotes the cost of the `ith` candy, return _the **minimum cost** of buying **all** the candies_. **Example 1:** ``` **Input:** cost = [1,2,3] **Output:** 5 **Explanation:** We buy the candies with costs 2 and 3, and take the candy with cost 1 for free. The total cost of buying all candies is 2 + 3 = 5. This is the **only** way we can buy the candies. Note that we cannot buy candies with costs 1 and 3, and then take the candy with cost 2 for free. The cost of the free candy has to be less than or equal to the minimum cost of the purchased candies. ``` **Example 2:** ``` **Input:** cost = [6,5,7,9,2,2] **Output:** 23 **Explanation:** The way in which we can get the minimum cost is described below: - Buy candies with costs 9 and 7 - Take the candy with cost 6 for free - We buy candies with costs 5 and 2 - Take the last remaining candy with cost 2 for free Hence, the minimum cost to buy all candies is 9 + 7 + 5 + 2 = 23. ``` **Example 3:** ``` **Input:** cost = [5,5] **Output:** 10 **Explanation:** Since there are only 2 candies, we buy both of them. There is not a third candy we can take for free. Hence, the minimum cost to buy all candies is 5 + 5 = 10. ``` **Constraints:** `1 <= cost.length <= 100` `1 <= cost[i] <= 100`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "cost = [1,2,3]",
+            "output": "5 "
+        },
+        {
+            "label": "Example 2",
+            "input": "cost = [6,5,7,9,2,2]",
+            "output": "23 "
+        },
+        {
+            "label": "Example 3",
+            "input": "cost = [5,5]",
+            "output": "10 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                97,
+                94,
+                93,
+                83,
+                75,
+                75,
+                73,
+                59,
+                58,
+                56,
+                53,
+                48,
+                43,
+                29,
+                25,
+                18,
+                12,
+                9,
+                7
+            ],
+            "output": 699
+        },
+        {
+            "input": [
+                92,
+                92,
+                81,
+                80,
+                70,
+                65,
+                63,
+                50,
+                47,
+                44,
+                42,
+                36,
+                35,
+                30,
+                25,
+                24,
+                21,
+                8,
+                6
+            ],
+            "output": 649
+        },
+        {
+            "input": [
+                70,
+                53,
+                20,
+                18,
+                17,
+                2
+            ],
+            "output": 158
+        },
+        {
+            "input": [
+                100,
+                100,
+                96,
+                95,
+                93,
+                93,
+                92,
+                88,
+                85,
+                84,
+                80,
+                80,
+                77,
+                75,
+                75,
+                74,
+                68,
+                67,
+                66,
+                66,
+                66,
+                65,
+                65,
+                64,
+                64,
+                61,
+                61,
+                61,
+                59,
+                58,
+                57,
+                57,
+                57,
+                56,
+                55,
+                55,
+                52,
+                51,
+                49,
+                45,
+                44,
+                42,
+                42,
+                41,
+                39,
+                39,
+                38,
+                38,
+                38,
+                37,
+                35,
+                34,
+                32,
+                32,
+                31,
+                30,
+                30,
+                29,
+                29,
+                28,
+                28,
+                24,
+                22,
+                21,
+                20,
+                19,
+                19,
+                17,
+                17,
+                17,
+                16,
+                15,
+                15,
+                14,
+                14,
+                14,
+                13,
+                13,
+                12,
+                11,
+                8,
+                7,
+                7,
+                6,
+                5,
+                4,
+                3
+            ],
+            "output": 2634
+        },
+        {
+            "input": [
+                100,
+                100,
+                100,
+                96,
+                94,
+                93,
+                89,
+                88,
+                83,
+                81,
+                79,
+                79,
+                77,
+                75,
+                73,
+                72,
+                68,
+                66,
+                61,
+                57,
+                57,
+                56,
+                56,
+                51,
+                51,
+                41,
+                41,
+                38,
+                35,
+                32,
+                32,
+                30,
+                29,
+                24,
+                19,
+                16,
+                13,
+                12,
+                12,
+                7,
+                4
+            ],
+            "output": 1555
+        },
+        {
+            "input": [
+                100,
+                98,
+                94,
+                93,
+                91,
+                89,
+                89,
+                85,
+                85,
+                83,
+                77,
+                73,
+                70,
+                69,
+                66,
+                63,
+                59,
+                55,
+                53,
+                39,
+                38,
+                38,
+                37,
+                36,
+                34,
+                29,
+                27,
+                27,
+                26,
+                18,
+                16,
+                14,
+                10,
+                8,
+                2
+            ],
+            "output": 1300
+        },
+        {
+            "input": [
+                100,
+                98,
+                98,
+                97,
+                97,
+                97,
+                92,
+                85,
+                83,
+                82,
+                78,
+                78,
+                77,
+                74,
+                74,
+                73,
+                72,
+                72,
+                66,
+                63,
+                57,
+                56,
+                53,
+                48,
+                48,
+                48,
+                46,
+                46,
+                44,
+                42,
+                42,
+                40,
+                27,
+                27,
+                27,
+                25,
+                24,
+                20,
+                20,
+                19,
+                19,
+                18,
+                15,
+                15,
+                15,
+                15,
+                13,
+                12,
+                11,
+                8,
+                7,
+                7,
+                6,
+                5,
+                5,
+                3,
+                3,
+                2,
+                1
+            ],
+            "output": 1768
+        },
+        {
+            "input": [
+                99,
+                99,
+                98,
+                97,
+                97,
+                93,
+                92,
+                91,
+                91,
+                91,
+                89,
+                86,
+                86,
+                86,
+                85,
+                81,
+                81,
+                80,
+                79,
+                76,
+                75,
+                74,
+                73,
+                73,
+                73,
+                68,
+                66,
+                64,
+                62,
+                59,
+                58,
+                58,
+                57,
+                55,
+                53,
+                50,
+                47,
+                46,
+                46,
+                46,
+                45,
+                43,
+                41,
+                41,
+                35,
+                35,
+                33,
+                32,
+                32,
+                32,
+                28,
+                28,
+                26,
+                25,
+                23,
+                16,
+                14,
+                13,
+                11,
+                9,
+                9,
+                9,
+                8,
+                6,
+                4
+            ],
+            "output": 2425
+        },
+        {
+            "input": [
+                98,
+                96,
+                93,
+                83,
+                83,
+                80,
+                79,
+                79,
+                75,
+                73,
+                72,
+                72,
+                71,
+                70,
+                69,
+                67,
+                62,
+                54,
+                54,
+                53,
+                52,
+                50,
+                50,
+                49,
+                48,
+                48,
+                44,
+                40,
+                39,
+                36,
+                35,
+                33,
+                29,
+                24,
+                24,
+                23,
+                22,
+                21,
+                18,
+                15,
+                13,
+                13,
+                11,
+                11,
+                11,
+                7,
+                7,
+                4,
+                2
+            ],
+            "output": 1540
+        },
+        {
+            "input": [
+                99,
+                98,
+                98,
+                97,
+                96,
+                96,
+                96,
+                96,
+                94,
+                91,
+                90,
+                90,
+                90,
+                88,
+                86,
+                85,
+                85,
+                85,
+                84,
+                82,
+                81,
+                81,
+                80,
+                80,
+                80,
+                79,
+                79,
+                78,
+                77,
+                72,
+                71,
+                70,
+                69,
+                69,
+                68,
+                67,
+                66,
+                64,
+                64,
+                58,
+                57,
+                52,
+                52,
+                48,
+                46,
+                45,
+                45,
+                44,
+                44,
+                44,
+                38,
+                37,
+                35,
+                35,
+                34,
+                34,
+                31,
+                29,
+                29,
+                28,
+                26,
+                24,
+                22,
+                15,
+                15,
+                11,
+                10,
+                10,
+                8,
+                7,
+                1
+            ],
+            "output": 2859
+        }
+    ],
+    "haskell_template": "minimumCost :: [Int] -> Int\nminimumCost cost ",
+    "ocaml_template": "let minimumCost (cost: int list) : int =  ",
+    "scala_template": "def minimumCost(cost: List[Int]): Int = { \n    \n}",
+    "java_template": "public static int minimumCost(List<Integer> cost) {\n\n}",
+    "python_template": "class Solution(object):\n    def minimumCost(self, cost):\n        \"\"\"\n        :type cost: List[int]\n        :rtype: int\n        \"\"\"\n        "
+}

minimum_cost_of_buying_candies_with_discount/ocaml_tests/main.ml

@@ -0,0 +1,29 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 5 (minimumCost [1;2;3])
+
+let test2 _ = assert_equal 23 (minimumCost [6;5;7;9;2;2])
+
+let test3 _ = assert_equal 10 (minimumCost [5;5])
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for minimumCost" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+  "test3" >:: test3;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

minimum_cost_of_buying_candies_with_discount/scala_tests/MySuite.scala

@@ -0,0 +1,16 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.minimumCost(List(1,2,3)), 5)
+  }
+
+  test("test2") {
+    assertEquals(Main.minimumCost(List(6,5,7,9,2,2)), 23)
+  }
+
+  test("test3") {
+    assertEquals(Main.minimumCost(List(5,5)), 10)
+  }
+
+}

minimum_cost_to_convert_string_i/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(28, minimumCost("abcd", "acbe", new ArrayList<>(Arrays.asList("a","b","c","c","e","d")), new ArrayList<>(Arrays.asList("b","c","b","e","b","e")), new ArrayList<>(Arrays.asList(2,5,5,1,2,20))));
+}
+@Test
+public void test2() {
+    assertEquals(12, minimumCost("aaaa", "bbbb", new ArrayList<>(Arrays.asList("a","c")), new ArrayList<>(Arrays.asList("c","b")), new ArrayList<>(Arrays.asList(1,2))));
+}
+@Test
+public void test3() {
+    assertEquals(-1, minimumCost("abcd", "abce", new ArrayList<>(Arrays.asList("a")), new ArrayList<>(Arrays.asList("e")), new ArrayList<>(Arrays.asList(10000))));
+}
+
+}

minimum_cost_to_convert_string_ii/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(28, minimumCost("abcd", "acbe", new ArrayList<>(Arrays.asList("a","b","c","c","e","d")), new ArrayList<>(Arrays.asList("b","c","b","e","b","e")), new ArrayList<>(Arrays.asList(2,5,5,1,2,20))));
+}
+@Test
+public void test2() {
+    assertEquals(9, minimumCost("abcdefgh", "acdeeghh", new ArrayList<>(Arrays.asList("bcd","fgh","thh")), new ArrayList<>(Arrays.asList("cde","thh","ghh")), new ArrayList<>(Arrays.asList(1,3,5))));
+}
+@Test
+public void test3() {
+    assertEquals(-1, minimumCost("abcdefgh", "addddddd", new ArrayList<>(Arrays.asList("bcd","defgh")), new ArrayList<>(Arrays.asList("ddd","ddddd")), new ArrayList<>(Arrays.asList(100,1578))));
+}
+
+}

minimum_cost_to_equalize_array/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(15, minCostToEqualizeArray(new ArrayList<>(Arrays.asList(4,1)), 5, 2));
+}
+@Test
+public void test2() {
+    assertEquals(6, minCostToEqualizeArray(new ArrayList<>(Arrays.asList(2,3,3,3,5)), 2, 1));
+}
+@Test
+public void test3() {
+    assertEquals(4, minCostToEqualizeArray(new ArrayList<>(Arrays.asList(3,5,3)), 1, 3));
+}
+
+}

minimum_cost_to_equalize_array/meta.json

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

minimum_cost_to_make_all_characters_equal/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(2, minimumCost("0011"));
+}
+@Test
+public void test2() {
+    assertEquals(9, minimumCost("010101"));
+}
+
+}

minimum_cost_to_make_array_equal/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 (minCost [1,3,5,2] [2,3,1,14])," 8 (minCost [1,3,5,2] [2,3,1,14]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (minCost [2,2,2,2,2] [4,2,8,1,3])," 0 (minCost [2,2,2,2,2] [4,2,8,1,3]))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

minimum_cost_to_make_array_equal/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(8, minCost(new ArrayList<>(Arrays.asList(1,3,5,2)), new ArrayList<>(Arrays.asList(2,3,1,14))));
+}
+@Test
+public void test2() {
+    assertEquals(0, minCost(new ArrayList<>(Arrays.asList(2,2,2,2,2)), new ArrayList<>(Arrays.asList(4,2,8,1,3))));
+}
+
+}

minimum_cost_to_make_array_equal/meta.json

@@ -0,0 +1,26 @@
+{
+    "id": 2538,
+    "name": "minimum_cost_to_make_array_equal",
+    "difficulty": "Hard",
+    "link": "https://leetcode.com/problems/minimum-cost-to-make-array-equal/",
+    "date": "1665878400000",
+    "task_description": "You are given two **0-indexed** arrays `nums` and `cost` consisting each of `n` **positive** integers. You can do the following operation **any** number of times: Increase or decrease **any** element of the array `nums` by `1`. The cost of doing one operation on the `ith` element is `cost[i]`. Return _the **minimum** total cost such that all the elements of the array _`nums`_ become **equal**_. **Example 1:** ``` **Input:** nums = [1,3,5,2], cost = [2,3,1,14] **Output:** 8 **Explanation:** We can make all the elements equal to 2 in the following way: - Increase the 0th element one time. The cost is 2. - Decrease the 1st element one time. The cost is 3. - Decrease the 2nd element three times. The cost is 1 + 1 + 1 = 3. The total cost is 2 + 3 + 3 = 8. It can be shown that we cannot make the array equal with a smaller cost. ``` **Example 2:** ``` **Input:** nums = [2,2,2,2,2], cost = [4,2,8,1,3] **Output:** 0 **Explanation:** All the elements are already equal, so no operations are needed. ``` **Constraints:** `n == nums.length == cost.length` `1 <= n <= 105` `1 <= nums[i], cost[i] <= 106` Test cases are generated in a way that the output doesn't exceed 253-1",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "nums = [1,3,5,2], cost = [2,3,1,14]",
+            "output": "8 "
+        },
+        {
+            "label": "Example 2",
+            "input": "nums = [2,2,2,2,2], cost = [4,2,8,1,3]",
+            "output": "0 "
+        }
+    ],
+    "private_test_cases": [],
+    "haskell_template": "minCost :: [Int] -> [Int] -> Int\nminCost nums cost ",
+    "ocaml_template": "let minCost (nums: int list) (cost: int list) : int =  ",
+    "scala_template": "def minCost(nums: List[Int],cost: List[Int]): Int = { \n    \n}",
+    "java_template": "public static int minCost(List<Integer> nums, List<Integer> cost) {\n\n}",
+    "python_template": "class Solution(object):\n    def minCost(self, nums, cost):\n        \"\"\"\n        :type nums: List[int]\n        :type cost: List[int]\n        :rtype: int\n        \"\"\"\n        "
+}

minimum_cost_to_make_array_equal/ocaml_tests/main.ml

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

minimum_cost_to_make_array_equal/scala_tests/MySuite.scala

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

minimum_cost_to_make_array_equalindromic/haskell_tests/Main.hs

@@ -0,0 +1,29 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+minimumCost :: [Int] -> Int
+minimumCost nums = undefined
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (minimumCost [1,2,3,4,5])," 6 (minimumCost [1,2,3,4,5]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (minimumCost [10,12,13,14,15])," 11 (minimumCost [10,12,13,14,15]))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (minimumCost [22,33,22,33,22])," 22 (minimumCost [22,33,22,33,22]))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1, TestLabel "Test2" test2]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

minimum_cost_to_make_array_equalindromic/java_tests/Main.java

@@ -0,0 +1,24 @@
+
+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(6, minimumCost(Arrays.asList(1,2,3,4,5)));
+}
+@Test
+public void test2() {
+    assertEquals(11, minimumCost(Arrays.asList(10,12,13,14,15)));
+}
+@Test
+public void test3() {
+    assertEquals(22, minimumCost(Arrays.asList(22,33,22,33,22)));
+}
+
+}

minimum_cost_to_make_array_equalindromic/meta.json

@@ -0,0 +1,31 @@
+{
+    "id": 3229,
+    "name": "minimum_cost_to_make_array_equalindromic",
+    "difficulty": "Medium",
+    "link": "https://leetcode.com/problems/minimum-cost-to-make-array-equalindromic/",
+    "date": "2023-12-10 00:00:00",
+    "task_description": "You are given a **0-indexed** integer array `nums` having length `n`. You are allowed to perform a special move **any** number of times (**including zero**) on `nums`. In one **special** **move** you perform the following steps **in order**: Choose an index `i` in the range `[0, n - 1]`, and a **positive** integer `x`. Add `|nums[i] - x|` to the total cost. Change the value of `nums[i]` to `x`. A **palindromic number** is a positive integer that remains the same when its digits are reversed. For example, `121`, `2552` and `65756` are palindromic numbers whereas `24`, `46`, `235` are not palindromic numbers. An array is considered **equalindromic** if all the elements in the array are equal to an integer `y`, where `y` is a **palindromic number** less than `109`. Return _an integer denoting the **minimum** possible total cost to make _`nums`_ **equalindromic** by performing any number of special moves._ **Example 1:** ``` **Input:** nums = [1,2,3,4,5] **Output:** 6 **Explanation:** We can make the array equalindromic by changing all elements to 3 which is a palindromic number. The cost of changing the array to [3,3,3,3,3] using 4 special moves is given by |1 - 3| + |2 - 3| + |4 - 3| + |5 - 3| = 6. It can be shown that changing all elements to any palindromic number other than 3 cannot be achieved at a lower cost. ``` **Example 2:** ``` **Input:** nums = [10,12,13,14,15] **Output:** 11 **Explanation:** We can make the array equalindromic by changing all elements to 11 which is a palindromic number. The cost of changing the array to [11,11,11,11,11] using 5 special moves is given by |10 - 11| + |12 - 11| + |13 - 11| + |14 - 11| + |15 - 11| = 11. It can be shown that changing all elements to any palindromic number other than 11 cannot be achieved at a lower cost. ``` **Example 3:** ``` **Input:** nums = [22,33,22,33,22] **Output:** 22 **Explanation:** We can make the array equalindromic by changing all elements to 22 which is a palindromic number. The cost of changing the array to [22,22,22,22,22] using 2 special moves is given by |33 - 22| + |33 - 22| = 22. It can be shown that changing all elements to any palindromic number other than 22 cannot be achieved at a lower cost. ``` **Constraints:** `1 <= n <= 105` `1 <= nums[i] <= 109`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "nums = [1,2,3,4,5]",
+            "output": "6 "
+        },
+        {
+            "label": "Example 2",
+            "input": "nums = [10,12,13,14,15]",
+            "output": "11 "
+        },
+        {
+            "label": "Example 3",
+            "input": "nums = [22,33,22,33,22]",
+            "output": "22 "
+        }
+    ],
+    "private_test_cases": [],
+    "haskell_template": "minimumCost :: [Int] -> Int\nminimumCost nums ",
+    "ocaml_template": "let minimumCost (nums: int list) : int =  ",
+    "scala_template": "def minimumCost(nums: List[Int]): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public long minimumCost(int[] nums) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def minimumCost(self, nums):\n        \"\"\"\n        :type nums: List[int]\n        :rtype: int\n        \"\"\"\n        "
+}

minimum_cost_to_make_array_equalindromic/ocaml_tests/main.ml

@@ -0,0 +1,30 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+    let minimumCost (nums: int list) : int =   failwith "Not implemented"
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 6 (minimumCost [1;2;3;4;5])
+
+let test2 _ = assert_equal 11 (minimumCost [10;12;13;14;15])
+
+let test3 _ = assert_equal 22 (minimumCost [22;33;22;33;22])
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for minimumCost" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+  "test3" >:: test3;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

minimum_cost_to_make_array_equalindromic/scala_tests/MySuite.scala

@@ -0,0 +1,16 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.minimumCost(List(1,2,3,4,5)), 6)
+  }
+
+  test("test2") {
+    assertEquals(Main.minimumCost(List(10,12,13,14,15)), 11)
+  }
+
+  test("test3") {
+    assertEquals(Main.minimumCost(List(22,33,22,33,22)), 22)
+  }
+
+}

minimum_cost_to_make_arrays_identical/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(13, minCost(new ArrayList<>(Arrays.asList(-7,9,5)), new ArrayList<>(Arrays.asList(7,-2,-5)), 2));
+}
+@Test
+public void test2() {
+    assertEquals(0, minCost(new ArrayList<>(Arrays.asList(2,1)), new ArrayList<>(Arrays.asList(2,1)), 0));
+}
+
+}

minimum_cost_to_make_arrays_identical/meta.json

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

minimum_cost_to_set_cooking_time/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 (minCostSetTime 1 2 1 600)," 6 (minCostSetTime 1 2 1 600))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (minCostSetTime 0 1 2 76)," 6 (minCostSetTime 0 1 2 76))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

minimum_cost_to_set_cooking_time/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(6, minCostSetTime(1, 2, 1, 600));
+}
+@Test
+public void test2() {
+    assertEquals(6, minCostSetTime(0, 1, 2, 76));
+}
+
+}

minimum_cost_to_set_cooking_time/meta.json

@@ -0,0 +1,117 @@
+{
+    "id": 2266,
+    "name": "minimum_cost_to_set_cooking_time",
+    "difficulty": "Medium",
+    "link": "https://leetcode.com/problems/minimum-cost-to-set-cooking-time/",
+    "date": "1642809600000",
+    "task_description": "A generic microwave supports cooking times for: at least `1` second. at most `99` minutes and `99` seconds. To set the cooking time, you push **at most four digits**. The microwave normalizes what you push as four digits by **prepending zeroes**. It interprets the **first** two digits as the minutes and the **last** two digits as the seconds. It then **adds** them up as the cooking time. For example, You push `9` `5` `4` (three digits). It is normalized as `0954` and interpreted as `9` minutes and `54` seconds. You push `0` `0` `0` `8` (four digits). It is interpreted as `0` minutes and `8` seconds. You push `8` `0` `9` `0`. It is interpreted as `80` minutes and `90` seconds. You push `8` `1` `3` `0`. It is interpreted as `81` minutes and `30` seconds. You are given integers `startAt`, `moveCost`, `pushCost`, and `targetSeconds`. **Initially**, your finger is on the digit `startAt`. Moving the finger above **any specific digit** costs `moveCost` units of fatigue. Pushing the digit below the finger **once** costs `pushCost` units of fatigue. There can be multiple ways to set the microwave to cook for `targetSeconds` seconds but you are interested in the way with the minimum cost. Return _the **minimum cost** to set_ `targetSeconds` _seconds of cooking time_. Remember that one minute consists of `60` seconds. **Example 1:** ``` **Input:** startAt = 1, moveCost = 2, pushCost = 1, targetSeconds = 600 **Output:** 6 **Explanation:** The following are the possible ways to set the cooking time. - 1 0 0 0, interpreted as 10 minutes and 0 seconds. The finger is already on digit 1, pushes 1 (with cost 1), moves to 0 (with cost 2), pushes 0 (with cost 1), pushes 0 (with cost 1), and pushes 0 (with cost 1). The cost is: 1 + 2 + 1 + 1 + 1 = 6. This is the minimum cost. - 0 9 6 0, interpreted as 9 minutes and 60 seconds. That is also 600 seconds. The finger moves to 0 (with cost 2), pushes 0 (with cost 1), moves to 9 (with cost 2), pushes 9 (with cost 1), moves to 6 (with cost 2), pushes 6 (with cost 1), moves to 0 (with cost 2), and pushes 0 (with cost 1). The cost is: 2 + 1 + 2 + 1 + 2 + 1 + 2 + 1 = 12. - 9 6 0, normalized as 0960 and interpreted as 9 minutes and 60 seconds. The finger moves to 9 (with cost 2), pushes 9 (with cost 1), moves to 6 (with cost 2), pushes 6 (with cost 1), moves to 0 (with cost 2), and pushes 0 (with cost 1). The cost is: 2 + 1 + 2 + 1 + 2 + 1 = 9. ``` **Example 2:** ``` **Input:** startAt = 0, moveCost = 1, pushCost = 2, targetSeconds = 76 **Output:** 6 **Explanation:** The optimal way is to push two digits: 7 6, interpreted as 76 seconds. The finger moves to 7 (with cost 1), pushes 7 (with cost 2), moves to 6 (with cost 1), and pushes 6 (with cost 2). The total cost is: 1 + 2 + 1 + 2 = 6 Note other possible ways are 0076, 076, 0116, and 116, but none of them produces the minimum cost. ``` **Constraints:** `0 <= startAt <= 9` `1 <= moveCost, pushCost <= 105` `1 <= targetSeconds <= 6039`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "startAt = 1, moveCost = 2, pushCost = 1, targetSeconds = 600",
+            "output": "6 "
+        },
+        {
+            "label": "Example 2",
+            "input": "startAt = 0, moveCost = 1, pushCost = 2, targetSeconds = 76",
+            "output": "6 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                7,
+                71964,
+                50245,
+                4721
+            ],
+            "output": 416872
+        },
+        {
+            "input": [
+                6,
+                91933,
+                82787,
+                3978
+            ],
+            "output": 515014
+        },
+        {
+            "input": [
+                8,
+                557,
+                34344,
+                5384
+            ],
+            "output": 138490
+        },
+        {
+            "input": [
+                7,
+                5088,
+                70480,
+                358
+            ],
+            "output": 221616
+        },
+        {
+            "input": [
+                7,
+                35988,
+                89071,
+                5807
+            ],
+            "output": 500236
+        },
+        {
+            "input": [
+                5,
+                46652,
+                46124,
+                5331
+            ],
+            "output": 324452
+        },
+        {
+            "input": [
+                3,
+                88643,
+                80681,
+                809
+            ],
+            "output": 677296
+        },
+        {
+            "input": [
+                3,
+                15189,
+                6466,
+                4984
+            ],
+            "output": 86620
+        },
+        {
+            "input": [
+                9,
+                14158,
+                13109,
+                6038
+            ],
+            "output": 66594
+        },
+        {
+            "input": [
+                5,
+                83324,
+                22235,
+                2554
+            ],
+            "output": 422236
+        }
+    ],
+    "haskell_template": "minCostSetTime :: Int -> Int -> Int -> Int -> Int\nminCostSetTime startAt moveCost pushCost targetSeconds ",
+    "ocaml_template": "let minCostSetTime (startAt: int) (moveCost: int) (pushCost: int) (targetSeconds: int) : int =  ",
+    "scala_template": "def minCostSetTime(startAt: Int,moveCost: Int,pushCost: Int,targetSeconds: Int): Int = { \n    \n}",
+    "java_template": "public static int minCostSetTime(int startAt, int moveCost, int pushCost, int targetSeconds) {\n\n}",
+    "python_template": "class Solution(object):\n    def minCostSetTime(self, startAt, moveCost, pushCost, targetSeconds):\n        \"\"\"\n        :type startAt: int\n        :type moveCost: int\n        :type pushCost: int\n        :type targetSeconds: int\n        :rtype: int\n        \"\"\"\n        "
+}

minimum_cost_to_set_cooking_time/ocaml_tests/main.ml

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

minimum_cost_to_set_cooking_time/scala_tests/MySuite.scala

@@ -0,0 +1,12 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.minCostSetTime(1,2,1,600), 6)
+  }
+
+  test("test2") {
+    assertEquals(Main.minCostSetTime(0,1,2,76), 6)
+  }
+
+}

minimum_cost_to_split_an_array/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 (minCost [1,2,1,2,1,3,3] 2)," 8 (minCost [1,2,1,2,1,3,3] 2))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (minCost [1,2,1,2,1] 2)," 6 (minCost [1,2,1,2,1] 2))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (minCost [1,2,1,2,1] 5)," 10 (minCost [1,2,1,2,1] 5))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (minCost [556, 295, 236, 505, 105, 289, 147, 189, 148, 495, 184, 477, 405, 14, 117, 380, 585, 124, 22, 152, 105, 115, 407, 366, 143, 525, 274, 11, 340, 133, 298, 565, 577, 398, 283, 117, 163, 593, 535, 259, 177, 211, 340, 436, 130, 112, 148, 65, 342, 580, 361, 430, 581, 285, 378, 425, 218, 214, 592, 491, 342, 363, 94, 394, 555, 232, 308, 345, 95, 600, 412, 131, 115, 390, 170, 75, 556, 501, 391, 7, 99, 242, 576, 556, 369, 126, 55, 491, 386, 168, 587, 582, 316, 199, 171, 122, 591, 184, 299, 570, 596, 42, 545, 191, 239, 474, 115, 301, 571, 4, 214, 257, 125, 161, 596, 330, 174, 243, 360, 608, 388, 358, 300, 521, 610, 134, 385, 56, 146, 394, 29, 422, 285, 79, 156, 294, 269, 35, 371, 143, 610, 293, 403, 139, 381, 53, 35, 4, 498, 590, 451, 101, 560, 525, 11, 411, 524, 371, 352, 196, 170, 214, 236, 232, 340, 568, 283, 600, 31, 114, 115, 500, 178, 72, 372, 344, 98, 160, 36, 475, 151, 132, 560, 432, 23, 21, 130, 429, 109, 176, 582, 472, 492, 166, 595, 163, 62, 274, 223, 430, 532, 519, 239, 402, 494, 176, 197, 85, 278, 330, 502, 157, 101, 47, 122, 219, 313, 252, 432, 412, 493, 289, 535, 427, 244, 498, 561, 377, 296, 167, 502, 497, 519, 580, 339, 418, 379, 232, 41, 553, 133, 28, 242, 151, 445, 319, 526, 326, 403, 487, 449, 448, 361, 297, 110, 1, 129, 293, 20, 23, 389, 92, 37, 66, 222, 403, 155, 180, 251, 258, 530, 386, 271, 414, 477, 4, 509, 575, 56, 335, 604, 546, 426, 88, 412, 75, 245, 445, 448, 161, 535, 53, 171, 197, 456, 292, 611, 337, 321, 473, 294, 12, 113, 528, 52, 424, 24, 201, 428, 378, 71, 551, 486, 458, 279, 567, 41, 312, 374, 28, 426, 567, 280, 447, 552, 432, 516, 479, 369, 276, 465, 287, 101, 521, 177, 164, 162, 298, 472, 399, 104, 545, 562, 342, 278, 371, 115, 245, 258, 154, 248, 46, 257, 18, 360, 322, 302, 31, 593, 425, 107, 405, 290, 264, 365, 548, 400, 200, 132, 312, 257, 524, 534, 31, 545, 554, 601, 211, 472, 402, 493, 28, 583, 367, 16, 282, 565, 488, 351, 517, 503, 148, 389, 78, 14, 208, 482, 153, 80, 336, 570, 537, 1, 226, 387, 150, 394, 275, 17, 387, 577, 454, 293, 356, 548, 464, 197, 291, 47, 299, 62, 197, 278, 286, 188, 486, 601, 15, 594, 276, 160, 265, 159, 188, 119, 259, 116, 5, 521, 58, 146, 222, 610, 141, 419, 514, 324, 352, 188, 244, 80, 572, 292, 293, 62, 357, 293, 376, 100, 450, 156, 440, 84, 305, 239, 424, 419, 406, 254, 213, 558, 100, 553, 1, 113, 153, 97, 189, 101, 302, 217, 414, 407, 515, 31, 194, 158, 237, 418, 592, 387, 345, 182, 439, 505, 59, 91, 220, 428, 178, 94, 606, 122, 412, 443, 471, 363, 331, 176, 324, 502, 123, 244, 261, 385, 310, 455, 609, 213, 557, 443, 347, 428, 123, 157, 561, 286, 317, 136, 324, 565, 87, 395, 598, 529, 451, 10, 574, 540, 351, 305, 560, 427, 503, 575, 71, 70, 431, 114, 147, 0, 577, 496, 227, 447, 441, 350, 47, 500, 610, 539, 209, 514, 490, 320, 539, 515, 567, 308, 327, 74, 494, 579, 551, 420, 494, 35, 603, 9, 473, 31, 105, 353, 116, 503, 403, 163, 151, 195, 146, 544, 338, 537, 188, 132, 375, 300, 571, 396, 398, 201, 356, 603, 291, 228, 566, 53, 236, 583, 209, 241, 288] 318885581)," 318885978 (minCost [556, 295, 236, 505, 105, 289, 147, 189, 148, 495, 184, 477, 405, 14, 117, 380, 585, 124, 22, 152, 105, 115, 407, 366, 143, 525, 274, 11, 340, 133, 298, 565, 577, 398, 283, 117, 163, 593, 535, 259, 177, 211, 340, 436, 130, 112, 148, 65, 342, 580, 361, 430, 581, 285, 378, 425, 218, 214, 592, 491, 342, 363, 94, 394, 555, 232, 308, 345, 95, 600, 412, 131, 115, 390, 170, 75, 556, 501, 391, 7, 99, 242, 576, 556, 369, 126, 55, 491, 386, 168, 587, 582, 316, 199, 171, 122, 591, 184, 299, 570, 596, 42, 545, 191, 239, 474, 115, 301, 571, 4, 214, 257, 125, 161, 596, 330, 174, 243, 360, 608, 388, 358, 300, 521, 610, 134, 385, 56, 146, 394, 29, 422, 285, 79, 156, 294, 269, 35, 371, 143, 610, 293, 403, 139, 381, 53, 35, 4, 498, 590, 451, 101, 560, 525, 11, 411, 524, 371, 352, 196, 170, 214, 236, 232, 340, 568, 283, 600, 31, 114, 115, 500, 178, 72, 372, 344, 98, 160, 36, 475, 151, 132, 560, 432, 23, 21, 130, 429, 109, 176, 582, 472, 492, 166, 595, 163, 62, 274, 223, 430, 532, 519, 239, 402, 494, 176, 197, 85, 278, 330, 502, 157, 101, 47, 122, 219, 313, 252, 432, 412, 493, 289, 535, 427, 244, 498, 561, 377, 296, 167, 502, 497, 519, 580, 339, 418, 379, 232, 41, 553, 133, 28, 242, 151, 445, 319, 526, 326, 403, 487, 449, 448, 361, 297, 110, 1, 129, 293, 20, 23, 389, 92, 37, 66, 222, 403, 155, 180, 251, 258, 530, 386, 271, 414, 477, 4, 509, 575, 56, 335, 604, 546, 426, 88, 412, 75, 245, 445, 448, 161, 535, 53, 171, 197, 456, 292, 611, 337, 321, 473, 294, 12, 113, 528, 52, 424, 24, 201, 428, 378, 71, 551, 486, 458, 279, 567, 41, 312, 374, 28, 426, 567, 280, 447, 552, 432, 516, 479, 369, 276, 465, 287, 101, 521, 177, 164, 162, 298, 472, 399, 104, 545, 562, 342, 278, 371, 115, 245, 258, 154, 248, 46, 257, 18, 360, 322, 302, 31, 593, 425, 107, 405, 290, 264, 365, 548, 400, 200, 132, 312, 257, 524, 534, 31, 545, 554, 601, 211, 472, 402, 493, 28, 583, 367, 16, 282, 565, 488, 351, 517, 503, 148, 389, 78, 14, 208, 482, 153, 80, 336, 570, 537, 1, 226, 387, 150, 394, 275, 17, 387, 577, 454, 293, 356, 548, 464, 197, 291, 47, 299, 62, 197, 278, 286, 188, 486, 601, 15, 594, 276, 160, 265, 159, 188, 119, 259, 116, 5, 521, 58, 146, 222, 610, 141, 419, 514, 324, 352, 188, 244, 80, 572, 292, 293, 62, 357, 293, 376, 100, 450, 156, 440, 84, 305, 239, 424, 419, 406, 254, 213, 558, 100, 553, 1, 113, 153, 97, 189, 101, 302, 217, 414, 407, 515, 31, 194, 158, 237, 418, 592, 387, 345, 182, 439, 505, 59, 91, 220, 428, 178, 94, 606, 122, 412, 443, 471, 363, 331, 176, 324, 502, 123, 244, 261, 385, 310, 455, 609, 213, 557, 443, 347, 428, 123, 157, 561, 286, 317, 136, 324, 565, 87, 395, 598, 529, 451, 10, 574, 540, 351, 305, 560, 427, 503, 575, 71, 70, 431, 114, 147, 0, 577, 496, 227, 447, 441, 350, 47, 500, 610, 539, 209, 514, 490, 320, 539, 515, 567, 308, 327, 74, 494, 579, 551, 420, 494, 35, 603, 9, 473, 31, 105, 353, 116, 503, 403, 163, 151, 195, 146, 544, 338, 537, 188, 132, 375, 300, 571, 396, 398, 201, 356, 603, 291, 228, 566, 53, 236, 583, 209, 241, 288] 318885581))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (minCost [436, 88, 79, 214, 18, 319, 225, 299, 468, 11, 446, 320, 111, 295, 115, 449, 195, 57, 75, 493, 460, 229, 460, 75, 215, 208, 372, 255, 398, 484, 400, 265, 102, 24, 79, 384, 363, 58, 220, 256, 323, 141, 177, 80, 321, 471, 20, 219, 263, 353, 135, 127, 478, 143, 197, 431, 241, 461, 475, 36, 146, 51, 452, 336, 370, 217, 97, 92, 443, 343, 379, 378, 375, 251, 31, 246, 159, 259, 519, 33, 212, 199, 415, 230, 404, 350, 98, 37, 287, 158, 234, 7, 281, 365, 507, 380, 363, 230, 170, 159, 492, 232, 122, 98, 380, 196, 520, 480, 218, 490, 120, 453, 177, 134, 457, 199, 361, 54, 241, 416, 107, 339, 425, 249, 246, 39, 529, 48, 42, 342, 136, 128, 311, 460, 189, 150, 272, 211, 404, 358, 462, 496, 327, 102, 428, 507, 468, 170, 273, 54, 52, 444, 34, 292, 479, 262, 15, 436, 480, 226, 175, 216, 71, 501, 361, 155, 139, 200, 148, 422, 93, 383, 195, 88, 29, 251, 336, 100, 456, 291, 367, 50, 364, 409, 158, 372, 223, 470, 289, 471, 451, 359, 345, 435, 16, 360, 234, 402, 105, 5, 351, 310, 51, 39, 288, 73, 379, 306, 331, 80, 275, 217, 125, 423, 75, 334, 61, 108, 165, 11, 112, 486, 62, 85, 105, 268, 255, 76, 406, 382, 317, 528, 21, 146, 477, 349, 101, 249, 27, 198, 292, 399, 363, 316, 137, 105, 211, 166, 295, 149, 17, 165, 282, 250, 395, 396, 65, 254, 77, 402, 442, 366, 113, 336, 79, 195, 458, 233, 366, 513, 402, 352, 131, 109, 497, 149, 363, 196, 1, 46, 226, 272, 400, 349, 138, 105, 290, 149, 253, 58, 498, 47, 529, 208, 232, 296, 423, 260, 98, 253, 47, 180, 524, 94, 70, 28, 503, 18, 75, 260, 61, 425, 458, 231, 212, 190, 50, 207, 237, 414, 164, 350, 9, 409, 183, 234, 334, 158, 177, 224, 204, 273, 27, 502, 462, 337, 365, 521, 466, 319, 428, 180, 242, 266, 250, 458, 293, 19, 53, 270, 349, 13, 246, 226, 315, 53, 409, 368, 103, 364, 57, 286, 455, 320, 112, 17, 57, 137, 234, 344, 167, 529, 270, 324, 382, 4, 420, 70, 257, 444, 185, 32, 103, 261, 215, 227, 477, 431, 448, 335, 171, 165, 161, 168, 530, 409, 78, 407, 378, 412, 326, 338, 302, 106, 274, 375, 78, 44, 395, 92, 438, 75, 152, 116, 270, 332, 182, 484, 470, 142, 283, 344, 243, 183, 169, 446, 262, 425, 518, 198, 44, 383, 332, 381, 311, 434, 213, 242, 255, 530, 343, 265, 434, 229, 255, 114, 466, 477, 159, 521, 498, 8, 289, 323, 293, 527, 471, 459, 206, 431, 23, 266, 179, 66, 502, 207, 138, 286, 239, 394, 437, 60, 510, 325, 407, 197, 136, 373, 347, 441, 72, 419, 179, 305, 381, 10, 119, 288, 16, 386, 188, 241, 15, 322, 349, 181, 54, 295, 297, 335, 211, 199, 281, 397, 282, 215, 131, 7, 92, 324, 252, 201, 506, 299, 135, 98, 468, 1, 258, 377, 97, 371, 520, 426, 179, 514, 488, 238, 506, 47, 393] 440648021)," 440648356 (minCost [436, 88, 79, 214, 18, 319, 225, 299, 468, 11, 446, 320, 111, 295, 115, 449, 195, 57, 75, 493, 460, 229, 460, 75, 215, 208, 372, 255, 398, 484, 400, 265, 102, 24, 79, 384, 363, 58, 220, 256, 323, 141, 177, 80, 321, 471, 20, 219, 263, 353, 135, 127, 478, 143, 197, 431, 241, 461, 475, 36, 146, 51, 452, 336, 370, 217, 97, 92, 443, 343, 379, 378, 375, 251, 31, 246, 159, 259, 519, 33, 212, 199, 415, 230, 404, 350, 98, 37, 287, 158, 234, 7, 281, 365, 507, 380, 363, 230, 170, 159, 492, 232, 122, 98, 380, 196, 520, 480, 218, 490, 120, 453, 177, 134, 457, 199, 361, 54, 241, 416, 107, 339, 425, 249, 246, 39, 529, 48, 42, 342, 136, 128, 311, 460, 189, 150, 272, 211, 404, 358, 462, 496, 327, 102, 428, 507, 468, 170, 273, 54, 52, 444, 34, 292, 479, 262, 15, 436, 480, 226, 175, 216, 71, 501, 361, 155, 139, 200, 148, 422, 93, 383, 195, 88, 29, 251, 336, 100, 456, 291, 367, 50, 364, 409, 158, 372, 223, 470, 289, 471, 451, 359, 345, 435, 16, 360, 234, 402, 105, 5, 351, 310, 51, 39, 288, 73, 379, 306, 331, 80, 275, 217, 125, 423, 75, 334, 61, 108, 165, 11, 112, 486, 62, 85, 105, 268, 255, 76, 406, 382, 317, 528, 21, 146, 477, 349, 101, 249, 27, 198, 292, 399, 363, 316, 137, 105, 211, 166, 295, 149, 17, 165, 282, 250, 395, 396, 65, 254, 77, 402, 442, 366, 113, 336, 79, 195, 458, 233, 366, 513, 402, 352, 131, 109, 497, 149, 363, 196, 1, 46, 226, 272, 400, 349, 138, 105, 290, 149, 253, 58, 498, 47, 529, 208, 232, 296, 423, 260, 98, 253, 47, 180, 524, 94, 70, 28, 503, 18, 75, 260, 61, 425, 458, 231, 212, 190, 50, 207, 237, 414, 164, 350, 9, 409, 183, 234, 334, 158, 177, 224, 204, 273, 27, 502, 462, 337, 365, 521, 466, 319, 428, 180, 242, 266, 250, 458, 293, 19, 53, 270, 349, 13, 246, 226, 315, 53, 409, 368, 103, 364, 57, 286, 455, 320, 112, 17, 57, 137, 234, 344, 167, 529, 270, 324, 382, 4, 420, 70, 257, 444, 185, 32, 103, 261, 215, 227, 477, 431, 448, 335, 171, 165, 161, 168, 530, 409, 78, 407, 378, 412, 326, 338, 302, 106, 274, 375, 78, 44, 395, 92, 438, 75, 152, 116, 270, 332, 182, 484, 470, 142, 283, 344, 243, 183, 169, 446, 262, 425, 518, 198, 44, 383, 332, 381, 311, 434, 213, 242, 255, 530, 343, 265, 434, 229, 255, 114, 466, 477, 159, 521, 498, 8, 289, 323, 293, 527, 471, 459, 206, 431, 23, 266, 179, 66, 502, 207, 138, 286, 239, 394, 437, 60, 510, 325, 407, 197, 136, 373, 347, 441, 72, 419, 179, 305, 381, 10, 119, 288, 16, 386, 188, 241, 15, 322, 349, 181, 54, 295, 297, 335, 211, 199, 281, 397, 282, 215, 131, 7, 92, 324, 252, 201, 506, 299, 135, 98, 468, 1, 258, 377, 97, 371, 520, 426, 179, 514, 488, 238, 506, 47, 393] 440648021))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (minCost [699, 277, 733, 143, 496, 112, 374, 61, 228, 297, 536, 119, 671, 314, 426, 668, 534, 58, 701, 159, 464, 119, 494, 58, 232, 271, 751, 367, 692, 473, 325, 274, 665, 688, 456, 167, 6, 484, 301, 353, 431, 86, 39, 727, 570, 14, 18, 176, 8, 234, 722, 405, 385, 396, 363, 405, 676, 586, 578, 735, 239, 368, 363, 258, 310, 278, 470, 712, 364, 753, 76, 175, 20, 634, 518, 252, 732, 679, 291, 475, 344, 405, 655, 699, 729, 543, 734, 426, 66, 1, 670, 550, 330, 175, 269, 184, 632, 605, 487, 91, 706, 743, 253, 230, 52, 609, 622, 663, 14, 8, 190, 258, 715, 38, 436, 259, 218, 489, 153, 129, 751, 30, 288, 408, 59, 79, 409, 332, 421, 391, 312, 156, 422, 13, 178, 251, 271, 325, 347, 446, 729, 187, 178, 114, 52, 428, 642, 620, 642, 618, 152, 402, 694, 671, 444, 29, 503, 482, 99, 64, 119, 575, 162, 354, 223, 365, 359, 731, 341, 36, 188, 488, 723, 398, 499, 428, 546, 87, 704, 155, 422, 87, 106, 223, 392, 399, 577, 59, 190, 725, 609, 411, 550, 611, 205, 731, 677, 85, 477, 416, 67, 440, 661, 734, 226, 457, 104, 177, 73, 109, 225, 157, 62, 442, 593, 118, 716, 514, 395, 509, 357, 130, 27, 661, 49, 433, 380, 116, 93, 651, 306, 359, 119, 466, 554, 152, 398, 425, 206, 524, 259, 334, 40, 60, 397, 431, 98, 315, 549, 214, 738, 392, 508, 429, 37, 26, 468, 197, 412, 714, 731, 17, 478, 647, 535, 689, 72, 516, 366, 682, 499, 200, 751, 441, 561, 723, 121, 253, 170, 646, 735, 10, 57, 413, 498, 520, 655, 243, 76, 672, 247, 20, 175, 472, 45, 198, 280, 316, 86, 214, 125, 192, 309, 569, 359, 504, 509, 737, 439, 609, 147, 158, 82, 319, 29, 329, 609, 724, 484, 111, 718, 221, 229, 692, 282, 458, 546, 251, 455, 700, 476, 423, 300, 166, 106, 268, 384, 372, 457, 378, 342, 617, 478, 536, 201, 394, 282, 262, 71, 207, 562, 91, 550, 165, 31, 274, 575, 478, 437, 511, 297, 737, 262, 753, 670, 240, 553, 672, 391, 281, 559, 385, 303, 109, 110, 261, 252, 738, 236, 97, 368, 564, 73, 290, 308, 296, 250, 409, 708, 744, 698, 714, 161, 712, 46, 229, 677, 529, 202, 456, 80, 2, 612, 147, 221, 634, 319, 487, 556, 78, 344, 215, 80, 150, 594, 691, 268, 565, 499, 311, 109, 276, 240, 87, 642, 341, 0, 663, 0, 132, 432, 430, 21, 502, 31, 625, 84, 273, 137, 752, 261, 657, 469, 253, 255, 53, 28, 520, 79, 386, 314, 93, 129, 51, 126, 672, 365, 55, 400, 90, 201, 381, 628, 249, 237, 179, 671, 59, 235, 502, 198, 204, 502, 199, 592, 568, 45, 586, 37, 697, 179, 640, 513, 517, 310, 213, 85, 500, 148, 438, 128, 350, 242, 381, 657, 299, 451, 509, 494, 380, 161, 26, 690, 347, 7, 510, 94, 696, 46, 43, 177, 345, 625, 678, 31, 588, 668, 744, 253, 552, 281, 390, 151, 168, 722, 529, 187, 123, 613, 593, 2, 429, 517, 7, 612, 273, 280, 367, 625, 218, 711, 143, 196, 38, 132, 222, 714, 4, 76, 97, 554, 112, 262, 657, 350, 278, 702, 282, 717, 426, 320, 218, 87, 743, 100, 125, 463, 370, 127, 571, 699, 214, 703, 201, 480, 115, 81, 104, 293, 244, 90, 653, 342, 727, 200, 644, 678, 151, 331, 357, 511, 496, 736, 94, 499, 587, 13, 631, 571, 683, 9, 105, 706, 640, 617, 267, 348, 501, 33, 0, 577, 245, 669, 369, 518, 206, 34, 511, 232, 448, 283, 733, 478, 676, 586, 664, 515, 162, 509, 641, 9, 58, 442, 650, 713, 11, 249, 466, 54, 298, 137, 206, 415, 15, 199, 71, 336, 602, 410, 295, 621, 168, 262, 314, 656, 217, 696, 116, 394, 504, 59, 209, 409, 424, 713, 601, 101, 32, 602, 569, 585, 219, 141, 455, 269, 574, 506, 258, 437, 358, 294, 703, 626, 330, 467, 627, 417, 702, 13, 495, 56, 665, 454, 253, 203, 387, 524, 375, 656, 4, 436, 557, 584, 435, 236, 452, 448, 537, 713, 352, 656, 728, 632, 518, 680, 464, 489, 205, 307, 360, 30, 384, 1, 87, 743, 714, 337, 114, 303, 30, 526, 354, 80, 13, 658, 412, 220, 668, 709, 558, 192, 549, 518, 169, 327, 180, 634, 547, 180, 717, 85, 401, 121, 299] 930884210)," 930884693 (minCost [699, 277, 733, 143, 496, 112, 374, 61, 228, 297, 536, 119, 671, 314, 426, 668, 534, 58, 701, 159, 464, 119, 494, 58, 232, 271, 751, 367, 692, 473, 325, 274, 665, 688, 456, 167, 6, 484, 301, 353, 431, 86, 39, 727, 570, 14, 18, 176, 8, 234, 722, 405, 385, 396, 363, 405, 676, 586, 578, 735, 239, 368, 363, 258, 310, 278, 470, 712, 364, 753, 76, 175, 20, 634, 518, 252, 732, 679, 291, 475, 344, 405, 655, 699, 729, 543, 734, 426, 66, 1, 670, 550, 330, 175, 269, 184, 632, 605, 487, 91, 706, 743, 253, 230, 52, 609, 622, 663, 14, 8, 190, 258, 715, 38, 436, 259, 218, 489, 153, 129, 751, 30, 288, 408, 59, 79, 409, 332, 421, 391, 312, 156, 422, 13, 178, 251, 271, 325, 347, 446, 729, 187, 178, 114, 52, 428, 642, 620, 642, 618, 152, 402, 694, 671, 444, 29, 503, 482, 99, 64, 119, 575, 162, 354, 223, 365, 359, 731, 341, 36, 188, 488, 723, 398, 499, 428, 546, 87, 704, 155, 422, 87, 106, 223, 392, 399, 577, 59, 190, 725, 609, 411, 550, 611, 205, 731, 677, 85, 477, 416, 67, 440, 661, 734, 226, 457, 104, 177, 73, 109, 225, 157, 62, 442, 593, 118, 716, 514, 395, 509, 357, 130, 27, 661, 49, 433, 380, 116, 93, 651, 306, 359, 119, 466, 554, 152, 398, 425, 206, 524, 259, 334, 40, 60, 397, 431, 98, 315, 549, 214, 738, 392, 508, 429, 37, 26, 468, 197, 412, 714, 731, 17, 478, 647, 535, 689, 72, 516, 366, 682, 499, 200, 751, 441, 561, 723, 121, 253, 170, 646, 735, 10, 57, 413, 498, 520, 655, 243, 76, 672, 247, 20, 175, 472, 45, 198, 280, 316, 86, 214, 125, 192, 309, 569, 359, 504, 509, 737, 439, 609, 147, 158, 82, 319, 29, 329, 609, 724, 484, 111, 718, 221, 229, 692, 282, 458, 546, 251, 455, 700, 476, 423, 300, 166, 106, 268, 384, 372, 457, 378, 342, 617, 478, 536, 201, 394, 282, 262, 71, 207, 562, 91, 550, 165, 31, 274, 575, 478, 437, 511, 297, 737, 262, 753, 670, 240, 553, 672, 391, 281, 559, 385, 303, 109, 110, 261, 252, 738, 236, 97, 368, 564, 73, 290, 308, 296, 250, 409, 708, 744, 698, 714, 161, 712, 46, 229, 677, 529, 202, 456, 80, 2, 612, 147, 221, 634, 319, 487, 556, 78, 344, 215, 80, 150, 594, 691, 268, 565, 499, 311, 109, 276, 240, 87, 642, 341, 0, 663, 0, 132, 432, 430, 21, 502, 31, 625, 84, 273, 137, 752, 261, 657, 469, 253, 255, 53, 28, 520, 79, 386, 314, 93, 129, 51, 126, 672, 365, 55, 400, 90, 201, 381, 628, 249, 237, 179, 671, 59, 235, 502, 198, 204, 502, 199, 592, 568, 45, 586, 37, 697, 179, 640, 513, 517, 310, 213, 85, 500, 148, 438, 128, 350, 242, 381, 657, 299, 451, 509, 494, 380, 161, 26, 690, 347, 7, 510, 94, 696, 46, 43, 177, 345, 625, 678, 31, 588, 668, 744, 253, 552, 281, 390, 151, 168, 722, 529, 187, 123, 613, 593, 2, 429, 517, 7, 612, 273, 280, 367, 625, 218, 711, 143, 196, 38, 132, 222, 714, 4, 76, 97, 554, 112, 262, 657, 350, 278, 702, 282, 717, 426, 320, 218, 87, 743, 100, 125, 463, 370, 127, 571, 699, 214, 703, 201, 480, 115, 81, 104, 293, 244, 90, 653, 342, 727, 200, 644, 678, 151, 331, 357, 511, 496, 736, 94, 499, 587, 13, 631, 571, 683, 9, 105, 706, 640, 617, 267, 348, 501, 33, 0, 577, 245, 669, 369, 518, 206, 34, 511, 232, 448, 283, 733, 478, 676, 586, 664, 515, 162, 509, 641, 9, 58, 442, 650, 713, 11, 249, 466, 54, 298, 137, 206, 415, 15, 199, 71, 336, 602, 410, 295, 621, 168, 262, 314, 656, 217, 696, 116, 394, 504, 59, 209, 409, 424, 713, 601, 101, 32, 602, 569, 585, 219, 141, 455, 269, 574, 506, 258, 437, 358, 294, 703, 626, 330, 467, 627, 417, 702, 13, 495, 56, 665, 454, 253, 203, 387, 524, 375, 656, 4, 436, 557, 584, 435, 236, 452, 448, 537, 713, 352, 656, 728, 632, 518, 680, 464, 489, 205, 307, 360, 30, 384, 1, 87, 743, 714, 337, 114, 303, 30, 526, 354, 80, 13, 658, 412, 220, 668, 709, 558, 192, 549, 518, 169, 327, 180, 634, 547, 180, 717, 85, 401, 121, 299] 930884210))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (minCost [59, 51, 83, 114, 94, 60, 119, 97, 2, 96, 80, 13, 76, 59, 137, 89, 29, 108, 133, 100, 66, 110, 42, 131, 110, 53, 5, 139, 130, 143, 27, 30, 105, 77, 80, 125, 32, 66, 105, 112, 41, 127, 75, 15, 26, 90, 89, 83, 5, 45, 24, 56, 36, 109, 98, 25, 61, 101, 120, 115, 12, 76, 121, 26, 25, 131, 110, 35, 21, 22, 44, 97, 25, 120, 104, 101, 82, 36, 70, 84, 43, 41, 22, 53, 19, 47, 95, 53, 123, 9, 114, 119, 91, 122, 80, 80, 60, 99, 142, 145, 123, 124, 137, 124, 61, 30, 59, 133, 59, 29, 39, 127, 22, 2, 107, 31, 76, 3, 64, 106, 83, 38, 28, 32, 124, 78, 37, 40, 110, 99, 65, 21, 93, 121, 50, 16, 32, 23, 12, 131, 40, 60, 34, 36, 129, 67] 495868694)," 495868784 (minCost [59, 51, 83, 114, 94, 60, 119, 97, 2, 96, 80, 13, 76, 59, 137, 89, 29, 108, 133, 100, 66, 110, 42, 131, 110, 53, 5, 139, 130, 143, 27, 30, 105, 77, 80, 125, 32, 66, 105, 112, 41, 127, 75, 15, 26, 90, 89, 83, 5, 45, 24, 56, 36, 109, 98, 25, 61, 101, 120, 115, 12, 76, 121, 26, 25, 131, 110, 35, 21, 22, 44, 97, 25, 120, 104, 101, 82, 36, 70, 84, 43, 41, 22, 53, 19, 47, 95, 53, 123, 9, 114, 119, 91, 122, 80, 80, 60, 99, 142, 145, 123, 124, 137, 124, 61, 30, 59, 133, 59, 29, 39, 127, 22, 2, 107, 31, 76, 3, 64, 106, 83, 38, 28, 32, 124, 78, 37, 40, 110, 99, 65, 21, 93, 121, 50, 16, 32, 23, 12, 131, 40, 60, 34, 36, 129, 67] 495868694))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (minCost [203, 1, 252, 243, 29, 258, 14, 190, 83, 215, 8, 77, 215, 131, 168, 72, 4, 251, 147, 150, 79, 244, 125, 182, 141, 104, 147, 202, 62, 105, 95, 204, 16, 183, 165, 145, 208, 88, 90, 95, 11, 83, 228, 124, 136, 10, 49, 132, 100, 34, 75, 89, 111, 258, 95, 12, 12, 220, 59, 126, 26, 226, 110, 145, 251, 125, 53, 60, 9, 197, 224, 243, 260, 68, 117, 84, 162, 227, 130, 118, 245, 204, 139, 247, 195, 218, 194, 17, 144, 262, 152, 51, 254, 16, 204, 99, 32, 156, 67, 47, 47, 10, 216, 252, 34, 207, 202, 206, 44, 230, 37, 170, 50, 7, 130, 59, 241, 159, 68, 210, 148, 163, 245, 260, 159, 152, 51, 11, 21, 263, 155, 150, 189, 223, 142, 140, 131, 205, 74, 66, 138, 0, 172, 96, 140, 118, 89, 222, 218, 22, 174, 43, 80, 169, 88, 206, 92, 180, 252, 202, 65, 86, 130, 69, 122, 116, 214, 116, 225, 118, 188, 223, 122, 118, 113, 224, 98, 193, 39, 254, 80, 161, 204, 93, 182, 206, 84, 234, 177, 47, 74, 54, 182, 57, 146, 64, 137, 14, 161, 214, 194, 93, 106, 171, 260, 51, 114, 202, 219, 122, 149, 208, 161, 219, 36, 3, 215, 66, 114, 26, 177, 244, 65, 55, 211, 56, 50, 28, 169, 31, 39, 36, 192, 260, 148, 172, 221, 200, 84, 6, 246, 11, 75, 144, 38, 14, 49, 236, 90, 9, 74, 158, 236, 111, 159, 250, 204, 250, 94, 65, 230, 81, 41, 39] 207184027)," 207184195 (minCost [203, 1, 252, 243, 29, 258, 14, 190, 83, 215, 8, 77, 215, 131, 168, 72, 4, 251, 147, 150, 79, 244, 125, 182, 141, 104, 147, 202, 62, 105, 95, 204, 16, 183, 165, 145, 208, 88, 90, 95, 11, 83, 228, 124, 136, 10, 49, 132, 100, 34, 75, 89, 111, 258, 95, 12, 12, 220, 59, 126, 26, 226, 110, 145, 251, 125, 53, 60, 9, 197, 224, 243, 260, 68, 117, 84, 162, 227, 130, 118, 245, 204, 139, 247, 195, 218, 194, 17, 144, 262, 152, 51, 254, 16, 204, 99, 32, 156, 67, 47, 47, 10, 216, 252, 34, 207, 202, 206, 44, 230, 37, 170, 50, 7, 130, 59, 241, 159, 68, 210, 148, 163, 245, 260, 159, 152, 51, 11, 21, 263, 155, 150, 189, 223, 142, 140, 131, 205, 74, 66, 138, 0, 172, 96, 140, 118, 89, 222, 218, 22, 174, 43, 80, 169, 88, 206, 92, 180, 252, 202, 65, 86, 130, 69, 122, 116, 214, 116, 225, 118, 188, 223, 122, 118, 113, 224, 98, 193, 39, 254, 80, 161, 204, 93, 182, 206, 84, 234, 177, 47, 74, 54, 182, 57, 146, 64, 137, 14, 161, 214, 194, 93, 106, 171, 260, 51, 114, 202, 219, 122, 149, 208, 161, 219, 36, 3, 215, 66, 114, 26, 177, 244, 65, 55, 211, 56, 50, 28, 169, 31, 39, 36, 192, 260, 148, 172, 221, 200, 84, 6, 246, 11, 75, 144, 38, 14, 49, 236, 90, 9, 74, 158, 236, 111, 159, 250, 204, 250, 94, 65, 230, 81, 41, 39] 207184027))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (minCost [340, 77, 284, 344, 349, 100, 397, 234, 284, 331, 29, 59, 416, 87, 354, 250, 125, 176, 345, 286, 188, 118, 380, 324, 308, 383, 118, 210, 145, 35, 141, 233, 196, 298, 153, 221, 208, 18, 75, 142, 403, 104, 252, 248, 413, 12, 200, 167, 346, 57, 19, 392, 7, 279, 278, 331, 285, 129, 295, 300, 19, 418, 338, 370, 7, 56, 271, 116, 321, 165, 45, 413, 21, 60, 161, 271, 204, 288, 372, 67, 366, 278, 224, 205, 144, 103, 241, 27, 182, 406, 325, 238, 49, 292, 385, 57, 297, 364, 135, 173, 345, 318, 58, 29, 416, 248, 291, 333, 274, 68, 104, 89, 250, 173, 32, 323, 190, 209, 104, 81, 250, 207, 149, 60, 170, 303, 73, 215, 345, 390, 255, 233, 331, 274, 12, 172, 235, 105, 349, 294, 163, 353, 36, 227, 239, 9, 375, 118, 40, 231, 41, 406, 211, 79, 122, 105, 341, 160, 403, 162, 253, 60, 339, 22, 137, 173, 161, 21, 95, 179, 160, 62, 337, 396, 410, 325, 387, 237, 290, 31, 258, 303, 397, 239, 351, 37, 218, 60, 201, 60, 125, 330, 175, 70, 195, 297, 385, 333, 326, 157, 236, 176, 242, 222, 181, 262, 113, 404, 75, 156, 131, 406, 273, 48, 134, 6, 240, 299, 307, 52, 151, 33, 277, 344, 2, 114, 185, 266, 39, 26, 351, 77, 9, 388, 7, 183, 77, 390, 126, 145, 16, 195, 47, 116, 34, 96, 211, 376, 159, 222, 13, 242, 174, 376, 154, 255, 2, 288, 195, 355, 47, 190, 161, 3, 198, 330, 217, 46, 403, 362, 8, 77, 389, 344, 208, 293, 299, 191, 12, 183, 406, 356, 311, 33, 223, 378, 153, 271, 302, 131, 209, 99, 205, 163, 59, 84, 288, 402, 118, 286, 362, 216, 418, 344, 253, 111, 184, 128, 149, 191, 184, 47, 14, 176, 202, 331, 97, 11, 307, 324, 120, 219, 200, 103, 207, 215, 388, 10, 391, 142, 254, 383, 28, 213, 212, 63, 395, 96, 285, 182, 239, 196, 338, 259, 208, 407, 169, 107, 224, 39, 282, 22, 123, 181, 248, 384, 184, 63, 369, 138, 152, 180, 304, 418, 388, 418, 108, 73, 175, 114, 409, 175, 83, 364, 8, 39, 127, 391, 217, 282, 364, 73, 231, 105, 55, 303, 107, 387, 207, 127, 37, 344, 94, 269, 157, 252, 151, 318, 203, 153, 254, 123, 349, 235, 164, 329, 268, 355, 61, 233, 247, 86, 39, 125, 371, 415, 143, 350, 402, 59] 939948695)," 939948968 (minCost [340, 77, 284, 344, 349, 100, 397, 234, 284, 331, 29, 59, 416, 87, 354, 250, 125, 176, 345, 286, 188, 118, 380, 324, 308, 383, 118, 210, 145, 35, 141, 233, 196, 298, 153, 221, 208, 18, 75, 142, 403, 104, 252, 248, 413, 12, 200, 167, 346, 57, 19, 392, 7, 279, 278, 331, 285, 129, 295, 300, 19, 418, 338, 370, 7, 56, 271, 116, 321, 165, 45, 413, 21, 60, 161, 271, 204, 288, 372, 67, 366, 278, 224, 205, 144, 103, 241, 27, 182, 406, 325, 238, 49, 292, 385, 57, 297, 364, 135, 173, 345, 318, 58, 29, 416, 248, 291, 333, 274, 68, 104, 89, 250, 173, 32, 323, 190, 209, 104, 81, 250, 207, 149, 60, 170, 303, 73, 215, 345, 390, 255, 233, 331, 274, 12, 172, 235, 105, 349, 294, 163, 353, 36, 227, 239, 9, 375, 118, 40, 231, 41, 406, 211, 79, 122, 105, 341, 160, 403, 162, 253, 60, 339, 22, 137, 173, 161, 21, 95, 179, 160, 62, 337, 396, 410, 325, 387, 237, 290, 31, 258, 303, 397, 239, 351, 37, 218, 60, 201, 60, 125, 330, 175, 70, 195, 297, 385, 333, 326, 157, 236, 176, 242, 222, 181, 262, 113, 404, 75, 156, 131, 406, 273, 48, 134, 6, 240, 299, 307, 52, 151, 33, 277, 344, 2, 114, 185, 266, 39, 26, 351, 77, 9, 388, 7, 183, 77, 390, 126, 145, 16, 195, 47, 116, 34, 96, 211, 376, 159, 222, 13, 242, 174, 376, 154, 255, 2, 288, 195, 355, 47, 190, 161, 3, 198, 330, 217, 46, 403, 362, 8, 77, 389, 344, 208, 293, 299, 191, 12, 183, 406, 356, 311, 33, 223, 378, 153, 271, 302, 131, 209, 99, 205, 163, 59, 84, 288, 402, 118, 286, 362, 216, 418, 344, 253, 111, 184, 128, 149, 191, 184, 47, 14, 176, 202, 331, 97, 11, 307, 324, 120, 219, 200, 103, 207, 215, 388, 10, 391, 142, 254, 383, 28, 213, 212, 63, 395, 96, 285, 182, 239, 196, 338, 259, 208, 407, 169, 107, 224, 39, 282, 22, 123, 181, 248, 384, 184, 63, 369, 138, 152, 180, 304, 418, 388, 418, 108, 73, 175, 114, 409, 175, 83, 364, 8, 39, 127, 391, 217, 282, 364, 73, 231, 105, 55, 303, 107, 387, 207, 127, 37, 344, 94, 269, 157, 252, 151, 318, 203, 153, 254, 123, 349, 235, 164, 329, 268, 355, 61, 233, 247, 86, 39, 125, 371, 415, 143, 350, 402, 59] 939948695))
+
+
+-- 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

minimum_cost_to_split_an_array/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(8, minCost(new ArrayList<>(Arrays.asList(1,2,1,2,1,3,3)), 2));
+}
+@Test
+public void test2() {
+    assertEquals(6, minCost(new ArrayList<>(Arrays.asList(1,2,1,2,1)), 2));
+}
+@Test
+public void test3() {
+    assertEquals(10, minCost(new ArrayList<>(Arrays.asList(1,2,1,2,1)), 5));
+}
+
+}

minimum_cost_to_split_an_array/meta.json

@@ -0,0 +1,3728 @@
+{
+    "id": 2633,
+    "name": "minimum_cost_to_split_an_array",
+    "difficulty": "Hard",
+    "link": "https://leetcode.com/problems/minimum-cost-to-split-an-array/",
+    "date": "2023-01-15 00:00:00",
+    "task_description": "You are given an integer array `nums` and an integer `k`. Split the array into some number of non-empty subarrays. The **cost** of a split is the sum of the **importance value** of each subarray in the split. Let `trimmed(subarray)` be the version of the subarray where all numbers which appear only once are removed. For example, `trimmed([3,1,2,4,3,4]) = [3,4,3,4].` The **importance value** of a subarray is `k + trimmed(subarray).length`. For example, if a subarray is `[1,2,3,3,3,4,4]`, then trimmed(`[1,2,3,3,3,4,4]) = [3,3,3,4,4].`The importance value of this subarray will be `k + 5`. Return _the minimum possible cost of a split of _`nums`. A **subarray** is a contiguous **non-empty** sequence of elements within an array. **Example 1:** ``` **Input:** nums = [1,2,1,2,1,3,3], k = 2 **Output:** 8 **Explanation:** We split nums to have two subarrays: [1,2], [1,2,1,3,3]. The importance value of [1,2] is 2 + (0) = 2. The importance value of [1,2,1,3,3] is 2 + (2 + 2) = 6. The cost of the split is 2 + 6 = 8. It can be shown that this is the minimum possible cost among all the possible splits. ``` **Example 2:** ``` **Input:** nums = [1,2,1,2,1], k = 2 **Output:** 6 **Explanation:** We split nums to have two subarrays: [1,2], [1,2,1]. The importance value of [1,2] is 2 + (0) = 2. The importance value of [1,2,1] is 2 + (2) = 4. The cost of the split is 2 + 4 = 6. It can be shown that this is the minimum possible cost among all the possible splits. ``` **Example 3:** ``` **Input:** nums = [1,2,1,2,1], k = 5 **Output:** 10 **Explanation:** We split nums to have one subarray: [1,2,1,2,1]. The importance value of [1,2,1,2,1] is 5 + (3 + 2) = 10. The cost of the split is 10. It can be shown that this is the minimum possible cost among all the possible splits. ``` **Constraints:** `1 <= nums.length <= 1000` `0 <= nums[i] < nums.length` `1 <= k <= 109`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "nums = [1,2,1,2,1,3,3], k = 2",
+            "output": "8 "
+        },
+        {
+            "label": "Example 2",
+            "input": "nums = [1,2,1,2,1], k = 2",
+            "output": "6 "
+        },
+        {
+            "label": "Example 3",
+            "input": "nums = [1,2,1,2,1], k = 5",
+            "output": "10 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                [
+                    556,
+                    295,
+                    236,
+                    505,
+                    105,
+                    289,
+                    147,
+                    189,
+                    148,
+                    495,
+                    184,
+                    477,
+                    405,
+                    14,
+                    117,
+                    380,
+                    585,
+                    124,
+                    22,
+                    152,
+                    105,
+                    115,
+                    407,
+                    366,
+                    143,
+                    525,
+                    274,
+                    11,
+                    340,
+                    133,
+                    298,
+                    565,
+                    577,
+                    398,
+                    283,
+                    117,
+                    163,
+                    593,
+                    535,
+                    259,
+                    177,
+                    211,
+                    340,
+                    436,
+                    130,
+                    112,
+                    148,
+                    65,
+                    342,
+                    580,
+                    361,
+                    430,
+                    581,
+                    285,
+                    378,
+                    425,
+                    218,
+                    214,
+                    592,
+                    491,
+                    342,
+                    363,
+                    94,
+                    394,
+                    555,
+                    232,
+                    308,
+                    345,
+                    95,
+                    600,
+                    412,
+                    131,
+                    115,
+                    390,
+                    170,
+                    75,
+                    556,
+                    501,
+                    391,
+                    7,
+                    99,
+                    242,
+                    576,
+                    556,
+                    369,
+                    126,
+                    55,
+                    491,
+                    386,
+                    168,
+                    587,
+                    582,
+                    316,
+                    199,
+                    171,
+                    122,
+                    591,
+                    184,
+                    299,
+                    570,
+                    596,
+                    42,
+                    545,
+                    191,
+                    239,
+                    474,
+                    115,
+                    301,
+                    571,
+                    4,
+                    214,
+                    257,
+                    125,
+                    161,
+                    596,
+                    330,
+                    174,
+                    243,
+                    360,
+                    608,
+                    388,
+                    358,
+                    300,
+                    521,
+                    610,
+                    134,
+                    385,
+                    56,
+                    146,
+                    394,
+                    29,
+                    422,
+                    285,
+                    79,
+                    156,
+                    294,
+                    269,
+                    35,
+                    371,
+                    143,
+                    610,
+                    293,
+                    403,
+                    139,
+                    381,
+                    53,
+                    35,
+                    4,
+                    498,
+                    590,
+                    451,
+                    101,
+                    560,
+                    525,
+                    11,
+                    411,
+                    524,
+                    371,
+                    352,
+                    196,
+                    170,
+                    214,
+                    236,
+                    232,
+                    340,
+                    568,
+                    283,
+                    600,
+                    31,
+                    114,
+                    115,
+                    500,
+                    178,
+                    72,
+                    372,
+                    344,
+                    98,
+                    160,
+                    36,
+                    475,
+                    151,
+                    132,
+                    560,
+                    432,
+                    23,
+                    21,
+                    130,
+                    429,
+                    109,
+                    176,
+                    582,
+                    472,
+                    492,
+                    166,
+                    595,
+                    163,
+                    62,
+                    274,
+                    223,
+                    430,
+                    532,
+                    519,
+                    239,
+                    402,
+                    494,
+                    176,
+                    197,
+                    85,
+                    278,
+                    330,
+                    502,
+                    157,
+                    101,
+                    47,
+                    122,
+                    219,
+                    313,
+                    252,
+                    432,
+                    412,
+                    493,
+                    289,
+                    535,
+                    427,
+                    244,
+                    498,
+                    561,
+                    377,
+                    296,
+                    167,
+                    502,
+                    497,
+                    519,
+                    580,
+                    339,
+                    418,
+                    379,
+                    232,
+                    41,
+                    553,
+                    133,
+                    28,
+                    242,
+                    151,
+                    445,
+                    319,
+                    526,
+                    326,
+                    403,
+                    487,
+                    449,
+                    448,
+                    361,
+                    297,
+                    110,
+                    1,
+                    129,
+                    293,
+                    20,
+                    23,
+                    389,
+                    92,
+                    37,
+                    66,
+                    222,
+                    403,
+                    155,
+                    180,
+                    251,
+                    258,
+                    530,
+                    386,
+                    271,
+                    414,
+                    477,
+                    4,
+                    509,
+                    575,
+                    56,
+                    335,
+                    604,
+                    546,
+                    426,
+                    88,
+                    412,
+                    75,
+                    245,
+                    445,
+                    448,
+                    161,
+                    535,
+                    53,
+                    171,
+                    197,
+                    456,
+                    292,
+                    611,
+                    337,
+                    321,
+                    473,
+                    294,
+                    12,
+                    113,
+                    528,
+                    52,
+                    424,
+                    24,
+                    201,
+                    428,
+                    378,
+                    71,
+                    551,
+                    486,
+                    458,
+                    279,
+                    567,
+                    41,
+                    312,
+                    374,
+                    28,
+                    426,
+                    567,
+                    280,
+                    447,
+                    552,
+                    432,
+                    516,
+                    479,
+                    369,
+                    276,
+                    465,
+                    287,
+                    101,
+                    521,
+                    177,
+                    164,
+                    162,
+                    298,
+                    472,
+                    399,
+                    104,
+                    545,
+                    562,
+                    342,
+                    278,
+                    371,
+                    115,
+                    245,
+                    258,
+                    154,
+                    248,
+                    46,
+                    257,
+                    18,
+                    360,
+                    322,
+                    302,
+                    31,
+                    593,
+                    425,
+                    107,
+                    405,
+                    290,
+                    264,
+                    365,
+                    548,
+                    400,
+                    200,
+                    132,
+                    312,
+                    257,
+                    524,
+                    534,
+                    31,
+                    545,
+                    554,
+                    601,
+                    211,
+                    472,
+                    402,
+                    493,
+                    28,
+                    583,
+                    367,
+                    16,
+                    282,
+                    565,
+                    488,
+                    351,
+                    517,
+                    503,
+                    148,
+                    389,
+                    78,
+                    14,
+                    208,
+                    482,
+                    153,
+                    80,
+                    336,
+                    570,
+                    537,
+                    1,
+                    226,
+                    387,
+                    150,
+                    394,
+                    275,
+                    17,
+                    387,
+                    577,
+                    454,
+                    293,
+                    356,
+                    548,
+                    464,
+                    197,
+                    291,
+                    47,
+                    299,
+                    62,
+                    197,
+                    278,
+                    286,
+                    188,
+                    486,
+                    601,
+                    15,
+                    594,
+                    276,
+                    160,
+                    265,
+                    159,
+                    188,
+                    119,
+                    259,
+                    116,
+                    5,
+                    521,
+                    58,
+                    146,
+                    222,
+                    610,
+                    141,
+                    419,
+                    514,
+                    324,
+                    352,
+                    188,
+                    244,
+                    80,
+                    572,
+                    292,
+                    293,
+                    62,
+                    357,
+                    293,
+                    376,
+                    100,
+                    450,
+                    156,
+                    440,
+                    84,
+                    305,
+                    239,
+                    424,
+                    419,
+                    406,
+                    254,
+                    213,
+                    558,
+                    100,
+                    553,
+                    1,
+                    113,
+                    153,
+                    97,
+                    189,
+                    101,
+                    302,
+                    217,
+                    414,
+                    407,
+                    515,
+                    31,
+                    194,
+                    158,
+                    237,
+                    418,
+                    592,
+                    387,
+                    345,
+                    182,
+                    439,
+                    505,
+                    59,
+                    91,
+                    220,
+                    428,
+                    178,
+                    94,
+                    606,
+                    122,
+                    412,
+                    443,
+                    471,
+                    363,
+                    331,
+                    176,
+                    324,
+                    502,
+                    123,
+                    244,
+                    261,
+                    385,
+                    310,
+                    455,
+                    609,
+                    213,
+                    557,
+                    443,
+                    347,
+                    428,
+                    123,
+                    157,
+                    561,
+                    286,
+                    317,
+                    136,
+                    324,
+                    565,
+                    87,
+                    395,
+                    598,
+                    529,
+                    451,
+                    10,
+                    574,
+                    540,
+                    351,
+                    305,
+                    560,
+                    427,
+                    503,
+                    575,
+                    71,
+                    70,
+                    431,
+                    114,
+                    147,
+                    0,
+                    577,
+                    496,
+                    227,
+                    447,
+                    441,
+                    350,
+                    47,
+                    500,
+                    610,
+                    539,
+                    209,
+                    514,
+                    490,
+                    320,
+                    539,
+                    515,
+                    567,
+                    308,
+                    327,
+                    74,
+                    494,
+                    579,
+                    551,
+                    420,
+                    494,
+                    35,
+                    603,
+                    9,
+                    473,
+                    31,
+                    105,
+                    353,
+                    116,
+                    503,
+                    403,
+                    163,
+                    151,
+                    195,
+                    146,
+                    544,
+                    338,
+                    537,
+                    188,
+                    132,
+                    375,
+                    300,
+                    571,
+                    396,
+                    398,
+                    201,
+                    356,
+                    603,
+                    291,
+                    228,
+                    566,
+                    53,
+                    236,
+                    583,
+                    209,
+                    241,
+                    288
+                ],
+                318885581
+            ],
+            "output": 318885978
+        },
+        {
+            "input": [
+                [
+                    436,
+                    88,
+                    79,
+                    214,
+                    18,
+                    319,
+                    225,
+                    299,
+                    468,
+                    11,
+                    446,
+                    320,
+                    111,
+                    295,
+                    115,
+                    449,
+                    195,
+                    57,
+                    75,
+                    493,
+                    460,
+                    229,
+                    460,
+                    75,
+                    215,
+                    208,
+                    372,
+                    255,
+                    398,
+                    484,
+                    400,
+                    265,
+                    102,
+                    24,
+                    79,
+                    384,
+                    363,
+                    58,
+                    220,
+                    256,
+                    323,
+                    141,
+                    177,
+                    80,
+                    321,
+                    471,
+                    20,
+                    219,
+                    263,
+                    353,
+                    135,
+                    127,
+                    478,
+                    143,
+                    197,
+                    431,
+                    241,
+                    461,
+                    475,
+                    36,
+                    146,
+                    51,
+                    452,
+                    336,
+                    370,
+                    217,
+                    97,
+                    92,
+                    443,
+                    343,
+                    379,
+                    378,
+                    375,
+                    251,
+                    31,
+                    246,
+                    159,
+                    259,
+                    519,
+                    33,
+                    212,
+                    199,
+                    415,
+                    230,
+                    404,
+                    350,
+                    98,
+                    37,
+                    287,
+                    158,
+                    234,
+                    7,
+                    281,
+                    365,
+                    507,
+                    380,
+                    363,
+                    230,
+                    170,
+                    159,
+                    492,
+                    232,
+                    122,
+                    98,
+                    380,
+                    196,
+                    520,
+                    480,
+                    218,
+                    490,
+                    120,
+                    453,
+                    177,
+                    134,
+                    457,
+                    199,
+                    361,
+                    54,
+                    241,
+                    416,
+                    107,
+                    339,
+                    425,
+                    249,
+                    246,
+                    39,
+                    529,
+                    48,
+                    42,
+                    342,
+                    136,
+                    128,
+                    311,
+                    460,
+                    189,
+                    150,
+                    272,
+                    211,
+                    404,
+                    358,
+                    462,
+                    496,
+                    327,
+                    102,
+                    428,
+                    507,
+                    468,
+                    170,
+                    273,
+                    54,
+                    52,
+                    444,
+                    34,
+                    292,
+                    479,
+                    262,
+                    15,
+                    436,
+                    480,
+                    226,
+                    175,
+                    216,
+                    71,
+                    501,
+                    361,
+                    155,
+                    139,
+                    200,
+                    148,
+                    422,
+                    93,
+                    383,
+                    195,
+                    88,
+                    29,
+                    251,
+                    336,
+                    100,
+                    456,
+                    291,
+                    367,
+                    50,
+                    364,
+                    409,
+                    158,
+                    372,
+                    223,
+                    470,
+                    289,
+                    471,
+                    451,
+                    359,
+                    345,
+                    435,
+                    16,
+                    360,
+                    234,
+                    402,
+                    105,
+                    5,
+                    351,
+                    310,
+                    51,
+                    39,
+                    288,
+                    73,
+                    379,
+                    306,
+                    331,
+                    80,
+                    275,
+                    217,
+                    125,
+                    423,
+                    75,
+                    334,
+                    61,
+                    108,
+                    165,
+                    11,
+                    112,
+                    486,
+                    62,
+                    85,
+                    105,
+                    268,
+                    255,
+                    76,
+                    406,
+                    382,
+                    317,
+                    528,
+                    21,
+                    146,
+                    477,
+                    349,
+                    101,
+                    249,
+                    27,
+                    198,
+                    292,
+                    399,
+                    363,
+                    316,
+                    137,
+                    105,
+                    211,
+                    166,
+                    295,
+                    149,
+                    17,
+                    165,
+                    282,
+                    250,
+                    395,
+                    396,
+                    65,
+                    254,
+                    77,
+                    402,
+                    442,
+                    366,
+                    113,
+                    336,
+                    79,
+                    195,
+                    458,
+                    233,
+                    366,
+                    513,
+                    402,
+                    352,
+                    131,
+                    109,
+                    497,
+                    149,
+                    363,
+                    196,
+                    1,
+                    46,
+                    226,
+                    272,
+                    400,
+                    349,
+                    138,
+                    105,
+                    290,
+                    149,
+                    253,
+                    58,
+                    498,
+                    47,
+                    529,
+                    208,
+                    232,
+                    296,
+                    423,
+                    260,
+                    98,
+                    253,
+                    47,
+                    180,
+                    524,
+                    94,
+                    70,
+                    28,
+                    503,
+                    18,
+                    75,
+                    260,
+                    61,
+                    425,
+                    458,
+                    231,
+                    212,
+                    190,
+                    50,
+                    207,
+                    237,
+                    414,
+                    164,
+                    350,
+                    9,
+                    409,
+                    183,
+                    234,
+                    334,
+                    158,
+                    177,
+                    224,
+                    204,
+                    273,
+                    27,
+                    502,
+                    462,
+                    337,
+                    365,
+                    521,
+                    466,
+                    319,
+                    428,
+                    180,
+                    242,
+                    266,
+                    250,
+                    458,
+                    293,
+                    19,
+                    53,
+                    270,
+                    349,
+                    13,
+                    246,
+                    226,
+                    315,
+                    53,
+                    409,
+                    368,
+                    103,
+                    364,
+                    57,
+                    286,
+                    455,
+                    320,
+                    112,
+                    17,
+                    57,
+                    137,
+                    234,
+                    344,
+                    167,
+                    529,
+                    270,
+                    324,
+                    382,
+                    4,
+                    420,
+                    70,
+                    257,
+                    444,
+                    185,
+                    32,
+                    103,
+                    261,
+                    215,
+                    227,
+                    477,
+                    431,
+                    448,
+                    335,
+                    171,
+                    165,
+                    161,
+                    168,
+                    530,
+                    409,
+                    78,
+                    407,
+                    378,
+                    412,
+                    326,
+                    338,
+                    302,
+                    106,
+                    274,
+                    375,
+                    78,
+                    44,
+                    395,
+                    92,
+                    438,
+                    75,
+                    152,
+                    116,
+                    270,
+                    332,
+                    182,
+                    484,
+                    470,
+                    142,
+                    283,
+                    344,
+                    243,
+                    183,
+                    169,
+                    446,
+                    262,
+                    425,
+                    518,
+                    198,
+                    44,
+                    383,
+                    332,
+                    381,
+                    311,
+                    434,
+                    213,
+                    242,
+                    255,
+                    530,
+                    343,
+                    265,
+                    434,
+                    229,
+                    255,
+                    114,
+                    466,
+                    477,
+                    159,
+                    521,
+                    498,
+                    8,
+                    289,
+                    323,
+                    293,
+                    527,
+                    471,
+                    459,
+                    206,
+                    431,
+                    23,
+                    266,
+                    179,
+                    66,
+                    502,
+                    207,
+                    138,
+                    286,
+                    239,
+                    394,
+                    437,
+                    60,
+                    510,
+                    325,
+                    407,
+                    197,
+                    136,
+                    373,
+                    347,
+                    441,
+                    72,
+                    419,
+                    179,
+                    305,
+                    381,
+                    10,
+                    119,
+                    288,
+                    16,
+                    386,
+                    188,
+                    241,
+                    15,
+                    322,
+                    349,
+                    181,
+                    54,
+                    295,
+                    297,
+                    335,
+                    211,
+                    199,
+                    281,
+                    397,
+                    282,
+                    215,
+                    131,
+                    7,
+                    92,
+                    324,
+                    252,
+                    201,
+                    506,
+                    299,
+                    135,
+                    98,
+                    468,
+                    1,
+                    258,
+                    377,
+                    97,
+                    371,
+                    520,
+                    426,
+                    179,
+                    514,
+                    488,
+                    238,
+                    506,
+                    47,
+                    393
+                ],
+                440648021
+            ],
+            "output": 440648356
+        },
+        {
+            "input": [
+                [
+                    699,
+                    277,
+                    733,
+                    143,
+                    496,
+                    112,
+                    374,
+                    61,
+                    228,
+                    297,
+                    536,
+                    119,
+                    671,
+                    314,
+                    426,
+                    668,
+                    534,
+                    58,
+                    701,
+                    159,
+                    464,
+                    119,
+                    494,
+                    58,
+                    232,
+                    271,
+                    751,
+                    367,
+                    692,
+                    473,
+                    325,
+                    274,
+                    665,
+                    688,
+                    456,
+                    167,
+                    6,
+                    484,
+                    301,
+                    353,
+                    431,
+                    86,
+                    39,
+                    727,
+                    570,
+                    14,
+                    18,
+                    176,
+                    8,
+                    234,
+                    722,
+                    405,
+                    385,
+                    396,
+                    363,
+                    405,
+                    676,
+                    586,
+                    578,
+                    735,
+                    239,
+                    368,
+                    363,
+                    258,
+                    310,
+                    278,
+                    470,
+                    712,
+                    364,
+                    753,
+                    76,
+                    175,
+                    20,
+                    634,
+                    518,
+                    252,
+                    732,
+                    679,
+                    291,
+                    475,
+                    344,
+                    405,
+                    655,
+                    699,
+                    729,
+                    543,
+                    734,
+                    426,
+                    66,
+                    1,
+                    670,
+                    550,
+                    330,
+                    175,
+                    269,
+                    184,
+                    632,
+                    605,
+                    487,
+                    91,
+                    706,
+                    743,
+                    253,
+                    230,
+                    52,
+                    609,
+                    622,
+                    663,
+                    14,
+                    8,
+                    190,
+                    258,
+                    715,
+                    38,
+                    436,
+                    259,
+                    218,
+                    489,
+                    153,
+                    129,
+                    751,
+                    30,
+                    288,
+                    408,
+                    59,
+                    79,
+                    409,
+                    332,
+                    421,
+                    391,
+                    312,
+                    156,
+                    422,
+                    13,
+                    178,
+                    251,
+                    271,
+                    325,
+                    347,
+                    446,
+                    729,
+                    187,
+                    178,
+                    114,
+                    52,
+                    428,
+                    642,
+                    620,
+                    642,
+                    618,
+                    152,
+                    402,
+                    694,
+                    671,
+                    444,
+                    29,
+                    503,
+                    482,
+                    99,
+                    64,
+                    119,
+                    575,
+                    162,
+                    354,
+                    223,
+                    365,
+                    359,
+                    731,
+                    341,
+                    36,
+                    188,
+                    488,
+                    723,
+                    398,
+                    499,
+                    428,
+                    546,
+                    87,
+                    704,
+                    155,
+                    422,
+                    87,
+                    106,
+                    223,
+                    392,
+                    399,
+                    577,
+                    59,
+                    190,
+                    725,
+                    609,
+                    411,
+                    550,
+                    611,
+                    205,
+                    731,
+                    677,
+                    85,
+                    477,
+                    416,
+                    67,
+                    440,
+                    661,
+                    734,
+                    226,
+                    457,
+                    104,
+                    177,
+                    73,
+                    109,
+                    225,
+                    157,
+                    62,
+                    442,
+                    593,
+                    118,
+                    716,
+                    514,
+                    395,
+                    509,
+                    357,
+                    130,
+                    27,
+                    661,
+                    49,
+                    433,
+                    380,
+                    116,
+                    93,
+                    651,
+                    306,
+                    359,
+                    119,
+                    466,
+                    554,
+                    152,
+                    398,
+                    425,
+                    206,
+                    524,
+                    259,
+                    334,
+                    40,
+                    60,
+                    397,
+                    431,
+                    98,
+                    315,
+                    549,
+                    214,
+                    738,
+                    392,
+                    508,
+                    429,
+                    37,
+                    26,
+                    468,
+                    197,
+                    412,
+                    714,
+                    731,
+                    17,
+                    478,
+                    647,
+                    535,
+                    689,
+                    72,
+                    516,
+                    366,
+                    682,
+                    499,
+                    200,
+                    751,
+                    441,
+                    561,
+                    723,
+                    121,
+                    253,
+                    170,
+                    646,
+                    735,
+                    10,
+                    57,
+                    413,
+                    498,
+                    520,
+                    655,
+                    243,
+                    76,
+                    672,
+                    247,
+                    20,
+                    175,
+                    472,
+                    45,
+                    198,
+                    280,
+                    316,
+                    86,
+                    214,
+                    125,
+                    192,
+                    309,
+                    569,
+                    359,
+                    504,
+                    509,
+                    737,
+                    439,
+                    609,
+                    147,
+                    158,
+                    82,
+                    319,
+                    29,
+                    329,
+                    609,
+                    724,
+                    484,
+                    111,
+                    718,
+                    221,
+                    229,
+                    692,
+                    282,
+                    458,
+                    546,
+                    251,
+                    455,
+                    700,
+                    476,
+                    423,
+                    300,
+                    166,
+                    106,
+                    268,
+                    384,
+                    372,
+                    457,
+                    378,
+                    342,
+                    617,
+                    478,
+                    536,
+                    201,
+                    394,
+                    282,
+                    262,
+                    71,
+                    207,
+                    562,
+                    91,
+                    550,
+                    165,
+                    31,
+                    274,
+                    575,
+                    478,
+                    437,
+                    511,
+                    297,
+                    737,
+                    262,
+                    753,
+                    670,
+                    240,
+                    553,
+                    672,
+                    391,
+                    281,
+                    559,
+                    385,
+                    303,
+                    109,
+                    110,
+                    261,
+                    252,
+                    738,
+                    236,
+                    97,
+                    368,
+                    564,
+                    73,
+                    290,
+                    308,
+                    296,
+                    250,
+                    409,
+                    708,
+                    744,
+                    698,
+                    714,
+                    161,
+                    712,
+                    46,
+                    229,
+                    677,
+                    529,
+                    202,
+                    456,
+                    80,
+                    2,
+                    612,
+                    147,
+                    221,
+                    634,
+                    319,
+                    487,
+                    556,
+                    78,
+                    344,
+                    215,
+                    80,
+                    150,
+                    594,
+                    691,
+                    268,
+                    565,
+                    499,
+                    311,
+                    109,
+                    276,
+                    240,
+                    87,
+                    642,
+                    341,
+                    0,
+                    663,
+                    0,
+                    132,
+                    432,
+                    430,
+                    21,
+                    502,
+                    31,
+                    625,
+                    84,
+                    273,
+                    137,
+                    752,
+                    261,
+                    657,
+                    469,
+                    253,
+                    255,
+                    53,
+                    28,
+                    520,
+                    79,
+                    386,
+                    314,
+                    93,
+                    129,
+                    51,
+                    126,
+                    672,
+                    365,
+                    55,
+                    400,
+                    90,
+                    201,
+                    381,
+                    628,
+                    249,
+                    237,
+                    179,
+                    671,
+                    59,
+                    235,
+                    502,
+                    198,
+                    204,
+                    502,
+                    199,
+                    592,
+                    568,
+                    45,
+                    586,
+                    37,
+                    697,
+                    179,
+                    640,
+                    513,
+                    517,
+                    310,
+                    213,
+                    85,
+                    500,
+                    148,
+                    438,
+                    128,
+                    350,
+                    242,
+                    381,
+                    657,
+                    299,
+                    451,
+                    509,
+                    494,
+                    380,
+                    161,
+                    26,
+                    690,
+                    347,
+                    7,
+                    510,
+                    94,
+                    696,
+                    46,
+                    43,
+                    177,
+                    345,
+                    625,
+                    678,
+                    31,
+                    588,
+                    668,
+                    744,
+                    253,
+                    552,
+                    281,
+                    390,
+                    151,
+                    168,
+                    722,
+                    529,
+                    187,
+                    123,
+                    613,
+                    593,
+                    2,
+                    429,
+                    517,
+                    7,
+                    612,
+                    273,
+                    280,
+                    367,
+                    625,
+                    218,
+                    711,
+                    143,
+                    196,
+                    38,
+                    132,
+                    222,
+                    714,
+                    4,
+                    76,
+                    97,
+                    554,
+                    112,
+                    262,
+                    657,
+                    350,
+                    278,
+                    702,
+                    282,
+                    717,
+                    426,
+                    320,
+                    218,
+                    87,
+                    743,
+                    100,
+                    125,
+                    463,
+                    370,
+                    127,
+                    571,
+                    699,
+                    214,
+                    703,
+                    201,
+                    480,
+                    115,
+                    81,
+                    104,
+                    293,
+                    244,
+                    90,
+                    653,
+                    342,
+                    727,
+                    200,
+                    644,
+                    678,
+                    151,
+                    331,
+                    357,
+                    511,
+                    496,
+                    736,
+                    94,
+                    499,
+                    587,
+                    13,
+                    631,
+                    571,
+                    683,
+                    9,
+                    105,
+                    706,
+                    640,
+                    617,
+                    267,
+                    348,
+                    501,
+                    33,
+                    0,
+                    577,
+                    245,
+                    669,
+                    369,
+                    518,
+                    206,
+                    34,
+                    511,
+                    232,
+                    448,
+                    283,
+                    733,
+                    478,
+                    676,
+                    586,
+                    664,
+                    515,
+                    162,
+                    509,
+                    641,
+                    9,
+                    58,
+                    442,
+                    650,
+                    713,
+                    11,
+                    249,
+                    466,
+                    54,
+                    298,
+                    137,
+                    206,
+                    415,
+                    15,
+                    199,
+                    71,
+                    336,
+                    602,
+                    410,
+                    295,
+                    621,
+                    168,
+                    262,
+                    314,
+                    656,
+                    217,
+                    696,
+                    116,
+                    394,
+                    504,
+                    59,
+                    209,
+                    409,
+                    424,
+                    713,
+                    601,
+                    101,
+                    32,
+                    602,
+                    569,
+                    585,
+                    219,
+                    141,
+                    455,
+                    269,
+                    574,
+                    506,
+                    258,
+                    437,
+                    358,
+                    294,
+                    703,
+                    626,
+                    330,
+                    467,
+                    627,
+                    417,
+                    702,
+                    13,
+                    495,
+                    56,
+                    665,
+                    454,
+                    253,
+                    203,
+                    387,
+                    524,
+                    375,
+                    656,
+                    4,
+                    436,
+                    557,
+                    584,
+                    435,
+                    236,
+                    452,
+                    448,
+                    537,
+                    713,
+                    352,
+                    656,
+                    728,
+                    632,
+                    518,
+                    680,
+                    464,
+                    489,
+                    205,
+                    307,
+                    360,
+                    30,
+                    384,
+                    1,
+                    87,
+                    743,
+                    714,
+                    337,
+                    114,
+                    303,
+                    30,
+                    526,
+                    354,
+                    80,
+                    13,
+                    658,
+                    412,
+                    220,
+                    668,
+                    709,
+                    558,
+                    192,
+                    549,
+                    518,
+                    169,
+                    327,
+                    180,
+                    634,
+                    547,
+                    180,
+                    717,
+                    85,
+                    401,
+                    121,
+                    299
+                ],
+                930884210
+            ],
+            "output": 930884693
+        },
+        {
+            "input": [
+                [
+                    59,
+                    51,
+                    83,
+                    114,
+                    94,
+                    60,
+                    119,
+                    97,
+                    2,
+                    96,
+                    80,
+                    13,
+                    76,
+                    59,
+                    137,
+                    89,
+                    29,
+                    108,
+                    133,
+                    100,
+                    66,
+                    110,
+                    42,
+                    131,
+                    110,
+                    53,
+                    5,
+                    139,
+                    130,
+                    143,
+                    27,
+                    30,
+                    105,
+                    77,
+                    80,
+                    125,
+                    32,
+                    66,
+                    105,
+                    112,
+                    41,
+                    127,
+                    75,
+                    15,
+                    26,
+                    90,
+                    89,
+                    83,
+                    5,
+                    45,
+                    24,
+                    56,
+                    36,
+                    109,
+                    98,
+                    25,
+                    61,
+                    101,
+                    120,
+                    115,
+                    12,
+                    76,
+                    121,
+                    26,
+                    25,
+                    131,
+                    110,
+                    35,
+                    21,
+                    22,
+                    44,
+                    97,
+                    25,
+                    120,
+                    104,
+                    101,
+                    82,
+                    36,
+                    70,
+                    84,
+                    43,
+                    41,
+                    22,
+                    53,
+                    19,
+                    47,
+                    95,
+                    53,
+                    123,
+                    9,
+                    114,
+                    119,
+                    91,
+                    122,
+                    80,
+                    80,
+                    60,
+                    99,
+                    142,
+                    145,
+                    123,
+                    124,
+                    137,
+                    124,
+                    61,
+                    30,
+                    59,
+                    133,
+                    59,
+                    29,
+                    39,
+                    127,
+                    22,
+                    2,
+                    107,
+                    31,
+                    76,
+                    3,
+                    64,
+                    106,
+                    83,
+                    38,
+                    28,
+                    32,
+                    124,
+                    78,
+                    37,
+                    40,
+                    110,
+                    99,
+                    65,
+                    21,
+                    93,
+                    121,
+                    50,
+                    16,
+                    32,
+                    23,
+                    12,
+                    131,
+                    40,
+                    60,
+                    34,
+                    36,
+                    129,
+                    67
+                ],
+                495868694
+            ],
+            "output": 495868784
+        },
+        {
+            "input": [
+                [
+                    203,
+                    1,
+                    252,
+                    243,
+                    29,
+                    258,
+                    14,
+                    190,
+                    83,
+                    215,
+                    8,
+                    77,
+                    215,
+                    131,
+                    168,
+                    72,
+                    4,
+                    251,
+                    147,
+                    150,
+                    79,
+                    244,
+                    125,
+                    182,
+                    141,
+                    104,
+                    147,
+                    202,
+                    62,
+                    105,
+                    95,
+                    204,
+                    16,
+                    183,
+                    165,
+                    145,
+                    208,
+                    88,
+                    90,
+                    95,
+                    11,
+                    83,
+                    228,
+                    124,
+                    136,
+                    10,
+                    49,
+                    132,
+                    100,
+                    34,
+                    75,
+                    89,
+                    111,
+                    258,
+                    95,
+                    12,
+                    12,
+                    220,
+                    59,
+                    126,
+                    26,
+                    226,
+                    110,
+                    145,
+                    251,
+                    125,
+                    53,
+                    60,
+                    9,
+                    197,
+                    224,
+                    243,
+                    260,
+                    68,
+                    117,
+                    84,
+                    162,
+                    227,
+                    130,
+                    118,
+                    245,
+                    204,
+                    139,
+                    247,
+                    195,
+                    218,
+                    194,
+                    17,
+                    144,
+                    262,
+                    152,
+                    51,
+                    254,
+                    16,
+                    204,
+                    99,
+                    32,
+                    156,
+                    67,
+                    47,
+                    47,
+                    10,
+                    216,
+                    252,
+                    34,
+                    207,
+                    202,
+                    206,
+                    44,
+                    230,
+                    37,
+                    170,
+                    50,
+                    7,
+                    130,
+                    59,
+                    241,
+                    159,
+                    68,
+                    210,
+                    148,
+                    163,
+                    245,
+                    260,
+                    159,
+                    152,
+                    51,
+                    11,
+                    21,
+                    263,
+                    155,
+                    150,
+                    189,
+                    223,
+                    142,
+                    140,
+                    131,
+                    205,
+                    74,
+                    66,
+                    138,
+                    0,
+                    172,
+                    96,
+                    140,
+                    118,
+                    89,
+                    222,
+                    218,
+                    22,
+                    174,
+                    43,
+                    80,
+                    169,
+                    88,
+                    206,
+                    92,
+                    180,
+                    252,
+                    202,
+                    65,
+                    86,
+                    130,
+                    69,
+                    122,
+                    116,
+                    214,
+                    116,
+                    225,
+                    118,
+                    188,
+                    223,
+                    122,
+                    118,
+                    113,
+                    224,
+                    98,
+                    193,
+                    39,
+                    254,
+                    80,
+                    161,
+                    204,
+                    93,
+                    182,
+                    206,
+                    84,
+                    234,
+                    177,
+                    47,
+                    74,
+                    54,
+                    182,
+                    57,
+                    146,
+                    64,
+                    137,
+                    14,
+                    161,
+                    214,
+                    194,
+                    93,
+                    106,
+                    171,
+                    260,
+                    51,
+                    114,
+                    202,
+                    219,
+                    122,
+                    149,
+                    208,
+                    161,
+                    219,
+                    36,
+                    3,
+                    215,
+                    66,
+                    114,
+                    26,
+                    177,
+                    244,
+                    65,
+                    55,
+                    211,
+                    56,
+                    50,
+                    28,
+                    169,
+                    31,
+                    39,
+                    36,
+                    192,
+                    260,
+                    148,
+                    172,
+                    221,
+                    200,
+                    84,
+                    6,
+                    246,
+                    11,
+                    75,
+                    144,
+                    38,
+                    14,
+                    49,
+                    236,
+                    90,
+                    9,
+                    74,
+                    158,
+                    236,
+                    111,
+                    159,
+                    250,
+                    204,
+                    250,
+                    94,
+                    65,
+                    230,
+                    81,
+                    41,
+                    39
+                ],
+                207184027
+            ],
+            "output": 207184195
+        },
+        {
+            "input": [
+                [
+                    340,
+                    77,
+                    284,
+                    344,
+                    349,
+                    100,
+                    397,
+                    234,
+                    284,
+                    331,
+                    29,
+                    59,
+                    416,
+                    87,
+                    354,
+                    250,
+                    125,
+                    176,
+                    345,
+                    286,
+                    188,
+                    118,
+                    380,
+                    324,
+                    308,
+                    383,
+                    118,
+                    210,
+                    145,
+                    35,
+                    141,
+                    233,
+                    196,
+                    298,
+                    153,
+                    221,
+                    208,
+                    18,
+                    75,
+                    142,
+                    403,
+                    104,
+                    252,
+                    248,
+                    413,
+                    12,
+                    200,
+                    167,
+                    346,
+                    57,
+                    19,
+                    392,
+                    7,
+                    279,
+                    278,
+                    331,
+                    285,
+                    129,
+                    295,
+                    300,
+                    19,
+                    418,
+                    338,
+                    370,
+                    7,
+                    56,
+                    271,
+                    116,
+                    321,
+                    165,
+                    45,
+                    413,
+                    21,
+                    60,
+                    161,
+                    271,
+                    204,
+                    288,
+                    372,
+                    67,
+                    366,
+                    278,
+                    224,
+                    205,
+                    144,
+                    103,
+                    241,
+                    27,
+                    182,
+                    406,
+                    325,
+                    238,
+                    49,
+                    292,
+                    385,
+                    57,
+                    297,
+                    364,
+                    135,
+                    173,
+                    345,
+                    318,
+                    58,
+                    29,
+                    416,
+                    248,
+                    291,
+                    333,
+                    274,
+                    68,
+                    104,
+                    89,
+                    250,
+                    173,
+                    32,
+                    323,
+                    190,
+                    209,
+                    104,
+                    81,
+                    250,
+                    207,
+                    149,
+                    60,
+                    170,
+                    303,
+                    73,
+                    215,
+                    345,
+                    390,
+                    255,
+                    233,
+                    331,
+                    274,
+                    12,
+                    172,
+                    235,
+                    105,
+                    349,
+                    294,
+                    163,
+                    353,
+                    36,
+                    227,
+                    239,
+                    9,
+                    375,
+                    118,
+                    40,
+                    231,
+                    41,
+                    406,
+                    211,
+                    79,
+                    122,
+                    105,
+                    341,
+                    160,
+                    403,
+                    162,
+                    253,
+                    60,
+                    339,
+                    22,
+                    137,
+                    173,
+                    161,
+                    21,
+                    95,
+                    179,
+                    160,
+                    62,
+                    337,
+                    396,
+                    410,
+                    325,
+                    387,
+                    237,
+                    290,
+                    31,
+                    258,
+                    303,
+                    397,
+                    239,
+                    351,
+                    37,
+                    218,
+                    60,
+                    201,
+                    60,
+                    125,
+                    330,
+                    175,
+                    70,
+                    195,
+                    297,
+                    385,
+                    333,
+                    326,
+                    157,
+                    236,
+                    176,
+                    242,
+                    222,
+                    181,
+                    262,
+                    113,
+                    404,
+                    75,
+                    156,
+                    131,
+                    406,
+                    273,
+                    48,
+                    134,
+                    6,
+                    240,
+                    299,
+                    307,
+                    52,
+                    151,
+                    33,
+                    277,
+                    344,
+                    2,
+                    114,
+                    185,
+                    266,
+                    39,
+                    26,
+                    351,
+                    77,
+                    9,
+                    388,
+                    7,
+                    183,
+                    77,
+                    390,
+                    126,
+                    145,
+                    16,
+                    195,
+                    47,
+                    116,
+                    34,
+                    96,
+                    211,
+                    376,
+                    159,
+                    222,
+                    13,
+                    242,
+                    174,
+                    376,
+                    154,
+                    255,
+                    2,
+                    288,
+                    195,
+                    355,
+                    47,
+                    190,
+                    161,
+                    3,
+                    198,
+                    330,
+                    217,
+                    46,
+                    403,
+                    362,
+                    8,
+                    77,
+                    389,
+                    344,
+                    208,
+                    293,
+                    299,
+                    191,
+                    12,
+                    183,
+                    406,
+                    356,
+                    311,
+                    33,
+                    223,
+                    378,
+                    153,
+                    271,
+                    302,
+                    131,
+                    209,
+                    99,
+                    205,
+                    163,
+                    59,
+                    84,
+                    288,
+                    402,
+                    118,
+                    286,
+                    362,
+                    216,
+                    418,
+                    344,
+                    253,
+                    111,
+                    184,
+                    128,
+                    149,
+                    191,
+                    184,
+                    47,
+                    14,
+                    176,
+                    202,
+                    331,
+                    97,
+                    11,
+                    307,
+                    324,
+                    120,
+                    219,
+                    200,
+                    103,
+                    207,
+                    215,
+                    388,
+                    10,
+                    391,
+                    142,
+                    254,
+                    383,
+                    28,
+                    213,
+                    212,
+                    63,
+                    395,
+                    96,
+                    285,
+                    182,
+                    239,
+                    196,
+                    338,
+                    259,
+                    208,
+                    407,
+                    169,
+                    107,
+                    224,
+                    39,
+                    282,
+                    22,
+                    123,
+                    181,
+                    248,
+                    384,
+                    184,
+                    63,
+                    369,
+                    138,
+                    152,
+                    180,
+                    304,
+                    418,
+                    388,
+                    418,
+                    108,
+                    73,
+                    175,
+                    114,
+                    409,
+                    175,
+                    83,
+                    364,
+                    8,
+                    39,
+                    127,
+                    391,
+                    217,
+                    282,
+                    364,
+                    73,
+                    231,
+                    105,
+                    55,
+                    303,
+                    107,
+                    387,
+                    207,
+                    127,
+                    37,
+                    344,
+                    94,
+                    269,
+                    157,
+                    252,
+                    151,
+                    318,
+                    203,
+                    153,
+                    254,
+                    123,
+                    349,
+                    235,
+                    164,
+                    329,
+                    268,
+                    355,
+                    61,
+                    233,
+                    247,
+                    86,
+                    39,
+                    125,
+                    371,
+                    415,
+                    143,
+                    350,
+                    402,
+                    59
+                ],
+                939948695
+            ],
+            "output": 939948968
+        },
+        {
+            "input": [
+                [
+                    176,
+                    100,
+                    95,
+                    166,
+                    175,
+                    33,
+                    180,
+                    239,
+                    7,
+                    174,
+                    192,
+                    52,
+                    235,
+                    155,
+                    27,
+                    144,
+                    202,
+                    245,
+                    198,
+                    39,
+                    44,
+                    221,
+                    134,
+                    191,
+                    226,
+                    83,
+                    42,
+                    246,
+                    137,
+                    23,
+                    188,
+                    89,
+                    185,
+                    147,
+                    16,
+                    53,
+                    12,
+                    71,
+                    187,
+                    48,
+                    202,
+                    135,
+                    125,
+                    18,
+                    122,
+                    69,
+                    214,
+                    203,
+                    162,
+                    245,
+                    155,
+                    142,
+                    92,
+                    98,
+                    69,
+                    101,
+                    31,
+                    141,
+                    57,
+                    196,
+                    20,
+                    228,
+                    67,
+                    44,
+                    9,
+                    51,
+                    8,
+                    136,
+                    161,
+                    219,
+                    215,
+                    229,
+                    115,
+                    24,
+                    204,
+                    49,
+                    227,
+                    184,
+                    231,
+                    148,
+                    79,
+                    91,
+                    176,
+                    2,
+                    59,
+                    224,
+                    79,
+                    236,
+                    4,
+                    191,
+                    208,
+                    129,
+                    137,
+                    100,
+                    219,
+                    117,
+                    187,
+                    213,
+                    203,
+                    119,
+                    147,
+                    149,
+                    20,
+                    71,
+                    46,
+                    6,
+                    121,
+                    71,
+                    205,
+                    178,
+                    172,
+                    208,
+                    220,
+                    101,
+                    103,
+                    168,
+                    18,
+                    79,
+                    155,
+                    68,
+                    208,
+                    4,
+                    171,
+                    41,
+                    17,
+                    157,
+                    68,
+                    145,
+                    213,
+                    222,
+                    6,
+                    1,
+                    85,
+                    173,
+                    31,
+                    190,
+                    68,
+                    131,
+                    99,
+                    191,
+                    64,
+                    178,
+                    78,
+                    168,
+                    23,
+                    29,
+                    157,
+                    187,
+                    57,
+                    157,
+                    182,
+                    31,
+                    190,
+                    196,
+                    140,
+                    50,
+                    114,
+                    74,
+                    204,
+                    38,
+                    147,
+                    86,
+                    124,
+                    220,
+                    98,
+                    74,
+                    66,
+                    135,
+                    23,
+                    134,
+                    120,
+                    104,
+                    90,
+                    103,
+                    152,
+                    140,
+                    26,
+                    98,
+                    221,
+                    234,
+                    82,
+                    27,
+                    100,
+                    23,
+                    196,
+                    231,
+                    160,
+                    126,
+                    112,
+                    84,
+                    17,
+                    229,
+                    26,
+                    20,
+                    126,
+                    166,
+                    53,
+                    81,
+                    186,
+                    177,
+                    132,
+                    14,
+                    72,
+                    154,
+                    72,
+                    19,
+                    137,
+                    48,
+                    6,
+                    112,
+                    190,
+                    21,
+                    155,
+                    182,
+                    127,
+                    188,
+                    107,
+                    216,
+                    41,
+                    21,
+                    100,
+                    35,
+                    144,
+                    51,
+                    119,
+                    161,
+                    218,
+                    191,
+                    95,
+                    203,
+                    34,
+                    79,
+                    32,
+                    175,
+                    171,
+                    193,
+                    114,
+                    99,
+                    97,
+                    209,
+                    123,
+                    109,
+                    236,
+                    87,
+                    181,
+                    133,
+                    230,
+                    229,
+                    107
+                ],
+                268850864
+            ],
+            "output": 268851021
+        },
+        {
+            "input": [
+                [
+                    114,
+                    121,
+                    14,
+                    24,
+                    40,
+                    6,
+                    46,
+                    83,
+                    42,
+                    118,
+                    107,
+                    72,
+                    101,
+                    48,
+                    48,
+                    31,
+                    50,
+                    47,
+                    93,
+                    66,
+                    86,
+                    62,
+                    119,
+                    13,
+                    25,
+                    94,
+                    8,
+                    101,
+                    15,
+                    69,
+                    95,
+                    96,
+                    103,
+                    126,
+                    27,
+                    16,
+                    30,
+                    60,
+                    5,
+                    69,
+                    53,
+                    123,
+                    114,
+                    45,
+                    92,
+                    8,
+                    4,
+                    38,
+                    63,
+                    98,
+                    96,
+                    48,
+                    69,
+                    100,
+                    34,
+                    17,
+                    8,
+                    61,
+                    17,
+                    62,
+                    17,
+                    19,
+                    3,
+                    48,
+                    61,
+                    28,
+                    99,
+                    32,
+                    42,
+                    73,
+                    60,
+                    48,
+                    104,
+                    70,
+                    124,
+                    62,
+                    7,
+                    73,
+                    68,
+                    16,
+                    88,
+                    54,
+                    113,
+                    79,
+                    74,
+                    100,
+                    88,
+                    54,
+                    5,
+                    112,
+                    14,
+                    47,
+                    103,
+                    103,
+                    3,
+                    2,
+                    108,
+                    60,
+                    59,
+                    126,
+                    4,
+                    24,
+                    41,
+                    75,
+                    66,
+                    58,
+                    52,
+                    74,
+                    78,
+                    81,
+                    8,
+                    120,
+                    6,
+                    46,
+                    90,
+                    12,
+                    84,
+                    70,
+                    108,
+                    1,
+                    123,
+                    121,
+                    26,
+                    34,
+                    124,
+                    79,
+                    87
+                ],
+                334897499
+            ],
+            "output": 334897579
+        },
+        {
+            "input": [
+                [
+                    214,
+                    24,
+                    8,
+                    165,
+                    469,
+                    295,
+                    238,
+                    174,
+                    305,
+                    327,
+                    377,
+                    77,
+                    320,
+                    309,
+                    441,
+                    180,
+                    425,
+                    222,
+                    379,
+                    489,
+                    137,
+                    397,
+                    90,
+                    373,
+                    398,
+                    16,
+                    285,
+                    440,
+                    262,
+                    45,
+                    469,
+                    367,
+                    102,
+                    397,
+                    200,
+                    199,
+                    304,
+                    239,
+                    458,
+                    17,
+                    155,
+                    207,
+                    154,
+                    435,
+                    300,
+                    169,
+                    0,
+                    220,
+                    288,
+                    1,
+                    439,
+                    424,
+                    252,
+                    216,
+                    345,
+                    387,
+                    30,
+                    315,
+                    368,
+                    484,
+                    258,
+                    492,
+                    435,
+                    282,
+                    45,
+                    488,
+                    447,
+                    464,
+                    202,
+                    47,
+                    39,
+                    122,
+                    132,
+                    210,
+                    286,
+                    161,
+                    75,
+                    310,
+                    341,
+                    275,
+                    376,
+                    326,
+                    37,
+                    436,
+                    42,
+                    137,
+                    86,
+                    32,
+                    99,
+                    471,
+                    409,
+                    461,
+                    459,
+                    488,
+                    243,
+                    209,
+                    456,
+                    225,
+                    188,
+                    295,
+                    16,
+                    102,
+                    333,
+                    275,
+                    7,
+                    290,
+                    58,
+                    254,
+                    372,
+                    467,
+                    221,
+                    473,
+                    118,
+                    61,
+                    173,
+                    338,
+                    177,
+                    306,
+                    170,
+                    199,
+                    157,
+                    210,
+                    456,
+                    308,
+                    27,
+                    26,
+                    249,
+                    284,
+                    159,
+                    317,
+                    432,
+                    10,
+                    18,
+                    284,
+                    60,
+                    232,
+                    266,
+                    333,
+                    412,
+                    108,
+                    143,
+                    311,
+                    310,
+                    223,
+                    201,
+                    132,
+                    339,
+                    100,
+                    149,
+                    158,
+                    333,
+                    235,
+                    336,
+                    317,
+                    69,
+                    30,
+                    457,
+                    137,
+                    333,
+                    420,
+                    370,
+                    417,
+                    340,
+                    83,
+                    112,
+                    450,
+                    246,
+                    382,
+                    262,
+                    237,
+                    148,
+                    447,
+                    180,
+                    201,
+                    86,
+                    46,
+                    307,
+                    115,
+                    193,
+                    383,
+                    424,
+                    84,
+                    414,
+                    392,
+                    355,
+                    367,
+                    271,
+                    322,
+                    14,
+                    22,
+                    151,
+                    251,
+                    188,
+                    121,
+                    356,
+                    18,
+                    344,
+                    35,
+                    230,
+                    397,
+                    108,
+                    252,
+                    226,
+                    63,
+                    269,
+                    333,
+                    83,
+                    158,
+                    1,
+                    27,
+                    400,
+                    325,
+                    224,
+                    449,
+                    125,
+                    331,
+                    49,
+                    373,
+                    13,
+                    482,
+                    194,
+                    470,
+                    260,
+                    223,
+                    109,
+                    282,
+                    472,
+                    426,
+                    169,
+                    130,
+                    479,
+                    407,
+                    477,
+                    241,
+                    342,
+                    390,
+                    134,
+                    339,
+                    107,
+                    334,
+                    327,
+                    75,
+                    109,
+                    184,
+                    216,
+                    192,
+                    147,
+                    441,
+                    158,
+                    173,
+                    307,
+                    255,
+                    115,
+                    316,
+                    51,
+                    253,
+                    58,
+                    71,
+                    354,
+                    450,
+                    146,
+                    354,
+                    223,
+                    252,
+                    119,
+                    272,
+                    418,
+                    323,
+                    483,
+                    272,
+                    291,
+                    8,
+                    437,
+                    16,
+                    481,
+                    412,
+                    208,
+                    365,
+                    237,
+                    435,
+                    363,
+                    424,
+                    420,
+                    259,
+                    132,
+                    364,
+                    164,
+                    424,
+                    347,
+                    450,
+                    13,
+                    98,
+                    396,
+                    7,
+                    194,
+                    180,
+                    143,
+                    218,
+                    31,
+                    168,
+                    344,
+                    210,
+                    38,
+                    184,
+                    353,
+                    399,
+                    366,
+                    410,
+                    210,
+                    430,
+                    86,
+                    244,
+                    408,
+                    52,
+                    82,
+                    415,
+                    162,
+                    421,
+                    108,
+                    261,
+                    38,
+                    467,
+                    323,
+                    78,
+                    96,
+                    141,
+                    159,
+                    237,
+                    106,
+                    488,
+                    250,
+                    204,
+                    242,
+                    394,
+                    309,
+                    264,
+                    267,
+                    148,
+                    285,
+                    183,
+                    467,
+                    204,
+                    449,
+                    368,
+                    435,
+                    138,
+                    222,
+                    477,
+                    289,
+                    403,
+                    79,
+                    163,
+                    453,
+                    283,
+                    301,
+                    112,
+                    294,
+                    476,
+                    197,
+                    149,
+                    210,
+                    411,
+                    365,
+                    2,
+                    152,
+                    15,
+                    251,
+                    460,
+                    328,
+                    202,
+                    254,
+                    168,
+                    474,
+                    221,
+                    280,
+                    42,
+                    106,
+                    207,
+                    82,
+                    167,
+                    118,
+                    146,
+                    91,
+                    223,
+                    207,
+                    114,
+                    62,
+                    428,
+                    466,
+                    214,
+                    250,
+                    138,
+                    301,
+                    206,
+                    250,
+                    7,
+                    385,
+                    170,
+                    399,
+                    47,
+                    193,
+                    165,
+                    5,
+                    45,
+                    193,
+                    90,
+                    218,
+                    300,
+                    21,
+                    339,
+                    191,
+                    251,
+                    428,
+                    148,
+                    164,
+                    4,
+                    350,
+                    176,
+                    153,
+                    151,
+                    455,
+                    449,
+                    96,
+                    350,
+                    372,
+                    209,
+                    302,
+                    271,
+                    125,
+                    24,
+                    92,
+                    35,
+                    486,
+                    90,
+                    237,
+                    179,
+                    351,
+                    454,
+                    306,
+                    404,
+                    310,
+                    322,
+                    415,
+                    327,
+                    462,
+                    344,
+                    491,
+                    71,
+                    51,
+                    155,
+                    249,
+                    378,
+                    25,
+                    47,
+                    293,
+                    92,
+                    459,
+                    125,
+                    169,
+                    145,
+                    434,
+                    161,
+                    165,
+                    74,
+                    21,
+                    201,
+                    113,
+                    160,
+                    259,
+                    196,
+                    418,
+                    153,
+                    89,
+                    394,
+                    217,
+                    412,
+                    487,
+                    447,
+                    261,
+                    486,
+                    383,
+                    77,
+                    187,
+                    310,
+                    474,
+                    50,
+                    112,
+                    387,
+                    259,
+                    26,
+                    116,
+                    222,
+                    373
+                ],
+                247598608
+            ],
+            "output": 247598923
+        },
+        {
+            "input": [
+                [
+                    14,
+                    4,
+                    8,
+                    3,
+                    8,
+                    8,
+                    10,
+                    16,
+                    14,
+                    4,
+                    3,
+                    16,
+                    1,
+                    2,
+                    15,
+                    14,
+                    10,
+                    7,
+                    5,
+                    14
+                ],
+                350801952
+            ],
+            "output": 350801967
+        }
+    ],
+    "haskell_template": "minCost :: [Int] -> Int -> Int\nminCost nums k ",
+    "ocaml_template": "let minCost (nums: int list) (k: int) : int =  ",
+    "scala_template": "def minCost(nums: List[Int],k: Int): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public int minCost(int[] nums, int k) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def minCost(self, nums, k):\n        \"\"\"\n        :type nums: List[int]\n        :type k: int\n        :rtype: int\n        \"\"\"\n        "
+}