3c84d0a839e6f58af193dbfafea5976ec5d5c2435f97ab08e3aa3eb4d3ff0398

.gitattributes

@@ -211,3 +211,5 @@ mice_and_cheese/meta.json filter=lfs diff=lfs merge=lfs -text
 minimize_maximum_of_array/meta.json filter=lfs diff=lfs merge=lfs -text
 minimize_or_of_remaining_elements_using_operations/meta.json filter=lfs diff=lfs merge=lfs -text
 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

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

minimize_the_total_price_of_the_trips/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(23, minimumTotalPrice(4, new ArrayList<>(Arrays.asList(new ArrayList<>(Arrays.asList(0,1)),new ArrayList<>(Arrays.asList(1,2)),new ArrayList<>(Arrays.asList(1,3)))), new ArrayList<>(Arrays.asList(2,2,10,6)), new ArrayList<>(Arrays.asList(new ArrayList<>(Arrays.asList(0,3)),new ArrayList<>(Arrays.asList(2,1)),new ArrayList<>(Arrays.asList(2,3))))));
+}
+@Test
+public void test2() {
+    assertEquals(1, minimumTotalPrice(2, new ArrayList<>(Arrays.asList(new ArrayList<>(Arrays.asList(0,1)))), new ArrayList<>(Arrays.asList(2,2)), new ArrayList<>(Arrays.asList(new ArrayList<>(Arrays.asList(0,0))))));
+}
+
+}

minimize_the_total_price_of_the_trips/meta.json

@@ -0,0 +1,3531 @@
+{
+    "id": 2739,
+    "name": "minimize_the_total_price_of_the_trips",
+    "difficulty": "Hard",
+    "link": "https://leetcode.com/problems/minimize-the-total-price-of-the-trips/",
+    "date": "1680998400000",
+    "task_description": "There exists an undirected and unrooted tree with `n` nodes indexed from `0` to `n - 1`. You are given the integer `n` and a 2D integer array `edges` of length `n - 1`, where `edges[i] = [ai, bi]` indicates that there is an edge between nodes `ai` and `bi` in the tree. Each node has an associated price. You are given an integer array `price`, where `price[i]` is the price of the `ith` node. The **price sum** of a given path is the sum of the prices of all nodes lying on that path. Additionally, you are given a 2D integer array `trips`, where `trips[i] = [starti, endi]` indicates that you start the `ith` trip from the node `starti` and travel to the node `endi` by any path you like. Before performing your first trip, you can choose some **non-adjacent** nodes and halve the prices. Return _the minimum total price sum to perform all the given trips_. **Example 1:** ``` **Input:** n = 4, edges = [[0,1],[1,2],[1,3]], price = [2,2,10,6], trips = [[0,3],[2,1],[2,3]] **Output:** 23 **Explanation:** The diagram above denotes the tree after rooting it at node 2. The first part shows the initial tree and the second part shows the tree after choosing nodes 0, 2, and 3, and making their price half. For the 1st trip, we choose path [0,1,3]. The price sum of that path is 1 + 2 + 3 = 6. For the 2nd trip, we choose path [2,1]. The price sum of that path is 2 + 5 = 7. For the 3rd trip, we choose path [2,1,3]. The price sum of that path is 5 + 2 + 3 = 10. The total price sum of all trips is 6 + 7 + 10 = 23. It can be proven, that 23 is the minimum answer that we can achieve. ``` **Example 2:** ``` **Input:** n = 2, edges = [[0,1]], price = [2,2], trips = [[0,0]] **Output:** 1 **Explanation:** The diagram above denotes the tree after rooting it at node 0. The first part shows the initial tree and the second part shows the tree after choosing node 0, and making its price half. For the 1st trip, we choose path [0]. The price sum of that path is 1. The total price sum of all trips is 1. It can be proven, that 1 is the minimum answer that we can achieve. ``` **Constraints:** `1 <= n <= 50` `edges.length == n - 1` `0 <= ai, bi <= n - 1` `edges` represents a valid tree. `price.length == n` `price[i]` is an even integer. `1 <= price[i] <= 1000` `1 <= trips.length <= 100` `0 <= starti, endi <= n - 1`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "n = 4, edges = [[0,1],[1,2],[1,3]], price = [2,2,10,6], trips = [[0,3],[2,1],[2,3]]",
+            "output": "23 "
+        },
+        {
+            "label": "Example 2",
+            "input": "n = 2, edges = [[0,1]], price = [2,2], trips = [[0,0]]",
+            "output": "1 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                40,
+                [
+                    [
+                        23,
+                        31
+                    ],
+                    [
+                        36,
+                        23
+                    ],
+                    [
+                        35,
+                        36
+                    ],
+                    [
+                        1,
+                        23
+                    ],
+                    [
+                        30,
+                        36
+                    ],
+                    [
+                        16,
+                        31
+                    ],
+                    [
+                        27,
+                        31
+                    ],
+                    [
+                        18,
+                        31
+                    ],
+                    [
+                        10,
+                        23
+                    ],
+                    [
+                        0,
+                        16
+                    ],
+                    [
+                        38,
+                        1
+                    ],
+                    [
+                        14,
+                        23
+                    ],
+                    [
+                        29,
+                        31
+                    ],
+                    [
+                        37,
+                        30
+                    ],
+                    [
+                        6,
+                        38
+                    ],
+                    [
+                        25,
+                        0
+                    ],
+                    [
+                        19,
+                        25
+                    ],
+                    [
+                        24,
+                        37
+                    ],
+                    [
+                        12,
+                        1
+                    ],
+                    [
+                        17,
+                        19
+                    ],
+                    [
+                        2,
+                        14
+                    ],
+                    [
+                        22,
+                        37
+                    ],
+                    [
+                        39,
+                        38
+                    ],
+                    [
+                        9,
+                        30
+                    ],
+                    [
+                        3,
+                        24
+                    ],
+                    [
+                        7,
+                        12
+                    ],
+                    [
+                        5,
+                        14
+                    ],
+                    [
+                        34,
+                        14
+                    ],
+                    [
+                        32,
+                        19
+                    ],
+                    [
+                        4,
+                        12
+                    ],
+                    [
+                        11,
+                        10
+                    ],
+                    [
+                        8,
+                        5
+                    ],
+                    [
+                        33,
+                        10
+                    ],
+                    [
+                        20,
+                        8
+                    ],
+                    [
+                        26,
+                        4
+                    ],
+                    [
+                        28,
+                        7
+                    ],
+                    [
+                        15,
+                        36
+                    ],
+                    [
+                        13,
+                        18
+                    ],
+                    [
+                        21,
+                        30
+                    ]
+                ],
+                [
+                    872,
+                    326,
+                    44,
+                    806,
+                    968,
+                    62,
+                    400,
+                    948,
+                    78,
+                    674,
+                    110,
+                    868,
+                    200,
+                    598,
+                    388,
+                    902,
+                    488,
+                    832,
+                    48,
+                    218,
+                    204,
+                    308,
+                    34,
+                    80,
+                    408,
+                    450,
+                    346,
+                    368,
+                    638,
+                    238,
+                    724,
+                    408,
+                    700,
+                    502,
+                    462,
+                    758,
+                    344,
+                    954,
+                    270,
+                    362
+                ],
+                [
+                    [
+                        11,
+                        19
+                    ],
+                    [
+                        15,
+                        23
+                    ],
+                    [
+                        19,
+                        24
+                    ],
+                    [
+                        11,
+                        34
+                    ],
+                    [
+                        6,
+                        36
+                    ],
+                    [
+                        10,
+                        10
+                    ],
+                    [
+                        22,
+                        5
+                    ],
+                    [
+                        3,
+                        26
+                    ],
+                    [
+                        37,
+                        8
+                    ],
+                    [
+                        6,
+                        15
+                    ],
+                    [
+                        34,
+                        38
+                    ],
+                    [
+                        18,
+                        14
+                    ],
+                    [
+                        23,
+                        12
+                    ],
+                    [
+                        33,
+                        15
+                    ],
+                    [
+                        14,
+                        32
+                    ],
+                    [
+                        30,
+                        38
+                    ],
+                    [
+                        20,
+                        2
+                    ],
+                    [
+                        10,
+                        29
+                    ],
+                    [
+                        30,
+                        15
+                    ],
+                    [
+                        28,
+                        15
+                    ],
+                    [
+                        9,
+                        16
+                    ],
+                    [
+                        0,
+                        34
+                    ],
+                    [
+                        32,
+                        33
+                    ],
+                    [
+                        11,
+                        36
+                    ],
+                    [
+                        1,
+                        3
+                    ],
+                    [
+                        14,
+                        15
+                    ],
+                    [
+                        1,
+                        38
+                    ],
+                    [
+                        12,
+                        27
+                    ],
+                    [
+                        30,
+                        37
+                    ],
+                    [
+                        27,
+                        6
+                    ],
+                    [
+                        36,
+                        13
+                    ],
+                    [
+                        32,
+                        6
+                    ],
+                    [
+                        13,
+                        2
+                    ],
+                    [
+                        6,
+                        1
+                    ],
+                    [
+                        17,
+                        12
+                    ],
+                    [
+                        37,
+                        11
+                    ],
+                    [
+                        30,
+                        31
+                    ],
+                    [
+                        24,
+                        32
+                    ],
+                    [
+                        0,
+                        5
+                    ],
+                    [
+                        15,
+                        14
+                    ],
+                    [
+                        4,
+                        34
+                    ],
+                    [
+                        16,
+                        34
+                    ],
+                    [
+                        29,
+                        7
+                    ],
+                    [
+                        26,
+                        13
+                    ],
+                    [
+                        23,
+                        23
+                    ],
+                    [
+                        8,
+                        38
+                    ],
+                    [
+                        7,
+                        14
+                    ],
+                    [
+                        37,
+                        19
+                    ],
+                    [
+                        19,
+                        17
+                    ],
+                    [
+                        13,
+                        18
+                    ],
+                    [
+                        38,
+                        26
+                    ],
+                    [
+                        24,
+                        36
+                    ],
+                    [
+                        10,
+                        6
+                    ],
+                    [
+                        2,
+                        37
+                    ],
+                    [
+                        24,
+                        24
+                    ],
+                    [
+                        25,
+                        2
+                    ],
+                    [
+                        17,
+                        12
+                    ],
+                    [
+                        4,
+                        11
+                    ],
+                    [
+                        38,
+                        36
+                    ],
+                    [
+                        21,
+                        19
+                    ],
+                    [
+                        0,
+                        5
+                    ],
+                    [
+                        2,
+                        32
+                    ],
+                    [
+                        2,
+                        23
+                    ],
+                    [
+                        26,
+                        22
+                    ],
+                    [
+                        34,
+                        14
+                    ],
+                    [
+                        34,
+                        5
+                    ],
+                    [
+                        37,
+                        12
+                    ],
+                    [
+                        10,
+                        12
+                    ],
+                    [
+                        25,
+                        21
+                    ],
+                    [
+                        25,
+                        22
+                    ],
+                    [
+                        37,
+                        23
+                    ],
+                    [
+                        21,
+                        11
+                    ],
+                    [
+                        8,
+                        37
+                    ],
+                    [
+                        31,
+                        26
+                    ],
+                    [
+                        33,
+                        8
+                    ],
+                    [
+                        38,
+                        25
+                    ]
+                ]
+            ],
+            "output": 117944
+        },
+        {
+            "input": [
+                36,
+                [
+                    [
+                        20,
+                        2
+                    ],
+                    [
+                        17,
+                        20
+                    ],
+                    [
+                        5,
+                        20
+                    ],
+                    [
+                        12,
+                        5
+                    ],
+                    [
+                        7,
+                        2
+                    ],
+                    [
+                        14,
+                        12
+                    ],
+                    [
+                        6,
+                        17
+                    ],
+                    [
+                        22,
+                        20
+                    ],
+                    [
+                        21,
+                        22
+                    ],
+                    [
+                        1,
+                        6
+                    ],
+                    [
+                        8,
+                        5
+                    ],
+                    [
+                        3,
+                        7
+                    ],
+                    [
+                        29,
+                        8
+                    ],
+                    [
+                        13,
+                        2
+                    ],
+                    [
+                        18,
+                        12
+                    ],
+                    [
+                        25,
+                        12
+                    ],
+                    [
+                        30,
+                        25
+                    ],
+                    [
+                        27,
+                        6
+                    ],
+                    [
+                        15,
+                        12
+                    ],
+                    [
+                        31,
+                        14
+                    ],
+                    [
+                        0,
+                        12
+                    ],
+                    [
+                        35,
+                        0
+                    ],
+                    [
+                        16,
+                        22
+                    ],
+                    [
+                        24,
+                        22
+                    ],
+                    [
+                        34,
+                        31
+                    ],
+                    [
+                        19,
+                        1
+                    ],
+                    [
+                        28,
+                        27
+                    ],
+                    [
+                        33,
+                        20
+                    ],
+                    [
+                        26,
+                        30
+                    ],
+                    [
+                        9,
+                        17
+                    ],
+                    [
+                        23,
+                        8
+                    ],
+                    [
+                        32,
+                        35
+                    ],
+                    [
+                        11,
+                        8
+                    ],
+                    [
+                        10,
+                        15
+                    ],
+                    [
+                        4,
+                        23
+                    ]
+                ],
+                [
+                    268,
+                    776,
+                    556,
+                    320,
+                    646,
+                    260,
+                    302,
+                    824,
+                    186,
+                    72,
+                    130,
+                    110,
+                    462,
+                    152,
+                    706,
+                    790,
+                    662,
+                    810,
+                    492,
+                    374,
+                    150,
+                    798,
+                    700,
+                    60,
+                    290,
+                    742,
+                    936,
+                    870,
+                    148,
+                    1000,
+                    304,
+                    538,
+                    968,
+                    868,
+                    60,
+                    534
+                ],
+                [
+                    [
+                        29,
+                        0
+                    ],
+                    [
+                        3,
+                        25
+                    ],
+                    [
+                        22,
+                        22
+                    ],
+                    [
+                        12,
+                        27
+                    ],
+                    [
+                        7,
+                        26
+                    ],
+                    [
+                        31,
+                        30
+                    ],
+                    [
+                        18,
+                        8
+                    ],
+                    [
+                        14,
+                        3
+                    ],
+                    [
+                        4,
+                        21
+                    ],
+                    [
+                        30,
+                        31
+                    ],
+                    [
+                        3,
+                        4
+                    ],
+                    [
+                        30,
+                        28
+                    ],
+                    [
+                        0,
+                        15
+                    ],
+                    [
+                        11,
+                        7
+                    ],
+                    [
+                        15,
+                        31
+                    ],
+                    [
+                        22,
+                        19
+                    ],
+                    [
+                        9,
+                        26
+                    ],
+                    [
+                        0,
+                        16
+                    ],
+                    [
+                        15,
+                        16
+                    ],
+                    [
+                        8,
+                        25
+                    ],
+                    [
+                        28,
+                        25
+                    ],
+                    [
+                        17,
+                        28
+                    ],
+                    [
+                        32,
+                        12
+                    ],
+                    [
+                        15,
+                        35
+                    ],
+                    [
+                        2,
+                        21
+                    ],
+                    [
+                        0,
+                        3
+                    ],
+                    [
+                        34,
+                        18
+                    ],
+                    [
+                        32,
+                        22
+                    ],
+                    [
+                        34,
+                        34
+                    ],
+                    [
+                        28,
+                        33
+                    ],
+                    [
+                        0,
+                        33
+                    ]
+                ]
+            ],
+            "output": 54772
+        },
+        {
+            "input": [
+                21,
+                [
+                    [
+                        16,
+                        10
+                    ],
+                    [
+                        20,
+                        16
+                    ],
+                    [
+                        4,
+                        20
+                    ],
+                    [
+                        15,
+                        10
+                    ],
+                    [
+                        12,
+                        4
+                    ],
+                    [
+                        0,
+                        16
+                    ],
+                    [
+                        11,
+                        16
+                    ],
+                    [
+                        3,
+                        15
+                    ],
+                    [
+                        8,
+                        4
+                    ],
+                    [
+                        7,
+                        10
+                    ],
+                    [
+                        6,
+                        10
+                    ],
+                    [
+                        2,
+                        8
+                    ],
+                    [
+                        1,
+                        12
+                    ],
+                    [
+                        13,
+                        0
+                    ],
+                    [
+                        9,
+                        0
+                    ],
+                    [
+                        19,
+                        20
+                    ],
+                    [
+                        18,
+                        11
+                    ],
+                    [
+                        17,
+                        16
+                    ],
+                    [
+                        5,
+                        1
+                    ],
+                    [
+                        14,
+                        19
+                    ]
+                ],
+                [
+                    254,
+                    76,
+                    994,
+                    424,
+                    776,
+                    250,
+                    318,
+                    366,
+                    252,
+                    432,
+                    118,
+                    988,
+                    922,
+                    290,
+                    420,
+                    608,
+                    476,
+                    458,
+                    90,
+                    260,
+                    630
+                ],
+                [
+                    [
+                        1,
+                        15
+                    ],
+                    [
+                        18,
+                        8
+                    ],
+                    [
+                        20,
+                        11
+                    ],
+                    [
+                        8,
+                        18
+                    ],
+                    [
+                        18,
+                        4
+                    ],
+                    [
+                        7,
+                        20
+                    ],
+                    [
+                        11,
+                        8
+                    ],
+                    [
+                        15,
+                        9
+                    ],
+                    [
+                        10,
+                        5
+                    ],
+                    [
+                        16,
+                        16
+                    ],
+                    [
+                        16,
+                        17
+                    ],
+                    [
+                        9,
+                        5
+                    ],
+                    [
+                        10,
+                        11
+                    ],
+                    [
+                        13,
+                        16
+                    ],
+                    [
+                        8,
+                        5
+                    ],
+                    [
+                        7,
+                        5
+                    ],
+                    [
+                        20,
+                        12
+                    ],
+                    [
+                        7,
+                        7
+                    ],
+                    [
+                        16,
+                        12
+                    ],
+                    [
+                        12,
+                        3
+                    ],
+                    [
+                        2,
+                        9
+                    ],
+                    [
+                        4,
+                        5
+                    ],
+                    [
+                        7,
+                        2
+                    ]
+                ]
+            ],
+            "output": 41429
+        },
+        {
+            "input": [
+                36,
+                [
+                    [
+                        5,
+                        15
+                    ],
+                    [
+                        6,
+                        15
+                    ],
+                    [
+                        12,
+                        5
+                    ],
+                    [
+                        9,
+                        5
+                    ],
+                    [
+                        1,
+                        6
+                    ],
+                    [
+                        0,
+                        5
+                    ],
+                    [
+                        21,
+                        0
+                    ],
+                    [
+                        13,
+                        9
+                    ],
+                    [
+                        2,
+                        21
+                    ],
+                    [
+                        29,
+                        6
+                    ],
+                    [
+                        27,
+                        6
+                    ],
+                    [
+                        23,
+                        1
+                    ],
+                    [
+                        17,
+                        15
+                    ],
+                    [
+                        16,
+                        1
+                    ],
+                    [
+                        34,
+                        0
+                    ],
+                    [
+                        31,
+                        34
+                    ],
+                    [
+                        7,
+                        1
+                    ],
+                    [
+                        33,
+                        17
+                    ],
+                    [
+                        26,
+                        27
+                    ],
+                    [
+                        11,
+                        0
+                    ],
+                    [
+                        19,
+                        16
+                    ],
+                    [
+                        18,
+                        15
+                    ],
+                    [
+                        22,
+                        7
+                    ],
+                    [
+                        4,
+                        2
+                    ],
+                    [
+                        35,
+                        16
+                    ],
+                    [
+                        3,
+                        7
+                    ],
+                    [
+                        24,
+                        21
+                    ],
+                    [
+                        25,
+                        19
+                    ],
+                    [
+                        28,
+                        17
+                    ],
+                    [
+                        20,
+                        13
+                    ],
+                    [
+                        10,
+                        9
+                    ],
+                    [
+                        32,
+                        0
+                    ],
+                    [
+                        30,
+                        35
+                    ],
+                    [
+                        14,
+                        9
+                    ],
+                    [
+                        8,
+                        6
+                    ]
+                ],
+                [
+                    14,
+                    362,
+                    824,
+                    814,
+                    798,
+                    286,
+                    506,
+                    350,
+                    228,
+                    126,
+                    298,
+                    290,
+                    938,
+                    132,
+                    114,
+                    298,
+                    790,
+                    520,
+                    140,
+                    136,
+                    640,
+                    366,
+                    220,
+                    804,
+                    616,
+                    622,
+                    986,
+                    274,
+                    114,
+                    300,
+                    820,
+                    406,
+                    650,
+                    550,
+                    162,
+                    508
+                ],
+                [
+                    [
+                        22,
+                        29
+                    ],
+                    [
+                        3,
+                        29
+                    ],
+                    [
+                        19,
+                        17
+                    ],
+                    [
+                        15,
+                        16
+                    ],
+                    [
+                        8,
+                        22
+                    ],
+                    [
+                        2,
+                        16
+                    ],
+                    [
+                        8,
+                        3
+                    ],
+                    [
+                        0,
+                        11
+                    ],
+                    [
+                        1,
+                        10
+                    ],
+                    [
+                        11,
+                        21
+                    ],
+                    [
+                        11,
+                        33
+                    ],
+                    [
+                        6,
+                        10
+                    ],
+                    [
+                        10,
+                        34
+                    ],
+                    [
+                        9,
+                        20
+                    ],
+                    [
+                        1,
+                        26
+                    ],
+                    [
+                        6,
+                        8
+                    ],
+                    [
+                        3,
+                        6
+                    ],
+                    [
+                        1,
+                        32
+                    ],
+                    [
+                        9,
+                        12
+                    ],
+                    [
+                        29,
+                        15
+                    ],
+                    [
+                        19,
+                        6
+                    ],
+                    [
+                        26,
+                        32
+                    ],
+                    [
+                        24,
+                        0
+                    ],
+                    [
+                        28,
+                        20
+                    ],
+                    [
+                        11,
+                        9
+                    ],
+                    [
+                        13,
+                        13
+                    ],
+                    [
+                        6,
+                        28
+                    ],
+                    [
+                        16,
+                        7
+                    ],
+                    [
+                        18,
+                        30
+                    ],
+                    [
+                        7,
+                        9
+                    ],
+                    [
+                        0,
+                        10
+                    ],
+                    [
+                        5,
+                        2
+                    ],
+                    [
+                        13,
+                        23
+                    ],
+                    [
+                        7,
+                        21
+                    ],
+                    [
+                        0,
+                        0
+                    ],
+                    [
+                        19,
+                        2
+                    ],
+                    [
+                        0,
+                        4
+                    ],
+                    [
+                        34,
+                        19
+                    ],
+                    [
+                        26,
+                        25
+                    ]
+                ]
+            ],
+            "output": 47583
+        },
+        {
+            "input": [
+                48,
+                [
+                    [
+                        43,
+                        16
+                    ],
+                    [
+                        30,
+                        16
+                    ],
+                    [
+                        35,
+                        43
+                    ],
+                    [
+                        14,
+                        16
+                    ],
+                    [
+                        29,
+                        14
+                    ],
+                    [
+                        13,
+                        43
+                    ],
+                    [
+                        37,
+                        29
+                    ],
+                    [
+                        40,
+                        14
+                    ],
+                    [
+                        36,
+                        13
+                    ],
+                    [
+                        15,
+                        13
+                    ],
+                    [
+                        32,
+                        35
+                    ],
+                    [
+                        12,
+                        15
+                    ],
+                    [
+                        18,
+                        35
+                    ],
+                    [
+                        23,
+                        14
+                    ],
+                    [
+                        33,
+                        23
+                    ],
+                    [
+                        26,
+                        13
+                    ],
+                    [
+                        8,
+                        35
+                    ],
+                    [
+                        31,
+                        33
+                    ],
+                    [
+                        21,
+                        13
+                    ],
+                    [
+                        34,
+                        14
+                    ],
+                    [
+                        47,
+                        37
+                    ],
+                    [
+                        11,
+                        12
+                    ],
+                    [
+                        7,
+                        11
+                    ],
+                    [
+                        46,
+                        32
+                    ],
+                    [
+                        25,
+                        11
+                    ],
+                    [
+                        17,
+                        43
+                    ],
+                    [
+                        27,
+                        8
+                    ],
+                    [
+                        20,
+                        36
+                    ],
+                    [
+                        41,
+                        11
+                    ],
+                    [
+                        2,
+                        16
+                    ],
+                    [
+                        0,
+                        33
+                    ],
+                    [
+                        45,
+                        18
+                    ],
+                    [
+                        10,
+                        43
+                    ],
+                    [
+                        3,
+                        36
+                    ],
+                    [
+                        28,
+                        2
+                    ],
+                    [
+                        6,
+                        16
+                    ],
+                    [
+                        39,
+                        30
+                    ],
+                    [
+                        1,
+                        46
+                    ],
+                    [
+                        24,
+                        32
+                    ],
+                    [
+                        4,
+                        28
+                    ],
+                    [
+                        19,
+                        13
+                    ],
+                    [
+                        38,
+                        34
+                    ],
+                    [
+                        44,
+                        15
+                    ],
+                    [
+                        42,
+                        8
+                    ],
+                    [
+                        22,
+                        19
+                    ],
+                    [
+                        9,
+                        7
+                    ],
+                    [
+                        5,
+                        23
+                    ]
+                ],
+                [
+                    686,
+                    994,
+                    744,
+                    196,
+                    494,
+                    356,
+                    320,
+                    920,
+                    292,
+                    276,
+                    856,
+                    704,
+                    756,
+                    238,
+                    900,
+                    514,
+                    252,
+                    904,
+                    448,
+                    124,
+                    770,
+                    22,
+                    58,
+                    542,
+                    960,
+                    368,
+                    862,
+                    252,
+                    502,
+                    216,
+                    304,
+                    968,
+                    82,
+                    894,
+                    546,
+                    252,
+                    94,
+                    410,
+                    440,
+                    966,
+                    322,
+                    114,
+                    554,
+                    502,
+                    164,
+                    604,
+                    606,
+                    730
+                ],
+                [
+                    [
+                        21,
+                        31
+                    ],
+                    [
+                        29,
+                        14
+                    ],
+                    [
+                        21,
+                        42
+                    ],
+                    [
+                        8,
+                        8
+                    ],
+                    [
+                        36,
+                        20
+                    ],
+                    [
+                        47,
+                        41
+                    ],
+                    [
+                        47,
+                        11
+                    ],
+                    [
+                        18,
+                        1
+                    ],
+                    [
+                        45,
+                        10
+                    ],
+                    [
+                        26,
+                        37
+                    ],
+                    [
+                        31,
+                        22
+                    ],
+                    [
+                        10,
+                        29
+                    ],
+                    [
+                        25,
+                        41
+                    ],
+                    [
+                        46,
+                        10
+                    ],
+                    [
+                        8,
+                        33
+                    ],
+                    [
+                        24,
+                        16
+                    ],
+                    [
+                        9,
+                        20
+                    ],
+                    [
+                        41,
+                        23
+                    ],
+                    [
+                        39,
+                        29
+                    ]
+                ]
+            ],
+            "output": 38985
+        },
+        {
+            "input": [
+                42,
+                [
+                    [
+                        37,
+                        34
+                    ],
+                    [
+                        10,
+                        37
+                    ],
+                    [
+                        14,
+                        34
+                    ],
+                    [
+                        23,
+                        10
+                    ],
+                    [
+                        8,
+                        10
+                    ],
+                    [
+                        2,
+                        23
+                    ],
+                    [
+                        24,
+                        8
+                    ],
+                    [
+                        33,
+                        37
+                    ],
+                    [
+                        39,
+                        37
+                    ],
+                    [
+                        27,
+                        8
+                    ],
+                    [
+                        16,
+                        33
+                    ],
+                    [
+                        19,
+                        27
+                    ],
+                    [
+                        30,
+                        39
+                    ],
+                    [
+                        0,
+                        24
+                    ],
+                    [
+                        36,
+                        8
+                    ],
+                    [
+                        32,
+                        19
+                    ],
+                    [
+                        28,
+                        24
+                    ],
+                    [
+                        4,
+                        24
+                    ],
+                    [
+                        40,
+                        39
+                    ],
+                    [
+                        12,
+                        39
+                    ],
+                    [
+                        6,
+                        28
+                    ],
+                    [
+                        11,
+                        33
+                    ],
+                    [
+                        17,
+                        16
+                    ],
+                    [
+                        5,
+                        24
+                    ],
+                    [
+                        20,
+                        14
+                    ],
+                    [
+                        21,
+                        6
+                    ],
+                    [
+                        7,
+                        5
+                    ],
+                    [
+                        9,
+                        36
+                    ],
+                    [
+                        13,
+                        19
+                    ],
+                    [
+                        25,
+                        40
+                    ],
+                    [
+                        41,
+                        14
+                    ],
+                    [
+                        26,
+                        11
+                    ],
+                    [
+                        31,
+                        7
+                    ],
+                    [
+                        35,
+                        11
+                    ],
+                    [
+                        38,
+                        0
+                    ],
+                    [
+                        22,
+                        39
+                    ],
+                    [
+                        1,
+                        40
+                    ],
+                    [
+                        15,
+                        11
+                    ],
+                    [
+                        29,
+                        27
+                    ],
+                    [
+                        3,
+                        40
+                    ],
+                    [
+                        18,
+                        31
+                    ]
+                ],
+                [
+                    676,
+                    548,
+                    918,
+                    274,
+                    374,
+                    118,
+                    890,
+                    284,
+                    732,
+                    820,
+                    272,
+                    572,
+                    992,
+                    786,
+                    524,
+                    520,
+                    28,
+                    392,
+                    658,
+                    330,
+                    568,
+                    228,
+                    660,
+                    730,
+                    786,
+                    144,
+                    804,
+                    732,
+                    708,
+                    936,
+                    322,
+                    566,
+                    34,
+                    912,
+                    762,
+                    508,
+                    812,
+                    22,
+                    598,
+                    814,
+                    962,
+                    990
+                ],
+                [
+                    [
+                        26,
+                        27
+                    ],
+                    [
+                        25,
+                        2
+                    ],
+                    [
+                        16,
+                        15
+                    ],
+                    [
+                        40,
+                        39
+                    ],
+                    [
+                        14,
+                        28
+                    ],
+                    [
+                        5,
+                        0
+                    ],
+                    [
+                        9,
+                        38
+                    ],
+                    [
+                        37,
+                        11
+                    ],
+                    [
+                        21,
+                        2
+                    ],
+                    [
+                        1,
+                        34
+                    ],
+                    [
+                        4,
+                        17
+                    ],
+                    [
+                        23,
+                        23
+                    ],
+                    [
+                        19,
+                        2
+                    ],
+                    [
+                        37,
+                        16
+                    ],
+                    [
+                        7,
+                        14
+                    ],
+                    [
+                        27,
+                        4
+                    ],
+                    [
+                        0,
+                        13
+                    ],
+                    [
+                        3,
+                        1
+                    ],
+                    [
+                        36,
+                        32
+                    ],
+                    [
+                        27,
+                        18
+                    ],
+                    [
+                        17,
+                        18
+                    ],
+                    [
+                        6,
+                        30
+                    ],
+                    [
+                        7,
+                        7
+                    ],
+                    [
+                        9,
+                        31
+                    ],
+                    [
+                        13,
+                        22
+                    ],
+                    [
+                        2,
+                        27
+                    ],
+                    [
+                        33,
+                        5
+                    ],
+                    [
+                        13,
+                        4
+                    ],
+                    [
+                        18,
+                        6
+                    ],
+                    [
+                        22,
+                        6
+                    ],
+                    [
+                        35,
+                        25
+                    ],
+                    [
+                        15,
+                        0
+                    ],
+                    [
+                        27,
+                        10
+                    ],
+                    [
+                        36,
+                        24
+                    ],
+                    [
+                        39,
+                        24
+                    ],
+                    [
+                        26,
+                        14
+                    ],
+                    [
+                        4,
+                        12
+                    ],
+                    [
+                        21,
+                        11
+                    ]
+                ]
+            ],
+            "output": 87166
+        },
+        {
+            "input": [
+                49,
+                [
+                    [
+                        46,
+                        45
+                    ],
+                    [
+                        20,
+                        45
+                    ],
+                    [
+                        24,
+                        46
+                    ],
+                    [
+                        25,
+                        24
+                    ],
+                    [
+                        14,
+                        46
+                    ],
+                    [
+                        6,
+                        45
+                    ],
+                    [
+                        33,
+                        6
+                    ],
+                    [
+                        19,
+                        6
+                    ],
+                    [
+                        48,
+                        33
+                    ],
+                    [
+                        32,
+                        20
+                    ],
+                    [
+                        17,
+                        19
+                    ],
+                    [
+                        23,
+                        19
+                    ],
+                    [
+                        42,
+                        14
+                    ],
+                    [
+                        2,
+                        45
+                    ],
+                    [
+                        34,
+                        17
+                    ],
+                    [
+                        26,
+                        2
+                    ],
+                    [
+                        31,
+                        26
+                    ],
+                    [
+                        30,
+                        45
+                    ],
+                    [
+                        16,
+                        20
+                    ],
+                    [
+                        41,
+                        33
+                    ],
+                    [
+                        18,
+                        48
+                    ],
+                    [
+                        1,
+                        2
+                    ],
+                    [
+                        28,
+                        42
+                    ],
+                    [
+                        4,
+                        16
+                    ],
+                    [
+                        37,
+                        18
+                    ],
+                    [
+                        8,
+                        24
+                    ],
+                    [
+                        40,
+                        37
+                    ],
+                    [
+                        13,
+                        33
+                    ],
+                    [
+                        3,
+                        6
+                    ],
+                    [
+                        39,
+                        3
+                    ],
+                    [
+                        10,
+                        28
+                    ],
+                    [
+                        15,
+                        13
+                    ],
+                    [
+                        35,
+                        39
+                    ],
+                    [
+                        43,
+                        46
+                    ],
+                    [
+                        44,
+                        2
+                    ],
+                    [
+                        36,
+                        44
+                    ],
+                    [
+                        21,
+                        31
+                    ],
+                    [
+                        0,
+                        19
+                    ],
+                    [
+                        29,
+                        17
+                    ],
+                    [
+                        27,
+                        0
+                    ],
+                    [
+                        9,
+                        13
+                    ],
+                    [
+                        11,
+                        35
+                    ],
+                    [
+                        22,
+                        20
+                    ],
+                    [
+                        38,
+                        3
+                    ],
+                    [
+                        5,
+                        37
+                    ],
+                    [
+                        12,
+                        9
+                    ],
+                    [
+                        7,
+                        43
+                    ],
+                    [
+                        47,
+                        18
+                    ]
+                ],
+                [
+                    138,
+                    740,
+                    82,
+                    324,
+                    748,
+                    988,
+                    660,
+                    602,
+                    614,
+                    838,
+                    634,
+                    346,
+                    136,
+                    126,
+                    260,
+                    112,
+                    294,
+                    668,
+                    652,
+                    856,
+                    842,
+                    858,
+                    674,
+                    204,
+                    686,
+                    212,
+                    940,
+                    92,
+                    302,
+                    780,
+                    486,
+                    888,
+                    868,
+                    564,
+                    618,
+                    518,
+                    498,
+                    358,
+                    194,
+                    102,
+                    516,
+                    694,
+                    138,
+                    962,
+                    192,
+                    118,
+                    940,
+                    876,
+                    946
+                ],
+                [
+                    [
+                        20,
+                        21
+                    ],
+                    [
+                        35,
+                        23
+                    ],
+                    [
+                        1,
+                        24
+                    ],
+                    [
+                        26,
+                        8
+                    ],
+                    [
+                        38,
+                        34
+                    ],
+                    [
+                        1,
+                        5
+                    ],
+                    [
+                        13,
+                        32
+                    ],
+                    [
+                        11,
+                        31
+                    ],
+                    [
+                        23,
+                        28
+                    ],
+                    [
+                        46,
+                        43
+                    ],
+                    [
+                        24,
+                        5
+                    ],
+                    [
+                        15,
+                        1
+                    ],
+                    [
+                        15,
+                        4
+                    ],
+                    [
+                        7,
+                        23
+                    ],
+                    [
+                        41,
+                        45
+                    ],
+                    [
+                        27,
+                        25
+                    ],
+                    [
+                        41,
+                        35
+                    ],
+                    [
+                        39,
+                        17
+                    ],
+                    [
+                        17,
+                        34
+                    ],
+                    [
+                        14,
+                        9
+                    ],
+                    [
+                        27,
+                        30
+                    ],
+                    [
+                        4,
+                        25
+                    ],
+                    [
+                        10,
+                        17
+                    ],
+                    [
+                        40,
+                        0
+                    ],
+                    [
+                        20,
+                        0
+                    ],
+                    [
+                        7,
+                        6
+                    ],
+                    [
+                        1,
+                        7
+                    ],
+                    [
+                        30,
+                        32
+                    ],
+                    [
+                        26,
+                        5
+                    ],
+                    [
+                        37,
+                        7
+                    ],
+                    [
+                        38,
+                        40
+                    ],
+                    [
+                        28,
+                        17
+                    ],
+                    [
+                        22,
+                        34
+                    ],
+                    [
+                        9,
+                        40
+                    ],
+                    [
+                        3,
+                        32
+                    ],
+                    [
+                        40,
+                        42
+                    ],
+                    [
+                        9,
+                        9
+                    ]
+                ]
+            ],
+            "output": 90453
+        },
+        {
+            "input": [
+                46,
+                [
+                    [
+                        15,
+                        8
+                    ],
+                    [
+                        27,
+                        15
+                    ],
+                    [
+                        10,
+                        8
+                    ],
+                    [
+                        0,
+                        15
+                    ],
+                    [
+                        45,
+                        27
+                    ],
+                    [
+                        23,
+                        8
+                    ],
+                    [
+                        21,
+                        10
+                    ],
+                    [
+                        43,
+                        0
+                    ],
+                    [
+                        35,
+                        8
+                    ],
+                    [
+                        28,
+                        10
+                    ],
+                    [
+                        2,
+                        21
+                    ],
+                    [
+                        26,
+                        10
+                    ],
+                    [
+                        1,
+                        28
+                    ],
+                    [
+                        33,
+                        0
+                    ],
+                    [
+                        18,
+                        28
+                    ],
+                    [
+                        13,
+                        21
+                    ],
+                    [
+                        29,
+                        13
+                    ],
+                    [
+                        6,
+                        18
+                    ],
+                    [
+                        38,
+                        43
+                    ],
+                    [
+                        24,
+                        35
+                    ],
+                    [
+                        40,
+                        21
+                    ],
+                    [
+                        25,
+                        1
+                    ],
+                    [
+                        22,
+                        13
+                    ],
+                    [
+                        11,
+                        28
+                    ],
+                    [
+                        36,
+                        28
+                    ],
+                    [
+                        42,
+                        8
+                    ],
+                    [
+                        17,
+                        40
+                    ],
+                    [
+                        32,
+                        17
+                    ],
+                    [
+                        20,
+                        15
+                    ],
+                    [
+                        41,
+                        33
+                    ],
+                    [
+                        12,
+                        2
+                    ],
+                    [
+                        44,
+                        12
+                    ],
+                    [
+                        9,
+                        25
+                    ],
+                    [
+                        31,
+                        44
+                    ],
+                    [
+                        7,
+                        32
+                    ],
+                    [
+                        39,
+                        7
+                    ],
+                    [
+                        4,
+                        31
+                    ],
+                    [
+                        34,
+                        38
+                    ],
+                    [
+                        5,
+                        13
+                    ],
+                    [
+                        37,
+                        27
+                    ],
+                    [
+                        14,
+                        13
+                    ],
+                    [
+                        16,
+                        39
+                    ],
+                    [
+                        3,
+                        42
+                    ],
+                    [
+                        19,
+                        40
+                    ],
+                    [
+                        30,
+                        28
+                    ]
+                ],
+                [
+                    658,
+                    914,
+                    786,
+                    418,
+                    136,
+                    222,
+                    168,
+                    300,
+                    342,
+                    976,
+                    458,
+                    590,
+                    350,
+                    684,
+                    864,
+                    820,
+                    222,
+                    982,
+                    994,
+                    374,
+                    60,
+                    284,
+                    516,
+                    686,
+                    492,
+                    154,
+                    500,
+                    158,
+                    482,
+                    86,
+                    384,
+                    384,
+                    976,
+                    742,
+                    154,
+                    570,
+                    918,
+                    446,
+                    308,
+                    626,
+                    768,
+                    552,
+                    446,
+                    470,
+                    324,
+                    866
+                ],
+                [
+                    [
+                        2,
+                        31
+                    ],
+                    [
+                        13,
+                        42
+                    ],
+                    [
+                        22,
+                        16
+                    ],
+                    [
+                        37,
+                        19
+                    ],
+                    [
+                        4,
+                        24
+                    ],
+                    [
+                        6,
+                        36
+                    ],
+                    [
+                        29,
+                        4
+                    ],
+                    [
+                        18,
+                        20
+                    ],
+                    [
+                        24,
+                        23
+                    ],
+                    [
+                        7,
+                        40
+                    ],
+                    [
+                        14,
+                        16
+                    ],
+                    [
+                        43,
+                        26
+                    ],
+                    [
+                        41,
+                        30
+                    ],
+                    [
+                        19,
+                        8
+                    ],
+                    [
+                        11,
+                        31
+                    ],
+                    [
+                        9,
+                        37
+                    ],
+                    [
+                        9,
+                        18
+                    ],
+                    [
+                        39,
+                        22
+                    ],
+                    [
+                        2,
+                        19
+                    ],
+                    [
+                        37,
+                        1
+                    ],
+                    [
+                        6,
+                        20
+                    ],
+                    [
+                        14,
+                        31
+                    ],
+                    [
+                        31,
+                        43
+                    ],
+                    [
+                        5,
+                        38
+                    ],
+                    [
+                        1,
+                        15
+                    ],
+                    [
+                        17,
+                        44
+                    ],
+                    [
+                        19,
+                        23
+                    ],
+                    [
+                        24,
+                        0
+                    ],
+                    [
+                        25,
+                        3
+                    ],
+                    [
+                        34,
+                        2
+                    ],
+                    [
+                        29,
+                        12
+                    ],
+                    [
+                        1,
+                        16
+                    ],
+                    [
+                        39,
+                        6
+                    ],
+                    [
+                        34,
+                        22
+                    ],
+                    [
+                        39,
+                        5
+                    ],
+                    [
+                        14,
+                        10
+                    ],
+                    [
+                        0,
+                        28
+                    ],
+                    [
+                        17,
+                        18
+                    ],
+                    [
+                        19,
+                        5
+                    ],
+                    [
+                        2,
+                        25
+                    ],
+                    [
+                        5,
+                        36
+                    ],
+                    [
+                        20,
+                        27
+                    ],
+                    [
+                        5,
+                        19
+                    ],
+                    [
+                        6,
+                        44
+                    ],
+                    [
+                        8,
+                        13
+                    ],
+                    [
+                        30,
+                        26
+                    ],
+                    [
+                        35,
+                        34
+                    ],
+                    [
+                        31,
+                        41
+                    ],
+                    [
+                        44,
+                        31
+                    ],
+                    [
+                        24,
+                        36
+                    ],
+                    [
+                        9,
+                        34
+                    ],
+                    [
+                        36,
+                        30
+                    ],
+                    [
+                        34,
+                        40
+                    ],
+                    [
+                        27,
+                        30
+                    ],
+                    [
+                        10,
+                        23
+                    ],
+                    [
+                        1,
+                        8
+                    ],
+                    [
+                        16,
+                        18
+                    ],
+                    [
+                        0,
+                        29
+                    ]
+                ]
+            ],
+            "output": 137007
+        },
+        {
+            "input": [
+                12,
+                [
+                    [
+                        9,
+                        5
+                    ],
+                    [
+                        8,
+                        5
+                    ],
+                    [
+                        4,
+                        5
+                    ],
+                    [
+                        1,
+                        4
+                    ],
+                    [
+                        7,
+                        1
+                    ],
+                    [
+                        0,
+                        5
+                    ],
+                    [
+                        6,
+                        1
+                    ],
+                    [
+                        10,
+                        7
+                    ],
+                    [
+                        2,
+                        10
+                    ],
+                    [
+                        3,
+                        5
+                    ],
+                    [
+                        11,
+                        8
+                    ]
+                ],
+                [
+                    384,
+                    798,
+                    18,
+                    330,
+                    838,
+                    812,
+                    180,
+                    698,
+                    816,
+                    544,
+                    518,
+                    796
+                ],
+                [
+                    [
+                        6,
+                        0
+                    ],
+                    [
+                        7,
+                        11
+                    ],
+                    [
+                        6,
+                        3
+                    ],
+                    [
+                        9,
+                        6
+                    ],
+                    [
+                        2,
+                        2
+                    ],
+                    [
+                        10,
+                        3
+                    ],
+                    [
+                        6,
+                        11
+                    ],
+                    [
+                        0,
+                        3
+                    ],
+                    [
+                        11,
+                        11
+                    ],
+                    [
+                        3,
+                        10
+                    ],
+                    [
+                        0,
+                        9
+                    ],
+                    [
+                        10,
+                        7
+                    ],
+                    [
+                        1,
+                        3
+                    ],
+                    [
+                        3,
+                        11
+                    ],
+                    [
+                        9,
+                        0
+                    ],
+                    [
+                        4,
+                        8
+                    ],
+                    [
+                        7,
+                        11
+                    ],
+                    [
+                        5,
+                        5
+                    ],
+                    [
+                        2,
+                        7
+                    ],
+                    [
+                        8,
+                        10
+                    ],
+                    [
+                        6,
+                        0
+                    ],
+                    [
+                        4,
+                        4
+                    ],
+                    [
+                        11,
+                        9
+                    ],
+                    [
+                        10,
+                        4
+                    ],
+                    [
+                        11,
+                        5
+                    ],
+                    [
+                        2,
+                        6
+                    ],
+                    [
+                        8,
+                        11
+                    ],
+                    [
+                        8,
+                        7
+                    ],
+                    [
+                        0,
+                        9
+                    ],
+                    [
+                        10,
+                        8
+                    ],
+                    [
+                        0,
+                        7
+                    ],
+                    [
+                        6,
+                        2
+                    ],
+                    [
+                        7,
+                        11
+                    ],
+                    [
+                        10,
+                        8
+                    ],
+                    [
+                        4,
+                        2
+                    ],
+                    [
+                        3,
+                        0
+                    ],
+                    [
+                        9,
+                        6
+                    ],
+                    [
+                        7,
+                        4
+                    ],
+                    [
+                        10,
+                        4
+                    ],
+                    [
+                        0,
+                        7
+                    ],
+                    [
+                        10,
+                        1
+                    ],
+                    [
+                        7,
+                        2
+                    ],
+                    [
+                        0,
+                        4
+                    ],
+                    [
+                        8,
+                        8
+                    ],
+                    [
+                        11,
+                        2
+                    ],
+                    [
+                        1,
+                        10
+                    ],
+                    [
+                        3,
+                        3
+                    ],
+                    [
+                        4,
+                        2
+                    ],
+                    [
+                        4,
+                        8
+                    ],
+                    [
+                        5,
+                        7
+                    ],
+                    [
+                        5,
+                        4
+                    ],
+                    [
+                        9,
+                        7
+                    ]
+                ]
+            ],
+            "output": 102841
+        },
+        {
+            "input": [
+                38,
+                [
+                    [
+                        13,
+                        27
+                    ],
+                    [
+                        16,
+                        13
+                    ],
+                    [
+                        8,
+                        13
+                    ],
+                    [
+                        21,
+                        16
+                    ],
+                    [
+                        37,
+                        27
+                    ],
+                    [
+                        9,
+                        8
+                    ],
+                    [
+                        22,
+                        21
+                    ],
+                    [
+                        0,
+                        27
+                    ],
+                    [
+                        34,
+                        22
+                    ],
+                    [
+                        17,
+                        21
+                    ],
+                    [
+                        12,
+                        21
+                    ],
+                    [
+                        36,
+                        16
+                    ],
+                    [
+                        32,
+                        34
+                    ],
+                    [
+                        24,
+                        0
+                    ],
+                    [
+                        20,
+                        12
+                    ],
+                    [
+                        1,
+                        17
+                    ],
+                    [
+                        30,
+                        37
+                    ],
+                    [
+                        3,
+                        22
+                    ],
+                    [
+                        31,
+                        21
+                    ],
+                    [
+                        14,
+                        32
+                    ],
+                    [
+                        29,
+                        37
+                    ],
+                    [
+                        19,
+                        29
+                    ],
+                    [
+                        33,
+                        12
+                    ],
+                    [
+                        7,
+                        1
+                    ],
+                    [
+                        15,
+                        36
+                    ],
+                    [
+                        18,
+                        15
+                    ],
+                    [
+                        28,
+                        19
+                    ],
+                    [
+                        35,
+                        36
+                    ],
+                    [
+                        5,
+                        34
+                    ],
+                    [
+                        2,
+                        8
+                    ],
+                    [
+                        26,
+                        31
+                    ],
+                    [
+                        10,
+                        33
+                    ],
+                    [
+                        11,
+                        34
+                    ],
+                    [
+                        23,
+                        33
+                    ],
+                    [
+                        25,
+                        17
+                    ],
+                    [
+                        4,
+                        2
+                    ],
+                    [
+                        6,
+                        26
+                    ]
+                ],
+                [
+                    430,
+                    364,
+                    504,
+                    852,
+                    728,
+                    384,
+                    960,
+                    644,
+                    890,
+                    72,
+                    920,
+                    980,
+                    572,
+                    398,
+                    342,
+                    790,
+                    638,
+                    538,
+                    252,
+                    276,
+                    228,
+                    94,
+                    224,
+                    416,
+                    264,
+                    592,
+                    324,
+                    314,
+                    162,
+                    378,
+                    114,
+                    280,
+                    570,
+                    720,
+                    506,
+                    982,
+                    926,
+                    204
+                ],
+                [
+                    [
+                        25,
+                        7
+                    ],
+                    [
+                        30,
+                        29
+                    ],
+                    [
+                        22,
+                        6
+                    ],
+                    [
+                        20,
+                        8
+                    ],
+                    [
+                        10,
+                        14
+                    ],
+                    [
+                        18,
+                        33
+                    ],
+                    [
+                        33,
+                        7
+                    ],
+                    [
+                        0,
+                        27
+                    ],
+                    [
+                        15,
+                        31
+                    ],
+                    [
+                        25,
+                        27
+                    ],
+                    [
+                        14,
+                        13
+                    ],
+                    [
+                        21,
+                        32
+                    ],
+                    [
+                        3,
+                        17
+                    ],
+                    [
+                        31,
+                        16
+                    ],
+                    [
+                        32,
+                        37
+                    ],
+                    [
+                        10,
+                        9
+                    ],
+                    [
+                        11,
+                        19
+                    ],
+                    [
+                        18,
+                        17
+                    ],
+                    [
+                        30,
+                        27
+                    ],
+                    [
+                        7,
+                        2
+                    ],
+                    [
+                        34,
+                        15
+                    ],
+                    [
+                        30,
+                        19
+                    ],
+                    [
+                        9,
+                        29
+                    ]
+                ]
+            ],
+            "output": 39537
+        }
+    ],
+    "haskell_template": "minimumTotalPrice :: Int -> [[Int]] -> [Int] -> [[Int]] -> Int\nminimumTotalPrice n edges price trips ",
+    "ocaml_template": "let minimumTotalPrice (n: int) (edges: int list list) (price: int list) (trips: int list list) : int =  ",
+    "scala_template": "def minimumTotalPrice(n: Int,edges: List[List[Int]],price: List[Int],trips: List[List[Int]]): Int = { \n    \n}",
+    "java_template": "public static int minimumTotalPrice(int n, List<List<Integer>> edges, List<Integer> price, List<List<Integer>> trips) {\n\n}",
+    "python_template": "class Solution(object):\n    def minimumTotalPrice(self, n, edges, price, trips):\n        \"\"\"\n        :type n: int\n        :type edges: List[List[int]]\n        :type price: List[int]\n        :type trips: List[List[int]]\n        :rtype: int\n        \"\"\"\n        "
+}

minimize_the_total_price_of_the_trips/ocaml_tests/main.ml

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

minimize_the_total_price_of_the_trips/scala_tests/MySuite.scala

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

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

minimize_xor/java_tests/Main.java

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

minimize_xor/meta.json

@@ -0,0 +1,97 @@
+{
+    "id": 2509,
+    "name": "minimize_xor",
+    "difficulty": "Medium",
+    "link": "https://leetcode.com/problems/minimize-xor/",
+    "date": "1664064000000",
+    "task_description": "Given two positive integers `num1` and `num2`, find the positive integer `x` such that: `x` has the same number of set bits as `num2`, and The value `x XOR num1` is **minimal**. Note that `XOR` is the bitwise XOR operation. Return _the integer _`x`. The test cases are generated such that `x` is **uniquely determined**. The number of **set bits** of an integer is the number of `1`'s in its binary representation. **Example 1:** ``` **Input:** num1 = 3, num2 = 5 **Output:** 3 **Explanation:** The binary representations of num1 and num2 are 0011 and 0101, respectively. The integer **3** has the same number of set bits as num2, and the value `3 XOR 3 = 0` is minimal. ``` **Example 2:** ``` **Input:** num1 = 1, num2 = 12 **Output:** 3 **Explanation:** The binary representations of num1 and num2 are 0001 and 1100, respectively. The integer **3** has the same number of set bits as num2, and the value `3 XOR 1 = 2` is minimal. ``` **Constraints:** `1 <= num1, num2 <= 109`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "num1 = 3, num2 = 5",
+            "output": "3 "
+        },
+        {
+            "label": "Example 2",
+            "input": "num1 = 1, num2 = 12",
+            "output": "3 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                72176727,
+                770164438
+            ],
+            "output": 72179711
+        },
+        {
+            "input": [
+                468575171,
+                27444322
+            ],
+            "output": 468516864
+        },
+        {
+            "input": [
+                222127838,
+                599095754
+            ],
+            "output": 222127836
+        },
+        {
+            "input": [
+                507580866,
+                282877334
+            ],
+            "output": 507580895
+        },
+        {
+            "input": [
+                668869429,
+                942725715
+            ],
+            "output": 668869408
+        },
+        {
+            "input": [
+                117649255,
+                771918934
+            ],
+            "output": 117649248
+        },
+        {
+            "input": [
+                295349101,
+                628704578
+            ],
+            "output": 295349088
+        },
+        {
+            "input": [
+                98205273,
+                230406736
+            ],
+            "output": 98205272
+        },
+        {
+            "input": [
+                711548599,
+                865594601
+            ],
+            "output": 711548607
+        },
+        {
+            "input": [
+                394257872,
+                81713535
+            ],
+            "output": 394257872
+        }
+    ],
+    "haskell_template": "minimizeXor :: Int -> Int -> Int\nminimizeXor num1 num2 ",
+    "ocaml_template": "let minimizeXor (num1: int) (num2: int) : int =  ",
+    "scala_template": "def minimizeXor(num1: Int,num2: Int): Int = { \n    \n}",
+    "java_template": "public static int minimizeXor(int num1, int num2) {\n\n}",
+    "python_template": "class Solution(object):\n    def minimizeXor(self, num1, num2):\n        \"\"\"\n        :type num1: int\n        :type num2: int\n        :rtype: int\n        \"\"\"\n        "
+}

minimize_xor/ocaml_tests/main.ml

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

minimize_xor/scala_tests/MySuite.scala

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

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

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

minimum_absolute_difference_between_elements_with_constraint/meta.json

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

minimum_absolute_difference_between_elements_with_constraint/ocaml_tests/main.ml

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

minimum_absolute_difference_between_elements_with_constraint/scala_tests/MySuite.scala

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

minimum_additions_to_make_valid_string/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 (addMinimum \"b \")," 2 (addMinimum "b"))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (addMinimum \"aaa \")," 6 (addMinimum "aaa"))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (addMinimum \"abc \")," 0 (addMinimum "abc"))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1, TestLabel "Test2" test2]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

minimum_additions_to_make_valid_string/java_tests/Main.java

@@ -0,0 +1,25 @@
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+import java.util.List;
+import java.util.Arrays;
+import java.util.ArrayList;
+public class Main {
+    //Program start
+    
+    //Program end
+
+    @Test
+public void test1() {
+    assertEquals(2, addMinimum("b"));
+}
+@Test
+public void test2() {
+    assertEquals(6, addMinimum("aaa"));
+}
+@Test
+public void test3() {
+    assertEquals(0, addMinimum("abc"));
+}
+
+}

minimum_additions_to_make_valid_string/meta.json

@@ -0,0 +1,72 @@
+{
+    "id": 2736,
+    "name": "minimum_additions_to_make_valid_string",
+    "difficulty": "Medium",
+    "link": "https://leetcode.com/problems/minimum-additions-to-make-valid-string/",
+    "date": "1680998400000",
+    "task_description": "Given a string `word` to which you can insert letters \"a\", \"b\" or \"c\" anywhere and any number of times, return _the minimum number of letters that must be inserted so that `word` becomes **valid**._ A string is called **valid **if it can be formed by concatenating the string \"abc\" several times. **Example 1:** ``` **Input:** word = \"b\" **Output:** 2 **Explanation:** Insert the letter \"a\" right before \"b\", and the letter \"c\" right next to \"b\" to obtain the valid string \"**a**b**c**\". ``` **Example 2:** ``` **Input:** word = \"aaa\" **Output:** 6 **Explanation:** Insert letters \"b\" and \"c\" next to each \"a\" to obtain the valid string \"a**bc**a**bc**a**bc**\". ``` **Example 3:** ``` **Input:** word = \"abc\" **Output:** 0 **Explanation:** word is already valid. No modifications are needed. ``` **Constraints:** `1 <= word.length <= 50` `word` consists of letters \"a\", \"b\" and \"c\" only.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "word = \"b\"",
+            "output": "2 "
+        },
+        {
+            "label": "Example 2",
+            "input": "word = \"aaa\"",
+            "output": "6 "
+        },
+        {
+            "label": "Example 3",
+            "input": "word = \"abc\"",
+            "output": "0 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": "bcbbcccbabacaacbacbababcccb",
+            "output": 27
+        },
+        {
+            "input": "aabbbbbabaacbbaccabaabccacaccbccbccccbaabcac",
+            "output": 46
+        },
+        {
+            "input": "ccaabcbc",
+            "output": 7
+        },
+        {
+            "input": "bbbbbcbcbbbcabcbbbabacaabccbbbca",
+            "output": 34
+        },
+        {
+            "input": "bcbccbccababccbccbbabc",
+            "output": 17
+        },
+        {
+            "input": "bbcaccabbbcbcbbcaabcacacbbbccacabbabcbaacbbaaacaac",
+            "output": 46
+        },
+        {
+            "input": "bcaabaabacbcbacbcacacabcccacacabbbabbacbbaabcbaba",
+            "output": 41
+        },
+        {
+            "input": "ccbcbabacacbbaaaaabbcaabccbabacabacaacb",
+            "output": 39
+        },
+        {
+            "input": "bbcbbbcbbabccbaacabaccbcbcbbbbacccbbbabccbaa",
+            "output": 52
+        },
+        {
+            "input": "cabcaaaabababbcab",
+            "output": 13
+        }
+    ],
+    "haskell_template": "addMinimum :: String -> Int\naddMinimum word ",
+    "ocaml_template": "let addMinimum (word: string) : int =  ",
+    "scala_template": "def addMinimum(word: String): Int = { \n    \n}",
+    "java_template": "public static int addMinimum(String word) {\n\n}",
+    "python_template": "class Solution(object):\n    def addMinimum(self, word):\n        \"\"\"\n        :type word: str\n        :rtype: int\n        \"\"\"\n        "
+}

minimum_additions_to_make_valid_string/ocaml_tests/main.ml

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

minimum_additions_to_make_valid_string/scala_tests/MySuite.scala

@@ -0,0 +1,16 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.addMinimum("b"), 2)
+  }
+
+  test("test2") {
+    assertEquals(Main.addMinimum("aaa"), 6)
+  }
+
+  test("test3") {
+    assertEquals(Main.addMinimum("abc"), 0)
+  }
+
+}

minimum_amount_of_time_to_collect_garbage/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 (garbageCollection [ \"G \", \"P \", \"GP \", \"GG \"] [2,4,3])," 21 (garbageCollection ["G","P","GP","GG"] [2,4,3]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (garbageCollection [ \"MMM \", \"PGM \", \"GP \"] [3,10])," 37 (garbageCollection ["MMM","PGM","GP"] [3,10]))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

minimum_amount_of_time_to_collect_garbage/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(21, garbageCollection(new ArrayList<>(Arrays.asList("G","P","GP","GG")), new ArrayList<>(Arrays.asList(2,4,3))));
+}
+@Test
+public void test2() {
+    assertEquals(37, garbageCollection(new ArrayList<>(Arrays.asList("MMM","PGM","GP")), new ArrayList<>(Arrays.asList(3,10))));
+}
+
+}

minimum_amount_of_time_to_collect_garbage/meta.json

@@ -0,0 +1,1221 @@
+{
+    "id": 2471,
+    "name": "minimum_amount_of_time_to_collect_garbage",
+    "difficulty": "Medium",
+    "link": "https://leetcode.com/problems/minimum-amount-of-time-to-collect-garbage/",
+    "date": "1661040000000",
+    "task_description": "You are given a **0-indexed** array of strings `garbage` where `garbage[i]` represents the assortment of garbage at the `ith` house. `garbage[i]` consists only of the characters `'M'`, `'P'` and `'G'` representing one unit of metal, paper and glass garbage respectively. Picking up **one** unit of any type of garbage takes `1` minute. You are also given a **0-indexed** integer array `travel` where `travel[i]` is the number of minutes needed to go from house `i` to house `i + 1`. There are three garbage trucks in the city, each responsible for picking up one type of garbage. Each garbage truck starts at house `0` and must visit each house **in order**; however, they do **not** need to visit every house. Only **one** garbage truck may be used at any given moment. While one truck is driving or picking up garbage, the other two trucks **cannot** do anything. Return_ the **minimum** number of minutes needed to pick up all the garbage._ **Example 1:** ``` **Input:** garbage = [\"G\",\"P\",\"GP\",\"GG\"], travel = [2,4,3] **Output:** 21 **Explanation:** The paper garbage truck: 1. Travels from house 0 to house 1 2. Collects the paper garbage at house 1 3. Travels from house 1 to house 2 4. Collects the paper garbage at house 2 Altogether, it takes 8 minutes to pick up all the paper garbage. The glass garbage truck: 1. Collects the glass garbage at house 0 2. Travels from house 0 to house 1 3. Travels from house 1 to house 2 4. Collects the glass garbage at house 2 5. Travels from house 2 to house 3 6. Collects the glass garbage at house 3 Altogether, it takes 13 minutes to pick up all the glass garbage. Since there is no metal garbage, we do not need to consider the metal garbage truck. Therefore, it takes a total of 8 + 13 = 21 minutes to collect all the garbage. ``` **Example 2:** ``` **Input:** garbage = [\"MMM\",\"PGM\",\"GP\"], travel = [3,10] **Output:** 37 **Explanation:** The metal garbage truck takes 7 minutes to pick up all the metal garbage. The paper garbage truck takes 15 minutes to pick up all the paper garbage. The glass garbage truck takes 15 minutes to pick up all the glass garbage. It takes a total of 7 + 15 + 15 = 37 minutes to collect all the garbage. ``` **Constraints:** `2 <= garbage.length <= 105` `garbage[i]` consists of only the letters `'M'`, `'P'`, and `'G'`. `1 <= garbage[i].length <= 10` `travel.length == garbage.length - 1` `1 <= travel[i] <= 100`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "garbage = [\"G\",\"P\",\"GP\",\"GG\"], travel = [2,4,3]",
+            "output": "21 "
+        },
+        {
+            "label": "Example 2",
+            "input": "garbage = [\"MMM\",\"PGM\",\"GP\"], travel = [3,10]",
+            "output": "37 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                [
+                    "GMPMGG",
+                    "PMMGM",
+                    "PMPPMMGGG",
+                    "MGPPPPGGG",
+                    "M",
+                    "MM",
+                    "MP",
+                    "PG",
+                    "GMGGGGMGG",
+                    "PMPMMGP",
+                    "PPGPMGGM",
+                    "PMM",
+                    "MGGPM",
+                    "MPPGMMGGMP",
+                    "MPMPPGMM",
+                    "MGMGPMG",
+                    "PGMGMGP",
+                    "GMPM",
+                    "MPMPPMMGG",
+                    "PMPMMMMGGP",
+                    "MPMPPMMGMP",
+                    "MGMMMGPMM",
+                    "M",
+                    "PGMMMMPPM",
+                    "MPP",
+                    "GGGMMPGMM",
+                    "MPGMMMMMGP",
+                    "PMM",
+                    "MPPGGG",
+                    "MPMP",
+                    "PGMGMGPM",
+                    "PMPGPMGGMM",
+                    "PGMMGPPMM",
+                    "PPGG",
+                    "GGP",
+                    "M",
+                    "GMMGMP",
+                    "M",
+                    "PMGP",
+                    "MMGPPPG",
+                    "P",
+                    "PMMPGGP",
+                    "PPMPGP"
+                ],
+                [
+                    81,
+                    84,
+                    97,
+                    196,
+                    236,
+                    294,
+                    358,
+                    444,
+                    521,
+                    549,
+                    627,
+                    655,
+                    656,
+                    714,
+                    722,
+                    723,
+                    757,
+                    798,
+                    801,
+                    827,
+                    872,
+                    890,
+                    946,
+                    974,
+                    1069,
+                    1156,
+                    1247,
+                    1328,
+                    1410,
+                    1486,
+                    1576,
+                    1626,
+                    1726,
+                    1804,
+                    1878,
+                    1917,
+                    1956,
+                    2055,
+                    2094,
+                    2192,
+                    2209,
+                    2231
+                ]
+            ],
+            "output": 6947
+        },
+        {
+            "input": [
+                [
+                    "PG",
+                    "PMPMMPMPM",
+                    "MMPPGGPP",
+                    "MGGGMMP",
+                    "GPMMM",
+                    "G",
+                    "PGGP",
+                    "MMGPP",
+                    "P",
+                    "GPGMGMPGGP",
+                    "MMM",
+                    "MPP",
+                    "GP",
+                    "GP",
+                    "GPPPGMM",
+                    "PMPGMPPG",
+                    "G",
+                    "G",
+                    "GPMMPMMG",
+                    "P",
+                    "G",
+                    "GMG",
+                    "PGGMG",
+                    "PMPMGPGPGP",
+                    "GG",
+                    "PGG",
+                    "MMGMGPGPGP",
+                    "GGPGMGGMPP",
+                    "PMMPMGPGP",
+                    "PPGGGMPGP",
+                    "PPMMM",
+                    "MGPMPP",
+                    "MMPG",
+                    "MGMGPM",
+                    "GPMGPPPM",
+                    "MMG",
+                    "GP",
+                    "GGGPMPMG",
+                    "PPPGGPG",
+                    "MPPPMGMP",
+                    "PMMP",
+                    "GGPMGGPPM",
+                    "PPMMGPG",
+                    "MP",
+                    "MGMMGMG",
+                    "GPGGPPPGP",
+                    "MPGPPGGGM",
+                    "M",
+                    "MPPPMPPGM",
+                    "MPGP",
+                    "GPGGGP",
+                    "MPMGM",
+                    "PPMGMMMGPP",
+                    "PGP",
+                    "MM",
+                    "MMMM",
+                    "GPGMMMGG",
+                    "MGMGPMPG",
+                    "GG",
+                    "PMGPMM",
+                    "GPPMMGGGGG",
+                    "MMMGGG",
+                    "G",
+                    "MGGG",
+                    "GGPPGM",
+                    "MGGMGGGGM",
+                    "MPPPPGGPMM",
+                    "PMPMPM",
+                    "PMMGGPMP",
+                    "PGGG",
+                    "MPMGPPPP",
+                    "MGMM",
+                    "MPGPGPMPM",
+                    "MMMGM",
+                    "MPGPMMP",
+                    "GPPGGMM",
+                    "MGGGM",
+                    "MPGPGPPPMG",
+                    "GGPGGGG",
+                    "MMM",
+                    "MMMMG",
+                    "GMGPMPGMMG",
+                    "M",
+                    "PPGMMM"
+                ],
+                [
+                    12,
+                    49,
+                    72,
+                    155,
+                    255,
+                    262,
+                    263,
+                    276,
+                    354,
+                    394,
+                    491,
+                    585,
+                    590,
+                    668,
+                    732,
+                    748,
+                    824,
+                    857,
+                    894,
+                    937,
+                    1028,
+                    1095,
+                    1107,
+                    1167,
+                    1229,
+                    1328,
+                    1428,
+                    1524,
+                    1616,
+                    1716,
+                    1730,
+                    1828,
+                    1928,
+                    1963,
+                    2029,
+                    2117,
+                    2160,
+                    2218,
+                    2276,
+                    2361,
+                    2375,
+                    2440,
+                    2459,
+                    2513,
+                    2588,
+                    2649,
+                    2749,
+                    2793,
+                    2819,
+                    2865,
+                    2894,
+                    2928,
+                    2967,
+                    3025,
+                    3069,
+                    3128,
+                    3166,
+                    3266,
+                    3274,
+                    3318,
+                    3356,
+                    3379,
+                    3472,
+                    3551,
+                    3577,
+                    3620,
+                    3638,
+                    3693,
+                    3719,
+                    3731,
+                    3749,
+                    3779,
+                    3829,
+                    3838,
+                    3860,
+                    3893,
+                    3977,
+                    4057,
+                    4145,
+                    4209,
+                    4244,
+                    4301,
+                    4341
+                ]
+            ],
+            "output": 13496
+        },
+        {
+            "input": [
+                [
+                    "MGPMMPGG",
+                    "MGMMGGM",
+                    "PGGGGPMGMM",
+                    "GMPPMPPPPM",
+                    "GPMPPPMPGP",
+                    "MGPGPM",
+                    "GGGMPGM",
+                    "MPPMPGP",
+                    "GMG",
+                    "PPPGPGMGPP",
+                    "MM",
+                    "MMMGMG",
+                    "GGGMPPPGGG",
+                    "PMMPMPMPM",
+                    "PPMMGPMGGG",
+                    "G",
+                    "MP",
+                    "PGPGPMG",
+                    "PPMPGGM",
+                    "MM",
+                    "MPPPMPGMP",
+                    "MGMMPP",
+                    "PMPM",
+                    "MPGGGGGGMM",
+                    "MGP",
+                    "P",
+                    "MGGPGGPMM",
+                    "PMGMMPGMGP",
+                    "MGGGGGP",
+                    "PGPMMGG",
+                    "GMP",
+                    "PPMGPMMGMP",
+                    "PMP",
+                    "MPPGGMM",
+                    "PGPPG",
+                    "MGGGPGMP",
+                    "GPGPP",
+                    "PG",
+                    "GMPPPGGGM",
+                    "GGGGPPGPGM",
+                    "GPPMPGPMM",
+                    "PMGGP",
+                    "PGMGPM",
+                    "GMMMMPM",
+                    "GMM",
+                    "GMMGGPM",
+                    "PGP",
+                    "MG",
+                    "MMMMMMGG",
+                    "PPMMMGM",
+                    "GPPPG",
+                    "PPGGPGPGP",
+                    "GGMGMP",
+                    "GMMMPPGPM",
+                    "MGP",
+                    "MGP",
+                    "MGMGMMMGM",
+                    "PMGGMGP",
+                    "GMGGP",
+                    "PMMMMPGM",
+                    "GPPP",
+                    "MMGPMMPMPM",
+                    "MGP",
+                    "MMMM",
+                    "PGM",
+                    "MGPMPMMPP",
+                    "MMGMPG",
+                    "PGMMPMGPMM",
+                    "GPPMGMMG",
+                    "MPG",
+                    "P",
+                    "MGPPMPGPG",
+                    "GPPMPGG",
+                    "GPMGM",
+                    "GPGGGPGPP"
+                ],
+                [
+                    23,
+                    123,
+                    147,
+                    157,
+                    188,
+                    287,
+                    348,
+                    441,
+                    459,
+                    531,
+                    559,
+                    579,
+                    665,
+                    686,
+                    693,
+                    724,
+                    746,
+                    792,
+                    868,
+                    884,
+                    906,
+                    971,
+                    990,
+                    1036,
+                    1090,
+                    1097,
+                    1168,
+                    1170,
+                    1201,
+                    1263,
+                    1339,
+                    1426,
+                    1485,
+                    1504,
+                    1537,
+                    1561,
+                    1606,
+                    1681,
+                    1684,
+                    1769,
+                    1838,
+                    1861,
+                    1891,
+                    1928,
+                    1994,
+                    2083,
+                    2168,
+                    2191,
+                    2228,
+                    2297,
+                    2389,
+                    2432,
+                    2440,
+                    2490,
+                    2579,
+                    2660,
+                    2734,
+                    2786,
+                    2849,
+                    2906,
+                    2935,
+                    3016,
+                    3069,
+                    3133,
+                    3207,
+                    3256,
+                    3259,
+                    3334,
+                    3392,
+                    3444,
+                    3462,
+                    3530,
+                    3610,
+                    3710
+                ]
+            ],
+            "output": 11504
+        },
+        {
+            "input": [
+                [
+                    "GMPMPMPM",
+                    "PMM",
+                    "PPG",
+                    "PGMMPPMPMP",
+                    "GMM",
+                    "MGPPGPGPM",
+                    "PM",
+                    "PMGPP",
+                    "G",
+                    "MMGG",
+                    "P",
+                    "MPMMP",
+                    "PGMPPGPP",
+                    "MGMPGPMPP",
+                    "PMGMGMMMGM",
+                    "MMPGMGMMMM",
+                    "PGPPPMMMP",
+                    "GP",
+                    "PPM",
+                    "GPMMPG"
+                ],
+                [
+                    68,
+                    94,
+                    132,
+                    193,
+                    242,
+                    284,
+                    372,
+                    386,
+                    486,
+                    487,
+                    557,
+                    618,
+                    637,
+                    676,
+                    679,
+                    770,
+                    783,
+                    832,
+                    917
+                ]
+            ],
+            "output": 2862
+        },
+        {
+            "input": [
+                [
+                    "PGGMPPGG",
+                    "GGMPPM",
+                    "PP",
+                    "MGMPMGG",
+                    "MGPGMMG",
+                    "MPPPMGG",
+                    "MPG",
+                    "PMPMG",
+                    "M",
+                    "MMMPGGMPGM",
+                    "GMMGPG",
+                    "GMGMM",
+                    "PP",
+                    "GMMPMPGMP",
+                    "MGGPGPGMG",
+                    "GMM",
+                    "MPGMMPM",
+                    "MMPGMGPPMG",
+                    "PPPMGPMMG",
+                    "M",
+                    "MGGGMGM",
+                    "GP",
+                    "GMMPG",
+                    "MPPPPG",
+                    "PGPPGGG",
+                    "GMP",
+                    "PPGGPMGP",
+                    "MGGGMP",
+                    "M",
+                    "P",
+                    "MGMG",
+                    "MMPMGGMMM",
+                    "GGMM",
+                    "GPGGMPPMGG",
+                    "PG",
+                    "PGGG",
+                    "GPMGPP",
+                    "PG",
+                    "PPPGMMPGP",
+                    "PGPPPMGG",
+                    "PGM",
+                    "GMMPMGMPGP",
+                    "PGMPGPPG",
+                    "MGG",
+                    "PGMPG",
+                    "MPMPGGGMM",
+                    "PMMGPP",
+                    "G",
+                    "MGGM",
+                    "P",
+                    "MGGPMGPG",
+                    "GM",
+                    "GMPMMPM",
+                    "GGGGMGM",
+                    "PPGGPPGM",
+                    "PGMPMMM",
+                    "PPGGM",
+                    "GGGM",
+                    "PPGGMGPPM",
+                    "P",
+                    "PPGMPMGPPG",
+                    "MPMMGGGGP",
+                    "MGPGM",
+                    "MMPMGGGMMP",
+                    "GMPM",
+                    "GGG",
+                    "MMMG",
+                    "GPGGMPGMP",
+                    "PPP",
+                    "MGMPM",
+                    "MGMPGMMPG"
+                ],
+                [
+                    18,
+                    48,
+                    135,
+                    198,
+                    282,
+                    327,
+                    331,
+                    431,
+                    498,
+                    540,
+                    548,
+                    613,
+                    696,
+                    751,
+                    820,
+                    852,
+                    893,
+                    936,
+                    1004,
+                    1079,
+                    1172,
+                    1227,
+                    1259,
+                    1312,
+                    1380,
+                    1443,
+                    1486,
+                    1488,
+                    1518,
+                    1613,
+                    1678,
+                    1762,
+                    1765,
+                    1786,
+                    1844,
+                    1875,
+                    1878,
+                    1915,
+                    1927,
+                    1928,
+                    1944,
+                    2010,
+                    2107,
+                    2146,
+                    2172,
+                    2207,
+                    2274,
+                    2365,
+                    2369,
+                    2405,
+                    2465,
+                    2543,
+                    2634,
+                    2732,
+                    2819,
+                    2917,
+                    2985,
+                    3023,
+                    3034,
+                    3104,
+                    3204,
+                    3259,
+                    3346,
+                    3359,
+                    3385,
+                    3386,
+                    3464,
+                    3510,
+                    3604,
+                    3686
+                ]
+            ],
+            "output": 11458
+        },
+        {
+            "input": [
+                [
+                    "M",
+                    "PMGGPGGGMP",
+                    "GGMGPM",
+                    "GMGPPGPGMM",
+                    "MGG",
+                    "PGPP",
+                    "PPPM",
+                    "GPGPG",
+                    "PMMPPPPG",
+                    "MMPGGPP",
+                    "PGGPPMP",
+                    "MM",
+                    "PPPG",
+                    "MPPM",
+                    "G",
+                    "GMMMPGMMPG",
+                    "M",
+                    "P",
+                    "GPPP",
+                    "PMG",
+                    "PMPGGGP",
+                    "M",
+                    "GPGGPMPP",
+                    "GM",
+                    "PGMGPPMP",
+                    "PGGGMGPMG",
+                    "MGPM",
+                    "MMMMGPMPMG",
+                    "MPMPPP",
+                    "MP",
+                    "MMGPMPMMPG",
+                    "MMGPGPPPPM",
+                    "GPMPMG",
+                    "PP",
+                    "MPMG"
+                ],
+                [
+                    41,
+                    138,
+                    207,
+                    212,
+                    289,
+                    333,
+                    409,
+                    475,
+                    574,
+                    659,
+                    696,
+                    760,
+                    808,
+                    872,
+                    972,
+                    1056,
+                    1134,
+                    1222,
+                    1276,
+                    1360,
+                    1452,
+                    1510,
+                    1532,
+                    1592,
+                    1610,
+                    1695,
+                    1717,
+                    1734,
+                    1766,
+                    1859,
+                    1943,
+                    1950,
+                    2047,
+                    2113
+                ]
+            ],
+            "output": 6523
+        },
+        {
+            "input": [
+                [
+                    "GMMMP",
+                    "G",
+                    "GGPGGMGMPG",
+                    "GMMM",
+                    "GGP",
+                    "PMP",
+                    "M",
+                    "GPPGGPP",
+                    "PMGPPMP",
+                    "MMM",
+                    "P",
+                    "MMG",
+                    "GMPGGM",
+                    "P",
+                    "PGGGGPG",
+                    "GPPPPMMPGP",
+                    "PPG",
+                    "PMGP",
+                    "PGMMP",
+                    "GMPG",
+                    "MMP",
+                    "MPMMGMMM",
+                    "PMGGPGP",
+                    "GPPPMP",
+                    "G",
+                    "GGMGP",
+                    "GGMGMGP",
+                    "GGPMP",
+                    "PGMP",
+                    "MGMPMG",
+                    "MPPG",
+                    "PPGPGPMP",
+                    "PM",
+                    "MGPGGG",
+                    "GPPPG",
+                    "GPGPP",
+                    "MGMMPGG",
+                    "MPMGPPM",
+                    "GGMMGMMM",
+                    "MGMPGM",
+                    "GMMMMPP",
+                    "P",
+                    "MP",
+                    "MMPGGPPMP",
+                    "MPP",
+                    "MPMPPGGPM",
+                    "PM",
+                    "P",
+                    "PPMGGP",
+                    "P",
+                    "MPGPGPMM",
+                    "MM",
+                    "G",
+                    "PPGPPMGG",
+                    "MP",
+                    "GMPG",
+                    "MGGGGMMGGP",
+                    "M",
+                    "MPPP",
+                    "GGGMMG",
+                    "PMPM",
+                    "GMPPMGPGG",
+                    "PPMGG",
+                    "MP",
+                    "MGGGPP",
+                    "MMMGMGG",
+                    "MMPMGM",
+                    "P",
+                    "GMPMMMGMP",
+                    "GPPMMMMGMM",
+                    "MPGPPP",
+                    "MMG",
+                    "PPPMP",
+                    "GGMGPMGGMP",
+                    "PMMGGGGGG",
+                    "GGGGGGPGG",
+                    "MMMMPM",
+                    "GPMGPPMMPG",
+                    "G",
+                    "MMGPMM",
+                    "GG",
+                    "PMGMPGMPM",
+                    "MGM",
+                    "PGMPMPGMG",
+                    "M",
+                    "MGPGGGM",
+                    "MGMMPPG",
+                    "GGPPMPGP",
+                    "G",
+                    "GMPM",
+                    "PPPGMMMPP",
+                    "MPMPPPGPP",
+                    "PGP",
+                    "GPGPMGGG",
+                    "GMMMMGGP",
+                    "GMMGPGPM",
+                    "MG",
+                    "M",
+                    "MP"
+                ],
+                [
+                    85,
+                    162,
+                    210,
+                    278,
+                    330,
+                    413,
+                    418,
+                    480,
+                    542,
+                    607,
+                    638,
+                    654,
+                    731,
+                    768,
+                    777,
+                    787,
+                    806,
+                    844,
+                    876,
+                    912,
+                    939,
+                    942,
+                    988,
+                    1085,
+                    1134,
+                    1147,
+                    1240,
+                    1261,
+                    1312,
+                    1362,
+                    1435,
+                    1456,
+                    1477,
+                    1542,
+                    1543,
+                    1559,
+                    1562,
+                    1588,
+                    1648,
+                    1705,
+                    1760,
+                    1764,
+                    1837,
+                    1888,
+                    1951,
+                    1952,
+                    2039,
+                    2077,
+                    2177,
+                    2246,
+                    2249,
+                    2286,
+                    2311,
+                    2314,
+                    2414,
+                    2473,
+                    2545,
+                    2564,
+                    2565,
+                    2665,
+                    2714,
+                    2744,
+                    2841,
+                    2845,
+                    2916,
+                    2974,
+                    3041,
+                    3101,
+                    3141,
+                    3228,
+                    3258,
+                    3299,
+                    3327,
+                    3378,
+                    3445,
+                    3457,
+                    3530,
+                    3629,
+                    3718,
+                    3744,
+                    3781,
+                    3818,
+                    3831,
+                    3841,
+                    3914,
+                    3946,
+                    3964,
+                    4022,
+                    4043,
+                    4112,
+                    4153,
+                    4199,
+                    4240,
+                    4246,
+                    4342,
+                    4380,
+                    4444,
+                    4493
+                ]
+            ],
+            "output": 13876
+        },
+        {
+            "input": [
+                [
+                    "PGGGPGMMMG",
+                    "MGPGPGPP",
+                    "PMMMGMMG",
+                    "PPPGPP",
+                    "PGPMPGGM",
+                    "MPMMGMMPG",
+                    "GPGMPMPP",
+                    "P",
+                    "GM",
+                    "PGGMGPPMP",
+                    "GMPMG",
+                    "P",
+                    "P",
+                    "MGGPGG",
+                    "PMMMPGGPMG",
+                    "MGPPM",
+                    "P",
+                    "PGPMMMMGG",
+                    "PM",
+                    "GGG",
+                    "MP",
+                    "PPGGG",
+                    "PM",
+                    "PGMPMGPGP",
+                    "GGPGGMP",
+                    "GGMGGMGMG",
+                    "PM",
+                    "PG",
+                    "MPG",
+                    "GGPGM"
+                ],
+                [
+                    75,
+                    148,
+                    183,
+                    193,
+                    207,
+                    283,
+                    289,
+                    376,
+                    381,
+                    456,
+                    508,
+                    601,
+                    631,
+                    723,
+                    798,
+                    837,
+                    911,
+                    933,
+                    934,
+                    941,
+                    1028,
+                    1035,
+                    1082,
+                    1131,
+                    1192,
+                    1256,
+                    1301,
+                    1333,
+                    1357
+                ]
+            ],
+            "output": 4229
+        },
+        {
+            "input": [
+                [
+                    "GP",
+                    "GMGPGMMGM",
+                    "PGGP",
+                    "MPMPMPPGMP",
+                    "PGPGMGPMM",
+                    "GPGPPPG",
+                    "MMMPPPPMPM",
+                    "GGMP",
+                    "MPMM",
+                    "GGGMGMM",
+                    "PGPGPMPMG",
+                    "GGMMPPMGPG",
+                    "PMGP",
+                    "GGPGMMG",
+                    "PGGG",
+                    "MGMMM",
+                    "GMGM",
+                    "GGGGMPGMMG",
+                    "PPPGGGG",
+                    "GGP",
+                    "GGP",
+                    "GMG",
+                    "PM",
+                    "PGGMGPPGPM",
+                    "PPPMPPPP",
+                    "MMMMMP",
+                    "MGPMPGPP",
+                    "PP",
+                    "GP",
+                    "MMPMMPPG",
+                    "MMGPGMPMMP",
+                    "GGPMPPGMG",
+                    "GGMM",
+                    "GMPMM",
+                    "GGPPGMGPG",
+                    "PMM",
+                    "GPGGGPMGG",
+                    "MPMGGGGG",
+                    "MMMPMMGMMM",
+                    "PMGPPPMPGP",
+                    "GPPMP",
+                    "GP",
+                    "MGGM",
+                    "PPGMPG",
+                    "GGPGPMP",
+                    "GMMPGPGGP",
+                    "GMMPGPMGP",
+                    "GMGMP",
+                    "PP",
+                    "GPGGPMPM",
+                    "PPPM",
+                    "MPGMGMM",
+                    "GMGMG",
+                    "GPGGMMPPGG",
+                    "PMPGMPPMP",
+                    "PMPMPGGP",
+                    "PPMPGM",
+                    "MGPPM",
+                    "PMMPPPPGP",
+                    "PPGMG",
+                    "PGPPMMGGMM",
+                    "MMG",
+                    "GMGMPGPMPM",
+                    "PMPMM",
+                    "PPPMMGPMP",
+                    "MG"
+                ],
+                [
+                    1,
+                    22,
+                    106,
+                    165,
+                    214,
+                    288,
+                    328,
+                    391,
+                    395,
+                    429,
+                    451,
+                    529,
+                    618,
+                    688,
+                    756,
+                    845,
+                    889,
+                    953,
+                    1006,
+                    1062,
+                    1136,
+                    1138,
+                    1177,
+                    1272,
+                    1341,
+                    1429,
+                    1459,
+                    1462,
+                    1522,
+                    1571,
+                    1582,
+                    1655,
+                    1686,
+                    1702,
+                    1710,
+                    1803,
+                    1898,
+                    1923,
+                    2015,
+                    2049,
+                    2132,
+                    2189,
+                    2214,
+                    2227,
+                    2229,
+                    2263,
+                    2330,
+                    2349,
+                    2399,
+                    2436,
+                    2532,
+                    2620,
+                    2705,
+                    2746,
+                    2842,
+                    2893,
+                    2979,
+                    3031,
+                    3129,
+                    3186,
+                    3283,
+                    3343,
+                    3369,
+                    3391,
+                    3475
+                ]
+            ],
+            "output": 10763
+        },
+        {
+            "input": [
+                [
+                    "PMPMPPP",
+                    "G",
+                    "MPMG",
+                    "GPPMMG",
+                    "GMGPGMMPGM",
+                    "PGP",
+                    "GMGPPGG",
+                    "PPPPGGP",
+                    "MMP",
+                    "GGGMG",
+                    "GGMPMPPGG",
+                    "G",
+                    "MMGM",
+                    "M",
+                    "P",
+                    "GM",
+                    "MMPGGPMPPG",
+                    "GMGPP",
+                    "GPPP",
+                    "PGMM",
+                    "PGMMPMGP",
+                    "GMMMG",
+                    "PPPPMGGM",
+                    "PGMGGPG",
+                    "MGMG",
+                    "MMMMPPMG",
+                    "MMPMPPPGPG",
+                    "MGPG",
+                    "PMGM",
+                    "MG",
+                    "M",
+                    "GG",
+                    "GM",
+                    "GMP"
+                ],
+                [
+                    22,
+                    29,
+                    38,
+                    138,
+                    172,
+                    268,
+                    316,
+                    363,
+                    384,
+                    400,
+                    433,
+                    489,
+                    523,
+                    563,
+                    632,
+                    671,
+                    684,
+                    773,
+                    844,
+                    944,
+                    982,
+                    1028,
+                    1068,
+                    1116,
+                    1166,
+                    1198,
+                    1257,
+                    1298,
+                    1383,
+                    1447,
+                    1467,
+                    1556,
+                    1627
+                ]
+            ],
+            "output": 5043
+        }
+    ],
+    "haskell_template": "garbageCollection :: [String] -> [Int] -> Int\ngarbageCollection garbage travel ",
+    "ocaml_template": "let garbageCollection (garbage: string list) (travel: int list) : int =  ",
+    "scala_template": "def garbageCollection(garbage: List[String],travel: List[Int]): Int = { \n    \n}",
+    "java_template": "public static int garbageCollection(List<String> garbage, List<Integer> travel) {\n\n}",
+    "python_template": "class Solution(object):\n    def garbageCollection(self, garbage, travel):\n        \"\"\"\n        :type garbage: List[str]\n        :type travel: List[int]\n        :rtype: int\n        \"\"\"\n        "
+}

minimum_amount_of_time_to_collect_garbage/ocaml_tests/main.ml

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

minimum_amount_of_time_to_collect_garbage/scala_tests/MySuite.scala

@@ -0,0 +1,12 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.garbageCollection(List("G","P","GP","GG"),List(2,4,3)), 21)
+  }
+
+  test("test2") {
+    assertEquals(Main.garbageCollection(List("MMM","PGM","GP"),List(3,10)), 37)
+  }
+
+}

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

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

minimum_amount_of_time_to_fill_cups/meta.json

@@ -0,0 +1,112 @@
+{
+    "id": 2412,
+    "name": "minimum_amount_of_time_to_fill_cups",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/minimum-amount-of-time-to-fill-cups/",
+    "date": "1656806400000",
+    "task_description": "You have a water dispenser that can dispense cold, warm, and hot water. Every second, you can either fill up `2` cups with **different** types of water, or `1` cup of any type of water. You are given a **0-indexed** integer array `amount` of length `3` where `amount[0]`, `amount[1]`, and `amount[2]` denote the number of cold, warm, and hot water cups you need to fill respectively. Return _the **minimum** number of seconds needed to fill up all the cups_. **Example 1:** ``` **Input:** amount = [1,4,2] **Output:** 4 **Explanation:** One way to fill up the cups is: Second 1: Fill up a cold cup and a warm cup. Second 2: Fill up a warm cup and a hot cup. Second 3: Fill up a warm cup and a hot cup. Second 4: Fill up a warm cup. It can be proven that 4 is the minimum number of seconds needed. ``` **Example 2:** ``` **Input:** amount = [5,4,4] **Output:** 7 **Explanation:** One way to fill up the cups is: Second 1: Fill up a cold cup, and a hot cup. Second 2: Fill up a cold cup, and a warm cup. Second 3: Fill up a cold cup, and a warm cup. Second 4: Fill up a warm cup, and a hot cup. Second 5: Fill up a cold cup, and a hot cup. Second 6: Fill up a cold cup, and a warm cup. Second 7: Fill up a hot cup. ``` **Example 3:** ``` **Input:** amount = [5,0,0] **Output:** 5 **Explanation:** Every second, we fill up a cold cup. ``` **Constraints:** `amount.length == 3` `0 <= amount[i] <= 100`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "amount = [1,4,2]",
+            "output": "4 "
+        },
+        {
+            "label": "Example 2",
+            "input": "amount = [5,4,4]",
+            "output": "7 "
+        },
+        {
+            "label": "Example 3",
+            "input": "amount = [5,0,0]",
+            "output": "5 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                0,
+                0,
+                0
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                100,
+                0,
+                0
+            ],
+            "output": 100
+        },
+        {
+            "input": [
+                60,
+                0,
+                0
+            ],
+            "output": 60
+        },
+        {
+            "input": [
+                10,
+                10,
+                10
+            ],
+            "output": 15
+        },
+        {
+            "input": [
+                20,
+                54,
+                0
+            ],
+            "output": 54
+        },
+        {
+            "input": [
+                0,
+                100,
+                100
+            ],
+            "output": 100
+        },
+        {
+            "input": [
+                86,
+                54,
+                62
+            ],
+            "output": 101
+        },
+        {
+            "input": [
+                37,
+                43,
+                34
+            ],
+            "output": 57
+        },
+        {
+            "input": [
+                49,
+                51,
+                7
+            ],
+            "output": 54
+        },
+        {
+            "input": [
+                19,
+                61,
+                9
+            ],
+            "output": 61
+        }
+    ],
+    "haskell_template": "fillCups :: [Int] -> Int\nfillCups amount ",
+    "ocaml_template": "let fillCups (amount: int list) : int =  ",
+    "scala_template": "def fillCups(amount: List[Int]): Int = { \n    \n}",
+    "java_template": "public static int fillCups(List<Integer> amount) {\n\n}",
+    "python_template": "class Solution(object):\n    def fillCups(self, amount):\n        \"\"\"\n        :type amount: List[int]\n        :rtype: int\n        \"\"\"\n        "
+}

minimum_amount_of_time_to_fill_cups/ocaml_tests/main.ml

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

minimum_amount_of_time_to_fill_cups/scala_tests/MySuite.scala

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

minimum_array_end/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 (minEnd 3 4)," 6 (minEnd 3 4))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (minEnd 2 7)," 15 (minEnd 2 7))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (minEnd 1 72)," 72 (minEnd 1 72))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (minEnd 3 2)," 6 (minEnd 3 2))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (minEnd 4 42)," 47 (minEnd 4 42))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (minEnd 2 80)," 81 (minEnd 2 80))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (minEnd 9 85)," 213 (minEnd 9 85))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (minEnd 7 63)," 447 (minEnd 7 63))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (minEnd 2 72)," 73 (minEnd 2 72))
+
+
+-- 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_array_end/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, minEnd(3, 4));
+}
+@Test
+public void test2() {
+    assertEquals(15, minEnd(2, 7));
+}
+
+}

minimum_array_end/meta.json

@@ -0,0 +1,97 @@
+{
+    "id": 3394,
+    "name": "minimum_array_end",
+    "difficulty": "Medium",
+    "link": "https://leetcode.com/problems/minimum-array-end/",
+    "date": "2024-04-21 00:00:00",
+    "task_description": "You are given two integers `n` and `x`. You have to construct an array of **positive** integers `nums` of size `n` where for every `0 <= i < n - 1`, `nums[i + 1]` is **greater than** `nums[i]`, and the result of the bitwise `AND` operation between all elements of `nums` is `x`. Return the **minimum** possible value of `nums[n - 1]`. **Example 1:** **Input:** n = 3, x = 4 **Output:** 6 **Explanation:** `nums` can be `[4,5,6]` and its last element is 6. **Example 2:** **Input:** n = 2, x = 7 **Output:** 15 **Explanation:** `nums` can be `[7,15]` and its last element is 15. **Constraints:** `1 <= n, x <= 108`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "n = 3, x = 4",
+            "output": "6 "
+        },
+        {
+            "label": "Example 2",
+            "input": "n = 2, x = 7",
+            "output": "15 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                1,
+                72
+            ],
+            "output": 72
+        },
+        {
+            "input": [
+                3,
+                2
+            ],
+            "output": 6
+        },
+        {
+            "input": [
+                4,
+                42
+            ],
+            "output": 47
+        },
+        {
+            "input": [
+                2,
+                80
+            ],
+            "output": 81
+        },
+        {
+            "input": [
+                9,
+                85
+            ],
+            "output": 213
+        },
+        {
+            "input": [
+                7,
+                63
+            ],
+            "output": 447
+        },
+        {
+            "input": [
+                2,
+                72
+            ],
+            "output": 73
+        },
+        {
+            "input": [
+                5,
+                93
+            ],
+            "output": 221
+        },
+        {
+            "input": [
+                3,
+                37
+            ],
+            "output": 45
+        },
+        {
+            "input": [
+                4,
+                6
+            ],
+            "output": 15
+        }
+    ],
+    "haskell_template": "minEnd :: Int -> Int -> Int\nminEnd n x ",
+    "ocaml_template": "let minEnd (n: int) (x: int) : int =  ",
+    "scala_template": "def minEnd(n: Int,x: Int): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public long minEnd(int n, int x) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def minEnd(self, n, x):\n        \"\"\"\n        :type n: int\n        :type x: int\n        :rtype: int\n        \"\"\"\n        "
+}

minimum_array_end/ocaml_tests/main.ml

@@ -0,0 +1,50 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 6 (minEnd 3 4)
+
+let test2 _ = assert_equal 15 (minEnd 2 7)
+
+let test3 _ = assert_equal 72 (minEnd 1 72)
+
+let test4 _ = assert_equal 6 (minEnd 3 2)
+
+let test5 _ = assert_equal 47 (minEnd 4 42)
+
+let test6 _ = assert_equal 81 (minEnd 2 80)
+
+let test7 _ = assert_equal 213 (minEnd 9 85)
+
+let test8 _ = assert_equal 447 (minEnd 7 63)
+
+let test9 _ = assert_equal 73 (minEnd 2 72)
+
+let test10 _ = assert_equal 221 (minEnd 5 93)
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for minEnd" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+  "test3" >:: test3;
+  "test4" >:: test4;
+  "test5" >:: test5;
+  "test6" >:: test6;
+  "test7" >:: test7;
+  "test8" >:: test8;
+  "test9" >:: test9;
+  "test10" >:: test10;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

minimum_array_end/scala_tests/MySuite.scala

@@ -0,0 +1,44 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.minEnd(3,4), 6)
+  }
+
+  test("test2") {
+    assertEquals(Main.minEnd(2,7), 15)
+  }
+
+  test("test3") {
+    assertEquals(Main.minEnd(1,72), 72)
+  }
+
+  test("test4") {
+    assertEquals(Main.minEnd(3,2), 6)
+  }
+
+  test("test5") {
+    assertEquals(Main.minEnd(4,42), 47)
+  }
+
+  test("test6") {
+    assertEquals(Main.minEnd(2,80), 81)
+  }
+
+  test("test7") {
+    assertEquals(Main.minEnd(9,85), 213)
+  }
+
+  test("test8") {
+    assertEquals(Main.minEnd(7,63), 447)
+  }
+
+  test("test9") {
+    assertEquals(Main.minEnd(2,72), 73)
+  }
+
+  test("test10") {
+    assertEquals(Main.minEnd(5,93), 221)
+  }
+
+}

minimum_array_length_after_pair_removals/java_tests/Main.java

@@ -0,0 +1,28 @@
+
+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(0, minLengthAfterRemovals(Arrays.asList(1,2,3,4)));
+}
+@Test
+public void test2() {
+    assertEquals(0, minLengthAfterRemovals(Arrays.asList(1,1,2,2,3,3)));
+}
+@Test
+public void test3() {
+    assertEquals(2, minLengthAfterRemovals(Arrays.asList(1000000000,1000000000)));
+}
+@Test
+public void test4() {
+    assertEquals(1, minLengthAfterRemovals(Arrays.asList(2,3,4,4,4)));
+}
+
+}

minimum_array_length_after_pair_removals/meta.json

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

minimum_array_sum/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 (minArraySum [2,8,3,19,3] 3 1 1)," 23 (minArraySum [2,8,3,19,3] 3 1 1))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (minArraySum [2,4,3] 3 2 1)," 3 (minArraySum [2,4,3] 3 2 1))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (minArraySum [0, 6, 8, 16, 17, 13, 17, 18, 20, 20, 20, 21, 34, 35, 5, 6, 12, 16, 16, 16] 73 11 11)," 316 (minArraySum [0, 6, 8, 16, 17, 13, 17, 18, 20, 20, 20, 21, 34, 35, 5, 6, 12, 16, 16, 16] 73 11 11))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (minArraySum [2, 3, 6, 8, 8, 8, 9, 10, 13, 14, 15, 16, 16, 18, 19, 22, 23, 24, 25, 27, 27, 27, 27, 28, 30, 35, 35, 37, 37, 38, 39, 44, 46, 23, 24, 24, 25, 25, 26, 28, 28, 28, 28, 29, 29, 29, 29, 30, 31, 31, 33, 34, 34, 34, 35, 35, 36, 36, 38, 39, 39, 42, 43, 1, 2, 2, 4, 5, 7, 8, 8, 12, 12, 14, 17, 18, 18] 87 30 57)," 1809 (minArraySum [2, 3, 6, 8, 8, 8, 9, 10, 13, 14, 15, 16, 16, 18, 19, 22, 23, 24, 25, 27, 27, 27, 27, 28, 30, 35, 35, 37, 37, 38, 39, 44, 46, 23, 24, 24, 25, 25, 26, 28, 28, 28, 28, 29, 29, 29, 29, 30, 31, 31, 33, 34, 34, 34, 35, 35, 36, 36, 38, 39, 39, 42, 43, 1, 2, 2, 4, 5, 7, 8, 8, 12, 12, 14, 17, 18, 18] 87 30 57))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (minArraySum [0, 0, 0, 1, 3, 3, 4, 5, 5, 7, 10, 11, 12, 14, 15, 17, 18, 9, 10, 10, 12, 14, 14, 15, 15, 16, 16, 16, 17, 17, 18, 19, 1, 1, 2, 3, 22, 23, 23, 24, 24, 24, 24, 25, 25, 26, 27, 27, 29, 29, 31, 31, 31, 31, 33, 33, 33, 34, 34, 36, 37, 37, 38, 38, 38, 39, 39, 39, 0, 0, 1, 2, 3, 3, 3, 3, 3, 4, 4, 5, 5, 5, 6, 6, 6, 6, 7, 7, 9, 10, 10, 10, 11, 11, 12, 12, 12] 40 76 33)," 1510 (minArraySum [0, 0, 0, 1, 3, 3, 4, 5, 5, 7, 10, 11, 12, 14, 15, 17, 18, 9, 10, 10, 12, 14, 14, 15, 15, 16, 16, 16, 17, 17, 18, 19, 1, 1, 2, 3, 22, 23, 23, 24, 24, 24, 24, 25, 25, 26, 27, 27, 29, 29, 31, 31, 31, 31, 33, 33, 33, 34, 34, 36, 37, 37, 38, 38, 38, 39, 39, 39, 0, 0, 1, 2, 3, 3, 3, 3, 3, 4, 4, 5, 5, 5, 6, 6, 6, 6, 7, 7, 9, 10, 10, 10, 11, 11, 12, 12, 12] 40 76 33))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (minArraySum [5, 5, 4, 5, 7, 8, 9, 12, 13, 14, 16, 18, 19, 19, 22, 23, 24, 24, 26, 27, 28, 28, 29, 30, 34, 36, 37, 37, 41, 42, 42, 45, 46, 48, 3, 3, 4, 4] 98 35 10)," 837 (minArraySum [5, 5, 4, 5, 7, 8, 9, 12, 13, 14, 16, 18, 19, 19, 22, 23, 24, 24, 26, 27, 28, 28, 29, 30, 34, 36, 37, 37, 41, 42, 42, 45, 46, 48, 3, 3, 4, 4] 98 35 10))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (minArraySum [4, 13, 14, 17, 18, 21, 24, 25, 1, 2, 4, 7, 37, 37, 41, 43, 43, 53, 54, 60, 63, 69, 76, 77, 81, 84, 84, 85, 85, 87, 89, 89, 92, 96, 96] 26 0 4)," 1771 (minArraySum [4, 13, 14, 17, 18, 21, 24, 25, 1, 2, 4, 7, 37, 37, 41, 43, 43, 53, 54, 60, 63, 69, 76, 77, 81, 84, 84, 85, 85, 87, 89, 89, 92, 96, 96] 26 0 4))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (minArraySum [16, 33, 83, 90, 101] 12 0 2)," 323 (minArraySum [16, 33, 83, 90, 101] 12 0 2))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (minArraySum [2, 3, 3, 7, 8, 8, 8, 10, 7, 7, 8, 8, 12, 14, 15, 15, 16, 17, 21, 23, 25, 26, 26, 27, 28, 28, 28, 28, 28, 29, 31, 31, 35, 36, 37, 37, 37, 41, 41, 42, 42, 42, 45, 47, 48, 49, 51, 22, 22, 23] 30 42 3)," 1244 (minArraySum [2, 3, 3, 7, 8, 8, 8, 10, 7, 7, 8, 8, 12, 14, 15, 15, 16, 17, 21, 23, 25, 26, 26, 27, 28, 28, 28, 28, 28, 29, 31, 31, 35, 36, 37, 37, 37, 41, 41, 42, 42, 42, 45, 47, 48, 49, 51, 22, 22, 23] 30 42 3))
+
+
+-- 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_array_sum/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(23, minArraySum(new ArrayList<>(Arrays.asList(2,8,3,19,3)), 3, 1, 1));
+}
+@Test
+public void test2() {
+    assertEquals(3, minArraySum(new ArrayList<>(Arrays.asList(2,4,3)), 3, 2, 1));
+}
+
+}

minimum_array_sum/meta.json

@@ -0,0 +1,596 @@
+{
+    "id": 3654,
+    "name": "minimum_array_sum",
+    "difficulty": "Medium",
+    "link": "https://leetcode.com/problems/minimum-array-sum/",
+    "date": "2024-11-17 00:00:00",
+    "task_description": "You are given an integer array `nums` and three integers `k`, `op1`, and `op2`. You can perform the following operations on `nums`: **Operation 1**: Choose an index `i` and divide `nums[i]` by 2, **rounding up** to the nearest whole number. You can perform this operation at most `op1` times, and not more than **once** per index. **Operation 2**: Choose an index `i` and subtract `k` from `nums[i]`, but only if `nums[i]` is greater than or equal to `k`. You can perform this operation at most `op2` times, and not more than **once** per index. **Note:** Both operations can be applied to the same index, but at most once each. Return the **minimum** possible **sum** of all elements in `nums` after performing any number of operations. **Example 1:** **Input:** nums = [2,8,3,19,3], k = 3, op1 = 1, op2 = 1 **Output:** 23 **Explanation:** Apply Operation 2 to `nums[1] = 8`, making `nums[1] = 5`. Apply Operation 1 to `nums[3] = 19`, making `nums[3] = 10`. The resulting array becomes `[2, 5, 3, 10, 3]`, which has the minimum possible sum of 23 after applying the operations. **Example 2:** **Input:** nums = [2,4,3], k = 3, op1 = 2, op2 = 1 **Output:** 3 **Explanation:** Apply Operation 1 to `nums[0] = 2`, making `nums[0] = 1`. Apply Operation 1 to `nums[1] = 4`, making `nums[1] = 2`. Apply Operation 2 to `nums[2] = 3`, making `nums[2] = 0`. The resulting array becomes `[1, 2, 0]`, which has the minimum possible sum of 3 after applying the operations. **Constraints:** `1 <= nums.length <= 100` `0 <= nums[i] <= 105` `0 <= k <= 105` `0 <= op1, op2 <= nums.length`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "nums = [2,8,3,19,3], k = 3, op1 = 1, op2 = 1",
+            "output": "23 "
+        },
+        {
+            "label": "Example 2",
+            "input": "nums = [2,4,3], k = 3, op1 = 2, op2 = 1",
+            "output": "3 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                [
+                    0,
+                    6,
+                    8,
+                    16,
+                    17,
+                    13,
+                    17,
+                    18,
+                    20,
+                    20,
+                    20,
+                    21,
+                    34,
+                    35,
+                    5,
+                    6,
+                    12,
+                    16,
+                    16,
+                    16
+                ],
+                73,
+                11,
+                11
+            ],
+            "output": 316
+        },
+        {
+            "input": [
+                [
+                    2,
+                    3,
+                    6,
+                    8,
+                    8,
+                    8,
+                    9,
+                    10,
+                    13,
+                    14,
+                    15,
+                    16,
+                    16,
+                    18,
+                    19,
+                    22,
+                    23,
+                    24,
+                    25,
+                    27,
+                    27,
+                    27,
+                    27,
+                    28,
+                    30,
+                    35,
+                    35,
+                    37,
+                    37,
+                    38,
+                    39,
+                    44,
+                    46,
+                    23,
+                    24,
+                    24,
+                    25,
+                    25,
+                    26,
+                    28,
+                    28,
+                    28,
+                    28,
+                    29,
+                    29,
+                    29,
+                    29,
+                    30,
+                    31,
+                    31,
+                    33,
+                    34,
+                    34,
+                    34,
+                    35,
+                    35,
+                    36,
+                    36,
+                    38,
+                    39,
+                    39,
+                    42,
+                    43,
+                    1,
+                    2,
+                    2,
+                    4,
+                    5,
+                    7,
+                    8,
+                    8,
+                    12,
+                    12,
+                    14,
+                    17,
+                    18,
+                    18
+                ],
+                87,
+                30,
+                57
+            ],
+            "output": 1809
+        },
+        {
+            "input": [
+                [
+                    0,
+                    0,
+                    0,
+                    1,
+                    3,
+                    3,
+                    4,
+                    5,
+                    5,
+                    7,
+                    10,
+                    11,
+                    12,
+                    14,
+                    15,
+                    17,
+                    18,
+                    9,
+                    10,
+                    10,
+                    12,
+                    14,
+                    14,
+                    15,
+                    15,
+                    16,
+                    16,
+                    16,
+                    17,
+                    17,
+                    18,
+                    19,
+                    1,
+                    1,
+                    2,
+                    3,
+                    22,
+                    23,
+                    23,
+                    24,
+                    24,
+                    24,
+                    24,
+                    25,
+                    25,
+                    26,
+                    27,
+                    27,
+                    29,
+                    29,
+                    31,
+                    31,
+                    31,
+                    31,
+                    33,
+                    33,
+                    33,
+                    34,
+                    34,
+                    36,
+                    37,
+                    37,
+                    38,
+                    38,
+                    38,
+                    39,
+                    39,
+                    39,
+                    0,
+                    0,
+                    1,
+                    2,
+                    3,
+                    3,
+                    3,
+                    3,
+                    3,
+                    4,
+                    4,
+                    5,
+                    5,
+                    5,
+                    6,
+                    6,
+                    6,
+                    6,
+                    7,
+                    7,
+                    9,
+                    10,
+                    10,
+                    10,
+                    11,
+                    11,
+                    12,
+                    12,
+                    12
+                ],
+                40,
+                76,
+                33
+            ],
+            "output": 1510
+        },
+        {
+            "input": [
+                [
+                    5,
+                    5,
+                    4,
+                    5,
+                    7,
+                    8,
+                    9,
+                    12,
+                    13,
+                    14,
+                    16,
+                    18,
+                    19,
+                    19,
+                    22,
+                    23,
+                    24,
+                    24,
+                    26,
+                    27,
+                    28,
+                    28,
+                    29,
+                    30,
+                    34,
+                    36,
+                    37,
+                    37,
+                    41,
+                    42,
+                    42,
+                    45,
+                    46,
+                    48,
+                    3,
+                    3,
+                    4,
+                    4
+                ],
+                98,
+                35,
+                10
+            ],
+            "output": 837
+        },
+        {
+            "input": [
+                [
+                    4,
+                    13,
+                    14,
+                    17,
+                    18,
+                    21,
+                    24,
+                    25,
+                    1,
+                    2,
+                    4,
+                    7,
+                    37,
+                    37,
+                    41,
+                    43,
+                    43,
+                    53,
+                    54,
+                    60,
+                    63,
+                    69,
+                    76,
+                    77,
+                    81,
+                    84,
+                    84,
+                    85,
+                    85,
+                    87,
+                    89,
+                    89,
+                    92,
+                    96,
+                    96
+                ],
+                26,
+                0,
+                4
+            ],
+            "output": 1771
+        },
+        {
+            "input": [
+                [
+                    16,
+                    33,
+                    83,
+                    90,
+                    101
+                ],
+                12,
+                0,
+                2
+            ],
+            "output": 323
+        },
+        {
+            "input": [
+                [
+                    2,
+                    3,
+                    3,
+                    7,
+                    8,
+                    8,
+                    8,
+                    10,
+                    7,
+                    7,
+                    8,
+                    8,
+                    12,
+                    14,
+                    15,
+                    15,
+                    16,
+                    17,
+                    21,
+                    23,
+                    25,
+                    26,
+                    26,
+                    27,
+                    28,
+                    28,
+                    28,
+                    28,
+                    28,
+                    29,
+                    31,
+                    31,
+                    35,
+                    36,
+                    37,
+                    37,
+                    37,
+                    41,
+                    41,
+                    42,
+                    42,
+                    42,
+                    45,
+                    47,
+                    48,
+                    49,
+                    51,
+                    22,
+                    22,
+                    23
+                ],
+                30,
+                42,
+                3
+            ],
+            "output": 1244
+        },
+        {
+            "input": [
+                [
+                    2,
+                    3,
+                    4,
+                    5,
+                    6,
+                    6,
+                    7,
+                    8,
+                    8,
+                    8,
+                    9,
+                    10,
+                    12,
+                    12,
+                    13,
+                    13,
+                    13,
+                    15,
+                    16,
+                    17,
+                    17,
+                    0,
+                    1,
+                    2,
+                    2,
+                    5,
+                    6,
+                    7,
+                    8,
+                    9,
+                    9,
+                    10,
+                    10,
+                    11,
+                    11,
+                    11,
+                    12,
+                    13,
+                    15,
+                    16,
+                    17,
+                    0,
+                    0,
+                    2,
+                    2,
+                    2,
+                    2,
+                    3,
+                    4,
+                    6,
+                    7,
+                    8,
+                    8,
+                    10,
+                    10,
+                    11,
+                    12,
+                    12,
+                    13,
+                    14,
+                    16,
+                    16,
+                    16
+                ],
+                35,
+                62,
+                43
+            ],
+            "output": 553
+        },
+        {
+            "input": [
+                [
+                    0,
+                    2,
+                    6,
+                    6,
+                    9,
+                    13,
+                    14,
+                    24,
+                    4,
+                    6,
+                    7,
+                    7,
+                    11,
+                    12,
+                    14,
+                    15,
+                    18,
+                    19,
+                    22,
+                    23,
+                    23,
+                    24,
+                    25,
+                    26,
+                    30,
+                    30,
+                    31,
+                    34,
+                    36,
+                    37,
+                    39,
+                    43,
+                    43,
+                    44,
+                    45
+                ],
+                8,
+                27,
+                32
+            ],
+            "output": 742
+        },
+        {
+            "input": [
+                [
+                    0,
+                    1,
+                    2,
+                    2,
+                    6,
+                    7,
+                    7,
+                    9,
+                    12,
+                    19,
+                    19,
+                    21,
+                    23,
+                    25,
+                    29,
+                    31,
+                    31,
+                    34,
+                    19,
+                    19,
+                    20,
+                    21,
+                    21,
+                    22,
+                    23,
+                    1,
+                    6,
+                    8,
+                    10,
+                    14,
+                    18,
+                    19,
+                    34,
+                    35,
+                    35,
+                    36,
+                    36,
+                    39,
+                    40,
+                    41,
+                    41,
+                    44,
+                    44,
+                    44,
+                    45,
+                    0,
+                    1,
+                    4,
+                    6
+                ],
+                47,
+                24,
+                11
+            ],
+            "output": 1024
+        }
+    ],
+    "haskell_template": "minArraySum :: [Int] -> Int -> Int -> Int -> Int\nminArraySum nums k op1 op2 ",
+    "ocaml_template": "let minArraySum (nums: int list) (k: int) (op1: int) (op2: int) : int =  ",
+    "scala_template": "def minArraySum(nums: List[Int],k: Int,op1: Int,op2: Int): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public int minArraySum(int[] nums, int k, int op1, int op2) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def minArraySum(self, nums, k, op1, op2):\n        \"\"\"\n        :type nums: List[int]\n        :type k: int\n        :type op1: int\n        :type op2: int\n        :rtype: int\n        \"\"\"\n        "
+}