626394dcaf3d5457e1a7f327907aa2c9c0bb93b638a2bdf566a3b653816c095e

.gitattributes

@@ -242,3 +242,7 @@ minimum_rounds_to_complete_all_tasks/meta.json filter=lfs diff=lfs merge=lfs -te
 minimum_score_of_a_path_between_two_cities/meta.json filter=lfs diff=lfs merge=lfs -text
 minimum_seconds_to_equalize_a_circular_array/meta.json filter=lfs diff=lfs merge=lfs -text
 minimum_size_subarray_in_infinite_array/meta.json filter=lfs diff=lfs merge=lfs -text
+minimum_sum_of_squared_difference/meta.json filter=lfs diff=lfs merge=lfs -text
+minimum_swaps_to_group_all_1s_together_ii/meta.json filter=lfs diff=lfs merge=lfs -text
+minimum_time_to_complete_trips/meta.json filter=lfs diff=lfs merge=lfs -text
+minimum_time_to_finish_the_race/meta.json filter=lfs diff=lfs merge=lfs -text

minimum_sum_of_mountain_triplets_i/java_tests/Main.java

@@ -0,0 +1,24 @@
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+import java.util.List;
+import java.util.Arrays;
+public class Main {
+    //Program start
+
+    //Program end
+
+    @Test
+public void test1() {
+    assertEquals(9, minimumSum(Arrays.asList(8,6,1,5,3)));
+}
+@Test
+public void test2() {
+    assertEquals(13, minimumSum(Arrays.asList(5,4,8,7,10,2)));
+}
+@Test
+public void test3() {
+    assertEquals(-1, minimumSum(Arrays.asList(6,5,4,3,4,5)));
+}
+
+}

minimum_sum_of_mountain_triplets_i/meta.json

@@ -0,0 +1,371 @@
+{
+    "id": 3176,
+    "name": "minimum_sum_of_mountain_triplets_i",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/minimum-sum-of-mountain-triplets-i/",
+    "date": "2023-10-15 00:00:00",
+    "task_description": "You are given a **0-indexed** array `nums` of integers. A triplet of indices `(i, j, k)` is a **mountain** if: `i < j < k` `nums[i] < nums[j]` and `nums[k] < nums[j]` Return _the **minimum possible sum** of a mountain triplet of_ `nums`. _If no such triplet exists, return_ `-1`. **Example 1:** ``` **Input:** nums = [8,6,1,5,3] **Output:** 9 **Explanation:** Triplet (2, 3, 4) is a mountain triplet of sum 9 since: - 2 < 3 < 4 - nums[2] < nums[3] and nums[4] < nums[3] And the sum of this triplet is nums[2] + nums[3] + nums[4] = 9. It can be shown that there are no mountain triplets with a sum of less than 9. ``` **Example 2:** ``` **Input:** nums = [5,4,8,7,10,2] **Output:** 13 **Explanation:** Triplet (1, 3, 5) is a mountain triplet of sum 13 since: - 1 < 3 < 5 - nums[1] < nums[3] and nums[5] < nums[3] And the sum of this triplet is nums[1] + nums[3] + nums[5] = 13. It can be shown that there are no mountain triplets with a sum of less than 13. ``` **Example 3:** ``` **Input:** nums = [6,5,4,3,4,5] **Output:** -1 **Explanation:** It can be shown that there are no mountain triplets in nums. ``` **Constraints:** `3 <= nums.length <= 50` `1 <= nums[i] <= 50`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "nums = [8,6,1,5,3]",
+            "output": "9 "
+        },
+        {
+            "label": "Example 2",
+            "input": "nums = [5,4,8,7,10,2]",
+            "output": "13 "
+        },
+        {
+            "label": "Example 3",
+            "input": "nums = [6,5,4,3,4,5]",
+            "output": "-1 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                7,
+                5,
+                14,
+                12,
+                17,
+                16,
+                49,
+                41,
+                11,
+                47,
+                40,
+                27,
+                33,
+                10,
+                22,
+                48,
+                16,
+                43,
+                33,
+                23,
+                35,
+                46,
+                9,
+                31,
+                5,
+                19,
+                1,
+                44,
+                50,
+                4,
+                20,
+                20,
+                14,
+                4,
+                11,
+                47,
+                27
+            ],
+            "output": 15
+        },
+        {
+            "input": [
+                30,
+                14,
+                27,
+                36,
+                34,
+                37,
+                37,
+                33,
+                25,
+                45,
+                40,
+                3,
+                35,
+                49,
+                24,
+                47,
+                17,
+                45,
+                16,
+                44,
+                32,
+                40,
+                45,
+                42,
+                22,
+                34,
+                46,
+                5,
+                14,
+                21,
+                42,
+                18,
+                4,
+                43,
+                8,
+                38,
+                24,
+                1,
+                41,
+                31,
+                34,
+                45
+            ],
+            "output": 8
+        },
+        {
+            "input": [
+                50,
+                27,
+                45,
+                23,
+                25,
+                19,
+                22,
+                8,
+                21,
+                30,
+                16,
+                15,
+                37,
+                36,
+                22,
+                29,
+                34,
+                4,
+                13,
+                44,
+                30,
+                24,
+                19
+            ],
+            "output": 27
+        },
+        {
+            "input": [
+                6,
+                48,
+                48,
+                13,
+                27,
+                13,
+                18,
+                25,
+                22,
+                39,
+                42,
+                49,
+                8,
+                1,
+                46,
+                5,
+                11,
+                33,
+                16
+            ],
+            "output": 15
+        },
+        {
+            "input": [
+                14,
+                42,
+                6,
+                21,
+                33,
+                25,
+                44,
+                48,
+                33,
+                18,
+                16,
+                21,
+                46,
+                43,
+                11,
+                34,
+                23,
+                36,
+                36,
+                5,
+                25,
+                31,
+                32,
+                4,
+                39,
+                27,
+                35,
+                32,
+                5,
+                42,
+                45,
+                8,
+                47,
+                47,
+                2,
+                6,
+                15,
+                19,
+                43,
+                22,
+                34,
+                44,
+                24,
+                2,
+                12,
+                41,
+                39,
+                50
+            ],
+            "output": 10
+        },
+        {
+            "input": [
+                39,
+                31,
+                2,
+                22,
+                5,
+                36,
+                34,
+                47,
+                50
+            ],
+            "output": 29
+        },
+        {
+            "input": [
+                26,
+                26,
+                11,
+                27,
+                13,
+                22,
+                8,
+                31,
+                1,
+                12,
+                31,
+                31,
+                6,
+                16,
+                37,
+                46,
+                2,
+                27,
+                30,
+                7
+            ],
+            "output": 9
+        },
+        {
+            "input": [
+                2,
+                13,
+                36,
+                22,
+                7,
+                41,
+                4,
+                20,
+                33,
+                27,
+                7,
+                17,
+                15,
+                44,
+                17,
+                26,
+                35,
+                13,
+                7,
+                50,
+                10,
+                41,
+                38,
+                33,
+                43,
+                34,
+                5,
+                23,
+                7,
+                35,
+                10,
+                42,
+                46,
+                7,
+                8,
+                8,
+                11,
+                6,
+                8,
+                22
+            ],
+            "output": 13
+        },
+        {
+            "input": [
+                46,
+                45,
+                46,
+                41,
+                34,
+                23,
+                46,
+                1,
+                8,
+                48,
+                26,
+                3,
+                49,
+                43,
+                42,
+                16,
+                1,
+                22,
+                5,
+                14,
+                24,
+                41,
+                39,
+                36,
+                20,
+                30,
+                1,
+                8,
+                50,
+                37,
+                12,
+                41,
+                26,
+                1,
+                20
+            ],
+            "output": 5
+        },
+        {
+            "input": [
+                32,
+                29,
+                21,
+                3,
+                44,
+                28,
+                9,
+                9,
+                34,
+                50,
+                34,
+                39,
+                25,
+                38,
+                43,
+                48
+            ],
+            "output": 40
+        }
+    ],
+    "haskell_template": "minimumSum :: [Int] -> Int\nminimumSum nums ",
+    "ocaml_template": "let minimumSum (nums: int list) : int =  ",
+    "scala_template": "def minimumSum(nums: List[Int]): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public int minimumSum(int[] nums) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def minimumSum(self, nums):\n        \"\"\"\n        :type nums: List[int]\n        :rtype: int\n        \"\"\"\n        "
+}

minimum_sum_of_mountain_triplets_i/ocaml_tests/main.ml

@@ -0,0 +1,51 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+    let minimumSum (nums: int list) : int =   failwith "Not implemented"
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 9 (minimumSum [8;6;1;5;3])
+
+let test2 _ = assert_equal 13 (minimumSum [5;4;8;7;10;2])
+
+let test3 _ = assert_equal (-1) (minimumSum [6;5;4;3;4;5])
+
+let test4 _ = assert_equal (-1) (minimumSum [7; 5; 14; 12; 17; 16; 49; 41; 11; 47; 40; 27; 33; 10; 22; 48; 16; 43; 33; 23; 35; 46; 9; 31; 5; 19; 1; 44; 50; 4; 20; 20; 14; 4; 11; 47; 27])
+
+let test5 _ = assert_equal (-1) (minimumSum [30; 14; 27; 36; 34; 37; 37; 33; 25; 45; 40; 3; 35; 49; 24; 47; 17; 45; 16; 44; 32; 40; 45; 42; 22; 34; 46; 5; 14; 21; 42; 18; 4; 43; 8; 38; 24; 1; 41; 31; 34; 45])
+
+let test6 _ = assert_equal (-1) (minimumSum [50; 27; 45; 23; 25; 19; 22; 8; 21; 30; 16; 15; 37; 36; 22; 29; 34; 4; 13; 44; 30; 24; 19])
+
+let test7 _ = assert_equal (-1) (minimumSum [6; 48; 48; 13; 27; 13; 18; 25; 22; 39; 42; 49; 8; 1; 46; 5; 11; 33; 16])
+
+let test8 _ = assert_equal (-1) (minimumSum [14; 42; 6; 21; 33; 25; 44; 48; 33; 18; 16; 21; 46; 43; 11; 34; 23; 36; 36; 5; 25; 31; 32; 4; 39; 27; 35; 32; 5; 42; 45; 8; 47; 47; 2; 6; 15; 19; 43; 22; 34; 44; 24; 2; 12; 41; 39; 50])
+
+let test9 _ = assert_equal (-1) (minimumSum [39; 31; 2; 22; 5; 36; 34; 47; 50])
+
+let test10 _ = assert_equal (-1) (minimumSum [26; 26; 11; 27; 13; 22; 8; 31; 1; 12; 31; 31; 6; 16; 37; 46; 2; 27; 30; 7])
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for minimumSum" >::: [
+        
+  "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_sum_of_mountain_triplets_i/scala_tests/MySuite.scala

@@ -0,0 +1,44 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.minimumSum(List(8,6,1,5,3)), 9)
+  }
+
+  test("test2") {
+    assertEquals(Main.minimumSum(List(5,4,8,7,10,2)), 13)
+  }
+
+  test("test3") {
+    assertEquals(Main.minimumSum(List(6,5,4,3,4,5)), -1)
+  }
+
+  test("test4") {
+    assertEquals(Main.minimumSum(7,5,14,12,17,16,49,41,11,47,40,27,33,10,22,48,16,43,33,23,35,46,9,31,5,19,1,44,50,4,20,20,14,4,11,47,27), 15)
+  }
+
+  test("test5") {
+    assertEquals(Main.minimumSum(30,14,27,36,34,37,37,33,25,45,40,3,35,49,24,47,17,45,16,44,32,40,45,42,22,34,46,5,14,21,42,18,4,43,8,38,24,1,41,31,34,45), 8)
+  }
+
+  test("test6") {
+    assertEquals(Main.minimumSum(50,27,45,23,25,19,22,8,21,30,16,15,37,36,22,29,34,4,13,44,30,24,19), 27)
+  }
+
+  test("test7") {
+    assertEquals(Main.minimumSum(6,48,48,13,27,13,18,25,22,39,42,49,8,1,46,5,11,33,16), 15)
+  }
+
+  test("test8") {
+    assertEquals(Main.minimumSum(14,42,6,21,33,25,44,48,33,18,16,21,46,43,11,34,23,36,36,5,25,31,32,4,39,27,35,32,5,42,45,8,47,47,2,6,15,19,43,22,34,44,24,2,12,41,39,50), 10)
+  }
+
+  test("test9") {
+    assertEquals(Main.minimumSum(39,31,2,22,5,36,34,47,50), 29)
+  }
+
+  test("test10") {
+    assertEquals(Main.minimumSum(26,26,11,27,13,22,8,31,1,12,31,31,6,16,37,46,2,27,30,7), 9)
+  }
+
+}

minimum_sum_of_mountain_triplets_ii/java_tests/Main.java

@@ -0,0 +1,24 @@
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+import java.util.List;
+import java.util.Arrays;
+public class Main {
+    //Program start
+
+    //Program end
+
+    @Test
+public void test1() {
+    assertEquals(9, minimumSum(Arrays.asList(8,6,1,5,3)));
+}
+@Test
+public void test2() {
+    assertEquals(13, minimumSum(Arrays.asList(5,4,8,7,10,2)));
+}
+@Test
+public void test3() {
+    assertEquals(-1, minimumSum(Arrays.asList(6,5,4,3,4,5)));
+}
+
+}

minimum_sum_of_squared_difference/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 (minSumSquareDiff [1,2,3,4] [2,10,20,19] 0 0)," 579 (minSumSquareDiff [1,2,3,4] [2,10,20,19] 0 0))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (minSumSquareDiff [1,4,10,12] [5,8,6,9] 1 1)," 43 (minSumSquareDiff [1,4,10,12] [5,8,6,9] 1 1))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

minimum_sum_of_squared_difference/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(579, minSumSquareDiff(new ArrayList<>(Arrays.asList(1,2,3,4)), new ArrayList<>(Arrays.asList(2,10,20,19)), 0, 0));
+}
+@Test
+public void test2() {
+    assertEquals(43, minSumSquareDiff(new ArrayList<>(Arrays.asList(1,4,10,12)), new ArrayList<>(Arrays.asList(5,8,6,9)), 1, 1));
+}
+
+}

minimum_sum_of_squared_difference/meta.json

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

minimum_sum_of_squared_difference/ocaml_tests/main.ml

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

minimum_sum_of_squared_difference/scala_tests/MySuite.scala

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

minimum_sum_of_values_by_dividing_array/java_tests/Main.java

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

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

minimum_swaps_to_group_all_1s_together_ii/java_tests/Main.java

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

minimum_swaps_to_group_all_1s_together_ii/meta.json

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

minimum_swaps_to_group_all_1s_together_ii/ocaml_tests/main.ml

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

minimum_swaps_to_group_all_1s_together_ii/scala_tests/MySuite.scala

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

minimum_time_to_break_locks_i/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 (findMinimumTime [3,4,1] 1)," 4 (findMinimumTime [3,4,1] 1))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (findMinimumTime [2,5,4] 2)," 5 (findMinimumTime [2,5,4] 2))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (findMinimumTime [137378, 881675, 832554, 792714, 582715, 957086, 55824] 10)," 174919 (findMinimumTime [137378, 881675, 832554, 792714, 582715, 957086, 55824] 10))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (findMinimumTime [307658, 586884, 872424, 781340, 571556] 7)," 483829 (findMinimumTime [307658, 586884, 872424, 781340, 571556] 7))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (findMinimumTime [341577, 233634, 669815, 36908] 10)," 96021 (findMinimumTime [341577, 233634, 669815, 36908] 10))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (findMinimumTime [630856, 383599, 544692, 621165, 419087, 83758] 6)," 244662 (findMinimumTime [630856, 383599, 544692, 621165, 419087, 83758] 6))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (findMinimumTime [423390, 269329, 235002, 274601] 7)," 306221 (findMinimumTime [423390, 269329, 235002, 274601] 7))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (findMinimumTime [949077, 571566, 186726] 6)," 341385 (findMinimumTime [949077, 571566, 186726] 6))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (findMinimumTime [898445, 876951, 491188, 629389, 800933, 982853] 5)," 804297 (findMinimumTime [898445, 876951, 491188, 629389, 800933, 982853] 5))
+
+
+-- 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_time_to_break_locks_i/java_tests/Main.java

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

minimum_time_to_break_locks_i/meta.json

@@ -0,0 +1,158 @@
+{
+    "id": 3649,
+    "name": "minimum_time_to_break_locks_i",
+    "difficulty": "Medium",
+    "link": "https://leetcode.com/problems/minimum-time-to-break-locks-i/",
+    "date": "2024-11-23 00:00:00",
+    "task_description": "Bob is stuck in a dungeon and must break `n` locks, each requiring some amount of **energy** to break. The required energy for each lock is stored in an array called `strength` where `strength[i]` indicates the energy needed to break the `ith` lock. To break a lock, Bob uses a sword with the following characteristics: The initial energy of the sword is 0. The initial factor `x` by which the energy of the sword increases is 1. Every minute, the energy of the sword increases by the current factor `x`. To break the `ith` lock, the energy of the sword must reach **at least** `strength[i]`. After breaking a lock, the energy of the sword resets to 0, and the factor `x` increases by a given value `k`. Your task is to determine the **minimum** time in minutes required for Bob to break all `n` locks and escape the dungeon. Return the **minimum **time required for Bob to break all `n` locks. **Example 1:** **Input:** strength = [3,4,1], k = 1 **Output:** 4 **Explanation:** Time Energy x Action Updated x 0 0 1 Nothing 1 1 1 1 Break 3rd Lock 2 2 2 2 Nothing 2 3 4 2 Break 2nd Lock 3 4 3 3 Break 1st Lock 3 The locks cannot be broken in less than 4 minutes; thus, the answer is 4. **Example 2:** **Input:** strength = [2,5,4], k = 2 **Output:** 5 **Explanation:** Time Energy x Action Updated x 0 0 1 Nothing 1 1 1 1 Nothing 1 2 2 1 Break 1st Lock 3 3 3 3 Nothing 3 4 6 3 Break 2nd Lock 5 5 5 5 Break 3rd Lock 7 The locks cannot be broken in less than 5 minutes; thus, the answer is 5. **Constraints:** `n == strength.length` `1 <= n <= 8` `1 <= K <= 10` `1 <= strength[i] <= 106`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "strength = [3,4,1], k = 1",
+            "output": "4 "
+        },
+        {
+            "label": "Example 2",
+            "input": "strength = [2,5,4], k = 2",
+            "output": "5 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                [
+                    137378,
+                    881675,
+                    832554,
+                    792714,
+                    582715,
+                    957086,
+                    55824
+                ],
+                10
+            ],
+            "output": 174919
+        },
+        {
+            "input": [
+                [
+                    307658,
+                    586884,
+                    872424,
+                    781340,
+                    571556
+                ],
+                7
+            ],
+            "output": 483829
+        },
+        {
+            "input": [
+                [
+                    341577,
+                    233634,
+                    669815,
+                    36908
+                ],
+                10
+            ],
+            "output": 96021
+        },
+        {
+            "input": [
+                [
+                    630856,
+                    383599,
+                    544692,
+                    621165,
+                    419087,
+                    83758
+                ],
+                6
+            ],
+            "output": 244662
+        },
+        {
+            "input": [
+                [
+                    423390,
+                    269329,
+                    235002,
+                    274601
+                ],
+                7
+            ],
+            "output": 306221
+        },
+        {
+            "input": [
+                [
+                    949077,
+                    571566,
+                    186726
+                ],
+                6
+            ],
+            "output": 341385
+        },
+        {
+            "input": [
+                [
+                    898445,
+                    876951,
+                    491188,
+                    629389,
+                    800933,
+                    982853
+                ],
+                5
+            ],
+            "output": 804297
+        },
+        {
+            "input": [
+                [
+                    386461,
+                    647430,
+                    256210,
+                    483105,
+                    777989,
+                    516737,
+                    434168
+                ],
+                5
+            ],
+            "output": 464892
+        },
+        {
+            "input": [
+                [
+                    963681,
+                    987219,
+                    79662
+                ],
+                5
+            ],
+            "output": 330024
+        },
+        {
+            "input": [
+                [
+                    101667,
+                    914911,
+                    65765,
+                    142139,
+                    603446,
+                    726
+                ],
+                8
+            ],
+            "output": 60303
+        }
+    ],
+    "haskell_template": "findMinimumTime :: [Int] -> Int -> Int\nfindMinimumTime strength k ",
+    "ocaml_template": "let findMinimumTime (strength: int list) (k: int) : int =  ",
+    "scala_template": "def findMinimumTime(strength: List[Int],k: Int): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public int findMinimumTime(List<Integer> strength, int k) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def findMinimumTime(self, strength, k):\n        \"\"\"\n        :type strength: List[int]\n        :type k: int\n        :rtype: int\n        \"\"\"\n        "
+}

minimum_time_to_break_locks_i/ocaml_tests/main.ml

@@ -0,0 +1,50 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 4 (findMinimumTime [3;4;1] 1)
+
+let test2 _ = assert_equal 5 (findMinimumTime [2;5;4] 2)
+
+let test3 _ = assert_equal 174919 (findMinimumTime [137378; 881675; 832554; 792714; 582715; 957086; 55824] 10)
+
+let test4 _ = assert_equal 483829 (findMinimumTime [307658; 586884; 872424; 781340; 571556] 7)
+
+let test5 _ = assert_equal 96021 (findMinimumTime [341577; 233634; 669815; 36908] 10)
+
+let test6 _ = assert_equal 244662 (findMinimumTime [630856; 383599; 544692; 621165; 419087; 83758] 6)
+
+let test7 _ = assert_equal 306221 (findMinimumTime [423390; 269329; 235002; 274601] 7)
+
+let test8 _ = assert_equal 341385 (findMinimumTime [949077; 571566; 186726] 6)
+
+let test9 _ = assert_equal 804297 (findMinimumTime [898445; 876951; 491188; 629389; 800933; 982853] 5)
+
+let test10 _ = assert_equal 464892 (findMinimumTime [386461; 647430; 256210; 483105; 777989; 516737; 434168] 5)
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for findMinimumTime" >::: [
+        
+  "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_time_to_break_locks_i/scala_tests/MySuite.scala

@@ -0,0 +1,44 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.findMinimumTime(List(3,4,1),1), 4)
+  }
+
+  test("test2") {
+    assertEquals(Main.findMinimumTime(List(2,5,4),2), 5)
+  }
+
+  test("test3") {
+    assertEquals(Main.findMinimumTime(List(137378, 881675, 832554, 792714, 582715, 957086, 55824),10), 174919)
+  }
+
+  test("test4") {
+    assertEquals(Main.findMinimumTime(List(307658, 586884, 872424, 781340, 571556),7), 483829)
+  }
+
+  test("test5") {
+    assertEquals(Main.findMinimumTime(List(341577, 233634, 669815, 36908),10), 96021)
+  }
+
+  test("test6") {
+    assertEquals(Main.findMinimumTime(List(630856, 383599, 544692, 621165, 419087, 83758),6), 244662)
+  }
+
+  test("test7") {
+    assertEquals(Main.findMinimumTime(List(423390, 269329, 235002, 274601),7), 306221)
+  }
+
+  test("test8") {
+    assertEquals(Main.findMinimumTime(List(949077, 571566, 186726),6), 341385)
+  }
+
+  test("test9") {
+    assertEquals(Main.findMinimumTime(List(898445, 876951, 491188, 629389, 800933, 982853),5), 804297)
+  }
+
+  test("test10") {
+    assertEquals(Main.findMinimumTime(List(386461, 647430, 256210, 483105, 777989, 516737, 434168),5), 464892)
+  }
+
+}

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

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

minimum_time_to_complete_all_tasks/ocaml_tests/main.ml

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

minimum_time_to_complete_all_tasks/scala_tests/MySuite.scala

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

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

minimum_time_to_complete_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(3, minimumTime(new ArrayList<>(Arrays.asList(1,2,3)), 5));
+}
+@Test
+public void test2() {
+    assertEquals(2, minimumTime(new ArrayList<>(Arrays.asList(2)), 1));
+}
+
+}

minimum_time_to_complete_trips/meta.json

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

minimum_time_to_complete_trips/ocaml_tests/main.ml

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

minimum_time_to_complete_trips/scala_tests/MySuite.scala

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

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

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

minimum_time_to_finish_the_race/meta.json

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

minimum_time_to_finish_the_race/ocaml_tests/main.ml

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

minimum_time_to_finish_the_race/scala_tests/MySuite.scala

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