2ff8330bfd74005b3b7a257ffd0af75b0a960582de7112aa72eb30a11e704951

minimum_array_sum/scala_tests/MySuite.scala

@@ -0,0 +1,44 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.minArraySum(List(2,8,3,19,3),3,1,1), 23)
+  }
+
+  test("test2") {
+    assertEquals(Main.minArraySum(List(2,4,3),3,2,1), 3)
+  }
+
+  test("test3") {
+    assertEquals(Main.minArraySum(List(0, 6, 8, 16, 17, 13, 17, 18, 20, 20, 20, 21, 34, 35, 5, 6, 12, 16, 16, 16),73,11,11), 316)
+  }
+
+  test("test4") {
+    assertEquals(Main.minArraySum(List(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)
+  }
+
+  test("test5") {
+    assertEquals(Main.minArraySum(List(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)
+  }
+
+  test("test6") {
+    assertEquals(Main.minArraySum(List(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)
+  }
+
+  test("test7") {
+    assertEquals(Main.minArraySum(List(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)
+  }
+
+  test("test8") {
+    assertEquals(Main.minArraySum(List(16, 33, 83, 90, 101),12,0,2), 323)
+  }
+
+  test("test9") {
+    assertEquals(Main.minArraySum(List(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)
+  }
+
+  test("test10") {
+    assertEquals(Main.minArraySum(List(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), 553)
+  }
+
+}

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

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

minimum_average_difference/ocaml_tests/main.ml

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

minimum_average_difference/scala_tests/MySuite.scala

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

minimum_average_of_smallest_and_largest_elements/haskell_tests/Main.hs

@@ -0,0 +1,47 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+minimumAverage :: [Int] -> Float
+minimumAverage nums = undefined
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (minimumAverage [7,8,3,4,15,13,4,1])," 5.5 (minimumAverage [7,8,3,4,15,13,4,1]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (minimumAverage [1,9,8,3,10,5])," 5.5 (minimumAverage [1,9,8,3,10,5]))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (minimumAverage [1,2,3,7,8,9])," 5.0 (minimumAverage [1,2,3,7,8,9]))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (minimumAverage [10, 11, 15, 22, 22, 24])," 16.5 (minimumAverage [10, 11, 15, 22, 22, 24]))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (minimumAverage [1, 1, 4, 5, 9, 11, 11, 12, 12, 13, 14, 15, 18, 20, 20, 21, 21, 25, 31, 33, 36, 37, 39, 40, 44, 45, 46, 48, 48, 49, 50, 50])," 21.0 (minimumAverage [1, 1, 4, 5, 9, 11, 11, 12, 12, 13, 14, 15, 18, 20, 20, 21, 21, 25, 31, 33, 36, 37, 39, 40, 44, 45, 46, 48, 48, 49, 50, 50]))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (minimumAverage [2, 6, 6, 9, 9, 16, 18, 23, 26, 28, 29, 31, 31, 34, 36, 37, 45, 48])," 21.5 (minimumAverage [2, 6, 6, 9, 9, 16, 18, 23, 26, 28, 29, 31, 31, 34, 36, 37, 45, 48]))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (minimumAverage [1, 5, 6, 7, 8, 9, 10, 10, 11, 15, 19, 20, 20, 21, 29, 30, 31, 32, 33, 36, 37, 39, 40, 41, 46, 48])," 20.5 (minimumAverage [1, 5, 6, 7, 8, 9, 10, 10, 11, 15, 19, 20, 20, 21, 29, 30, 31, 32, 33, 36, 37, 39, 40, 41, 46, 48]))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (minimumAverage [5, 5, 37, 43, 43, 50])," 24.0 (minimumAverage [5, 5, 37, 43, 43, 50]))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (minimumAverage [1, 2, 3, 3, 3, 3, 4, 6, 6, 7, 7, 7, 8, 11, 15, 16, 20, 20, 21, 22, 22, 26, 30, 31, 31, 36, 36, 37, 37, 38, 38, 39, 40, 42, 42, 42, 49, 49, 50, 50])," 22.0 (minimumAverage [1, 2, 3, 3, 3, 3, 4, 6, 6, 7, 7, 7, 8, 11, 15, 16, 20, 20, 21, 22, 22, 26, 30, 31, 31, 36, 36, 37, 37, 38, 38, 39, 40, 42, 42, 42, 49, 49, 50, 50]))
+
+
+-- 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_average_of_smallest_and_largest_elements/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(5.5, minimumAverage(Arrays.asList(7,8,3,4,15,13,4,1)));
+}
+@Test
+public void test2() {
+    assertEquals(5.5, minimumAverage(Arrays.asList(1,9,8,3,10,5)));
+}
+@Test
+public void test3() {
+    assertEquals(5.0, minimumAverage(Arrays.asList(1,2,3,7,8,9)));
+}
+
+}

minimum_average_of_smallest_and_largest_elements/meta.json

@@ -0,0 +1,354 @@
+{
+    "id": 3471,
+    "name": "minimum_average_of_smallest_and_largest_elements",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/minimum-average-of-smallest-and-largest-elements/",
+    "date": "2024-06-16 00:00:00",
+    "task_description": "You have an array of floating point numbers `averages` which is initially empty. You are given an array `nums` of `n` integers where `n` is even. You repeat the following procedure `n / 2` times: Remove the **smallest** element, `minElement`, and the **largest** element `maxElement`, from `nums`. Add `(minElement + maxElement) / 2` to `averages`. Return the **minimum** element in `averages`. **Example 1:** **Input:** nums = [7,8,3,4,15,13,4,1] **Output:** 5.5 **Explanation:** step nums averages 0 [7,8,3,4,15,13,4,1] [] 1 [7,8,3,4,13,4] [8] 2 [7,8,4,4] [8,8] 3 [7,4] [8,8,6] 4 [] [8,8,6,5.5] The smallest element of averages, 5.5, is returned. **Example 2:** **Input:** nums = [1,9,8,3,10,5] **Output:** 5.5 **Explanation:** step nums averages 0 [1,9,8,3,10,5] [] 1 [9,8,3,5] [5.5] 2 [8,5] [5.5,6] 3 [] [5.5,6,6.5] **Example 3:** **Input:** nums = [1,2,3,7,8,9] **Output:** 5.0 **Explanation:** step nums averages 0 [1,2,3,7,8,9] [] 1 [2,3,7,8] [5] 2 [3,7] [5,5] 3 [] [5,5,5] **Constraints:** `2 <= n == nums.length <= 50` `n` is even. `1 <= nums[i] <= 50`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "nums = [7,8,3,4,15,13,4,1]",
+            "output": "5.5 "
+        },
+        {
+            "label": "Example 2",
+            "input": "nums = [1,9,8,3,10,5]",
+            "output": "5.5 "
+        },
+        {
+            "label": "Example 3",
+            "input": "nums = [1,2,3,7,8,9]",
+            "output": "5.0 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                10,
+                11,
+                15,
+                22,
+                22,
+                24
+            ],
+            "output": 16.5
+        },
+        {
+            "input": [
+                1,
+                1,
+                4,
+                5,
+                9,
+                11,
+                11,
+                12,
+                12,
+                13,
+                14,
+                15,
+                18,
+                20,
+                20,
+                21,
+                21,
+                25,
+                31,
+                33,
+                36,
+                37,
+                39,
+                40,
+                44,
+                45,
+                46,
+                48,
+                48,
+                49,
+                50,
+                50
+            ],
+            "output": 21.0
+        },
+        {
+            "input": [
+                2,
+                6,
+                6,
+                9,
+                9,
+                16,
+                18,
+                23,
+                26,
+                28,
+                29,
+                31,
+                31,
+                34,
+                36,
+                37,
+                45,
+                48
+            ],
+            "output": 21.5
+        },
+        {
+            "input": [
+                1,
+                5,
+                6,
+                7,
+                8,
+                9,
+                10,
+                10,
+                11,
+                15,
+                19,
+                20,
+                20,
+                21,
+                29,
+                30,
+                31,
+                32,
+                33,
+                36,
+                37,
+                39,
+                40,
+                41,
+                46,
+                48
+            ],
+            "output": 20.5
+        },
+        {
+            "input": [
+                5,
+                5,
+                37,
+                43,
+                43,
+                50
+            ],
+            "output": 24.0
+        },
+        {
+            "input": [
+                1,
+                2,
+                3,
+                3,
+                3,
+                3,
+                4,
+                6,
+                6,
+                7,
+                7,
+                7,
+                8,
+                11,
+                15,
+                16,
+                20,
+                20,
+                21,
+                22,
+                22,
+                26,
+                30,
+                31,
+                31,
+                36,
+                36,
+                37,
+                37,
+                38,
+                38,
+                39,
+                40,
+                42,
+                42,
+                42,
+                49,
+                49,
+                50,
+                50
+            ],
+            "output": 22.0
+        },
+        {
+            "input": [
+                1,
+                3,
+                4,
+                4,
+                6,
+                7,
+                8,
+                8,
+                9,
+                9,
+                10,
+                11,
+                11,
+                14,
+                15,
+                16,
+                19,
+                20,
+                21,
+                22,
+                22,
+                23,
+                23,
+                24,
+                24,
+                24,
+                26,
+                27,
+                30,
+                32,
+                33,
+                34,
+                35,
+                36,
+                37,
+                37,
+                38,
+                39,
+                40,
+                41,
+                41,
+                43,
+                44,
+                45,
+                46,
+                48,
+                48,
+                49
+            ],
+            "output": 23.5
+        },
+        {
+            "input": [
+                1,
+                1,
+                1,
+                2,
+                4,
+                4,
+                6,
+                10,
+                10,
+                12,
+                13,
+                15,
+                16,
+                16,
+                16,
+                17,
+                17,
+                17,
+                18,
+                19,
+                21,
+                23,
+                24,
+                28,
+                28,
+                29,
+                33,
+                36,
+                36,
+                36,
+                36,
+                37,
+                37,
+                38,
+                39,
+                39,
+                40,
+                46,
+                48,
+                49,
+                50,
+                50
+            ],
+            "output": 21.5
+        },
+        {
+            "input": [
+                4,
+                8,
+                11,
+                15,
+                19,
+                23,
+                31,
+                36,
+                39,
+                41,
+                41,
+                49
+            ],
+            "output": 24.5
+        },
+        {
+            "input": [
+                1,
+                3,
+                6,
+                6,
+                6,
+                6,
+                9,
+                10,
+                13,
+                16,
+                19,
+                20,
+                24,
+                25,
+                27,
+                27,
+                34,
+                34,
+                36,
+                36,
+                37,
+                38,
+                38,
+                39,
+                39,
+                39,
+                39,
+                41,
+                41,
+                41,
+                42,
+                42,
+                42,
+                45,
+                45,
+                46,
+                47,
+                48,
+                49,
+                49,
+                50,
+                50
+            ],
+            "output": 25.5
+        }
+    ],
+    "haskell_template": "minimumAverage :: [Int] -> Float\nminimumAverage nums ",
+    "ocaml_template": "let minimumAverage (nums: int list) : float =  ",
+    "scala_template": "def minimumAverage(nums: List[Int]): Float = { \n    \n}",
+    "java_template": "class Solution {\n    public double minimumAverage(int[] nums) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def minimumAverage(self, nums):\n        \"\"\"\n        :type nums: List[int]\n        :rtype: float\n        \"\"\"\n        "
+}

minimum_average_of_smallest_and_largest_elements/ocaml_tests/main.ml

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

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

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

minimum_bit_flips_to_convert_number/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, minBitFlips(10, 7));
+}
+@Test
+public void test2() {
+    assertEquals(3, minBitFlips(3, 4));
+}
+
+}

minimum_bit_flips_to_convert_number/meta.json

@@ -0,0 +1,97 @@
+{
+    "id": 2323,
+    "name": "minimum_bit_flips_to_convert_number",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/minimum-bit-flips-to-convert-number/",
+    "date": "1647648000000",
+    "task_description": "A **bit flip** of a number `x` is choosing a bit in the binary representation of `x` and **flipping** it from either `0` to `1` or `1` to `0`. For example, for `x = 7`, the binary representation is `111` and we may choose any bit (including any leading zeros not shown) and flip it. We can flip the first bit from the right to get `110`, flip the second bit from the right to get `101`, flip the fifth bit from the right (a leading zero) to get `10111`, etc. Given two integers `start` and `goal`, return_ the **minimum** number of **bit flips** to convert _`start`_ to _`goal`. **Example 1:** ``` **Input:** start = 10, goal = 7 **Output:** 3 **Explanation:** The binary representation of 10 and 7 are 1010 and 0111 respectively. We can convert 10 to 7 in 3 steps: - Flip the first bit from the right: 1010 -> 1011. - Flip the third bit from the right: 1011 -> 1111. - Flip the fourth bit from the right: 1111 -> 0111. It can be shown we cannot convert 10 to 7 in less than 3 steps. Hence, we return 3. ``` **Example 2:** ``` **Input:** start = 3, goal = 4 **Output:** 3 **Explanation:** The binary representation of 3 and 4 are 011 and 100 respectively. We can convert 3 to 4 in 3 steps: - Flip the first bit from the right: 011 -> 010. - Flip the second bit from the right: 010 -> 000. - Flip the third bit from the right: 000 -> 100. It can be shown we cannot convert 3 to 4 in less than 3 steps. Hence, we return 3. ``` **Constraints:** `0 <= start, goal <= 109` **Note:** This question is the same as 461: Hamming Distance.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "start = 10, goal = 7",
+            "output": "3 "
+        },
+        {
+            "label": "Example 2",
+            "input": "start = 3, goal = 4",
+            "output": "3 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                464185174,
+                942726219
+            ],
+            "output": 16
+        },
+        {
+            "input": [
+                592770047,
+                56495577
+            ],
+            "output": 13
+        },
+        {
+            "input": [
+                485221247,
+                215866542
+            ],
+            "output": 15
+        },
+        {
+            "input": [
+                269177716,
+                255505893
+            ],
+            "output": 16
+        },
+        {
+            "input": [
+                196878261,
+                175543110
+            ],
+            "output": 14
+        },
+        {
+            "input": [
+                531827332,
+                699740652
+            ],
+            "output": 14
+        },
+        {
+            "input": [
+                137185274,
+                610277760
+            ],
+            "output": 17
+        },
+        {
+            "input": [
+                667761609,
+                636943338
+            ],
+            "output": 11
+        },
+        {
+            "input": [
+                853433529,
+                516947521
+            ],
+            "output": 13
+        },
+        {
+            "input": [
+                208171254,
+                57958222
+            ],
+            "output": 16
+        }
+    ],
+    "haskell_template": "minBitFlips :: Int -> Int -> Int\nminBitFlips start goal ",
+    "ocaml_template": "let minBitFlips (start: int) (goal: int) : int =  ",
+    "scala_template": "def minBitFlips(start: Int,goal: Int): Int = { \n    \n}",
+    "java_template": "public static int minBitFlips(int start, int goal) {\n\n}",
+    "python_template": "class Solution(object):\n    def minBitFlips(self, start, goal):\n        \"\"\"\n        :type start: int\n        :type goal: int\n        :rtype: int\n        \"\"\"\n        "
+}

minimum_bit_flips_to_convert_number/ocaml_tests/main.ml

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

minimum_bit_flips_to_convert_number/scala_tests/MySuite.scala

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

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

minimum_changes_to_make_k_semi_palindromes/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, minimumChanges("abcac", 2));
+}
+@Test
+public void test2() {
+    assertEquals(2, minimumChanges("abcdef", 2));
+}
+@Test
+public void test3() {
+    assertEquals(0, minimumChanges("aabbaa", 3));
+}
+
+}

minimum_changes_to_make_k_semi_palindromes/meta.json

@@ -0,0 +1,102 @@
+{
+    "id": 2879,
+    "name": "minimum_changes_to_make_k_semi_palindromes",
+    "difficulty": "Hard",
+    "link": "https://leetcode.com/problems/minimum-changes-to-make-k-semi-palindromes/",
+    "date": "1697328000000",
+    "task_description": "Given a string `s` and an integer `k`, partition `s` into `k` **substrings** such that the letter changes needed to make each substring a **semi-palindrome** are minimized. Return the _**minimum** number of letter changes_ required_._ A **semi-palindrome** is a special type of string that can be divided into **palindromes** based on a repeating pattern. To check if a string is a semi-palindrome:​ Choose a positive divisor `d` of the string's length. `d` can range from `1` up to, but not including, the string's length. For a string of length `1`, it does not have a valid divisor as per this definition, since the only divisor is its length, which is not allowed. For a given divisor `d`, divide the string into groups where each group contains characters from the string that follow a repeating pattern of length `d`. Specifically, the first group consists of characters at positions `1`, `1 + d`, `1 + 2d`, and so on; the second group includes characters at positions `2`, `2 + d`, `2 + 2d`, etc. The string is considered a semi-palindrome if each of these groups forms a palindrome. Consider the string `\"abcabc\"`: The length of `\"abcabc\"` is `6`. Valid divisors are `1`, `2`, and `3`. For `d = 1`: The entire string `\"abcabc\"` forms one group. Not a palindrome. For `d = 2`: Group 1 (positions `1, 3, 5`): `\"acb\"` Group 2 (positions `2, 4, 6`): `\"bac\"` Neither group forms a palindrome. For `d = 3`: Group 1 (positions `1, 4`): `\"aa\"` Group 2 (positions `2, 5`): `\"bb\"` Group 3 (positions `3, 6`): `\"cc\"` All groups form palindromes. Therefore, `\"abcabc\"` is a semi-palindrome. **Example 1: ** **Input: ** s = \"abcac\", k = 2 **Output: ** 1 **Explanation: ** Divide `s` into `\"ab\"` and `\"cac\"`. `\"cac\"` is already semi-palindrome. Change `\"ab\"` to `\"aa\"`, it becomes semi-palindrome with `d = 1`. **Example 2: ** **Input: ** s = \"abcdef\", k = 2 **Output: ** 2 **Explanation: ** Divide `s` into substrings `\"abc\"` and `\"def\"`. Each needs one change to become semi-palindrome. **Example 3: ** **Input: ** s = \"aabbaa\", k = 3 **Output: ** 0 **Explanation: ** Divide `s` into substrings `\"aa\"`, `\"bb\"` and `\"aa\"`. All are already semi-palindromes. **Constraints:** `2 <= s.length <= 200` `1 <= k <= s.length / 2` `s` contains only lowercase English letters.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "s = \"abcac\", k = 2",
+            "output": "1 "
+        },
+        {
+            "label": "Example 2",
+            "input": "s = \"abcdef\", k = 2",
+            "output": "2 "
+        },
+        {
+            "label": "Example 3",
+            "input": "s = \"aabbaa\", k = 3",
+            "output": "0 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                "\"qeklbsbwmpspzubgxvhjtwvdifezgmsqmuylthiwycqbjtcnyfysex\"",
+                25
+            ],
+            "output": 22
+        },
+        {
+            "input": [
+                "\"wucejegrzlclvdsrzcyqgtliyfiznirgdgjrcasacbaieyqebiqrnixcwupbpcamzndrfuupztxeizsyhgnnwaewqgkpautkqiwsbiimwuapnmsruevczmilagmeurgfzqvmsugcjkrteapjdxqqodxavhmblucxrrltiggxgnvchfprwwpwboddyk\"",
+                85
+            ],
+            "output": 72
+        },
+        {
+            "input": [
+                "\"aakcdvvaaucqbedrucmlqoounueroqgjhtkhnisniskzmqfkddfuvwuqxcirnlnjjmrzsgbbfvmwldalpdjfybwkkyyjiyri\"",
+                17
+            ],
+            "output": 21
+        },
+        {
+            "input": [
+                "\"khoehgodguhcouyrdetvrcohmykuwlnbagmouoymfqijlxrwlvsimounchgnjrjuraecishgvwrpsqmwdrbkprfkcatzpjtpvmqqmzfbdnudzwi\"",
+                31
+            ],
+            "output": 29
+        },
+        {
+            "input": [
+                "\"ffhnqiimghsyhmrhdrxupmdfwomkvngqdaancyrgmylvyiltlwbeil\"",
+                18
+            ],
+            "output": 14
+        },
+        {
+            "input": [
+                "\"dyfqgxtyotkvlxnmyzavacketnlsglaeqacvzbbq\"",
+                5
+            ],
+            "output": 10
+        },
+        {
+            "input": [
+                "apelnd",
+                3
+            ],
+            "output": 3
+        },
+        {
+            "input": [
+                "psnfxnvbihzcjmqohksburfkmwqugdbyiigxhssvtdghqjizneosexzlpyqcfrqgpmhswymqpmlzaognrrosjmkvzhpynkmnijloyuhjop",
+                51
+            ],
+            "output": 48
+        },
+        {
+            "input": [
+                "flsnhgiyotwxvpktlcarljrtcuwwbrsmmpsmttgvgereblshhfvozhvksxrqhtkvtiuewchsocdxjpfqcdsczbmazkz",
+                9
+            ],
+            "output": 23
+        },
+        {
+            "input": [
+                "fitudzhdjasdtggvklwg",
+                8
+            ],
+            "output": 7
+        }
+    ],
+    "haskell_template": "minimumChanges :: String -> Int -> Int\nminimumChanges s k ",
+    "ocaml_template": "let minimumChanges (s: string) (k: int) : int =  ",
+    "scala_template": "def minimumChanges(s: String,k: Int): Int = { \n    \n}",
+    "java_template": "public static int minimumChanges(String s, int k) {\n\n}",
+    "python_template": "class Solution(object):\n    def minimumChanges(self, s, k):\n        \"\"\"\n        :type s: str\n        :type k: int\n        :rtype: int\n        \"\"\"\n        "
+}

minimum_changes_to_make_k_semi_palindromes/ocaml_tests/main.ml

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

minimum_changes_to_make_k_semi_palindromes/scala_tests/MySuite.scala

@@ -0,0 +1,16 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.minimumChanges("abcac",2), 1)
+  }
+
+  test("test2") {
+    assertEquals(Main.minimumChanges("abcdef",2), 2)
+  }
+
+  test("test3") {
+    assertEquals(Main.minimumChanges("aabbaa",3), 0)
+  }
+
+}

minimum_common_value/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 (getCommon [1,2,3] [2,4])," 2 (getCommon [1,2,3] [2,4]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (getCommon [1,2,3,6] [2,3,4,5])," 2 (getCommon [1,2,3,6] [2,3,4,5]))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (getCommon [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 15, 16, 17, 18, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 83, 86, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100] [1, 3, 20, 21, 22, 25, 26, 32, 37, 38, 39, 40, 42, 43, 44, 46, 48, 50, 56, 57, 58, 59, 67, 68, 69, 71, 72, 80, 83, 87, 89, 92, 93, 96])," 1 (getCommon [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 15, 16, 17, 18, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 83, 86, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100] [1, 3, 20, 21, 22, 25, 26, 32, 37, 38, 39, 40, 42, 43, 44, 46, 48, 50, 56, 57, 58, 59, 67, 68, 69, 71, 72, 80, 83, 87, 89, 92, 93, 96]))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (getCommon [1, 2, 4, 5, 11, 12, 13, 14, 19, 23, 26, 35, 38, 40, 42, 45, 47, 49, 51, 52, 57, 58, 59, 60, 63, 66, 68, 69, 71, 75, 81, 89, 91, 93, 95] [1, 3, 4, 5, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 18, 19, 20, 22, 23, 24, 26, 28, 29, 30, 33, 34, 35, 36, 37, 38, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 51, 52, 53, 55, 58, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 74, 76, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 99, 100])," 1 (getCommon [1, 2, 4, 5, 11, 12, 13, 14, 19, 23, 26, 35, 38, 40, 42, 45, 47, 49, 51, 52, 57, 58, 59, 60, 63, 66, 68, 69, 71, 75, 81, 89, 91, 93, 95] [1, 3, 4, 5, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 18, 19, 20, 22, 23, 24, 26, 28, 29, 30, 33, 34, 35, 36, 37, 38, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 51, 52, 53, 55, 58, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 74, 76, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 99, 100]))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (getCommon [1, 3, 8, 10, 14, 16, 19, 27, 28, 32, 34, 35, 37, 42, 44, 47, 55, 57, 61, 65, 67, 69, 70, 73, 76, 80, 84, 85, 89, 90, 91, 95, 98, 100] [56, 76, 82, 88, 89, 90])," 76 (getCommon [1, 3, 8, 10, 14, 16, 19, 27, 28, 32, 34, 35, 37, 42, 44, 47, 55, 57, 61, 65, 67, 69, 70, 73, 76, 80, 84, 85, 89, 90, 91, 95, 98, 100] [56, 76, 82, 88, 89, 90]))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (getCommon [11, 13, 15, 18, 19, 25, 33, 43, 44, 45, 49, 52, 55, 71, 72, 76, 84, 89, 90, 91, 97] [1, 6, 8, 9, 13, 14, 15, 25, 28, 29, 35, 36, 43, 45, 47, 49, 53, 54, 61, 68, 72, 74, 82, 84, 86, 90, 92, 93, 94, 96, 98])," 13 (getCommon [11, 13, 15, 18, 19, 25, 33, 43, 44, 45, 49, 52, 55, 71, 72, 76, 84, 89, 90, 91, 97] [1, 6, 8, 9, 13, 14, 15, 25, 28, 29, 35, 36, 43, 45, 47, 49, 53, 54, 61, 68, 72, 74, 82, 84, 86, 90, 92, 93, 94, 96, 98]))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (getCommon [3, 5, 6, 13, 14, 16, 17, 20, 21, 22, 24, 26, 27, 28, 29, 34, 37, 38, 39, 41, 42, 43, 45, 47, 48, 50, 51, 52, 53, 57, 58, 59, 60, 62, 64, 65, 67, 68, 72, 74, 76, 77, 78, 79, 80, 82, 83, 84, 86, 87, 89, 91, 93, 94, 95, 96, 98, 99] [2, 5, 6, 8, 9, 10, 11, 12, 13, 14, 15, 16, 18, 19, 20, 22, 24, 25, 26, 27, 30, 32, 33, 35, 36, 38, 40, 41, 42, 43, 44, 45, 47, 48, 49, 50, 51, 52, 53, 54, 55, 57, 58, 59, 60, 64, 67, 68, 70, 71, 76, 78, 79, 80, 81, 82, 84, 85, 86, 87, 88, 89, 90, 92, 93, 94, 96, 98, 99, 100])," 5 (getCommon [3, 5, 6, 13, 14, 16, 17, 20, 21, 22, 24, 26, 27, 28, 29, 34, 37, 38, 39, 41, 42, 43, 45, 47, 48, 50, 51, 52, 53, 57, 58, 59, 60, 62, 64, 65, 67, 68, 72, 74, 76, 77, 78, 79, 80, 82, 83, 84, 86, 87, 89, 91, 93, 94, 95, 96, 98, 99] [2, 5, 6, 8, 9, 10, 11, 12, 13, 14, 15, 16, 18, 19, 20, 22, 24, 25, 26, 27, 30, 32, 33, 35, 36, 38, 40, 41, 42, 43, 44, 45, 47, 48, 49, 50, 51, 52, 53, 54, 55, 57, 58, 59, 60, 64, 67, 68, 70, 71, 76, 78, 79, 80, 81, 82, 84, 85, 86, 87, 88, 89, 90, 92, 93, 94, 96, 98, 99, 100]))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (getCommon [2, 5, 6, 7, 9, 10, 11, 13, 14, 15, 17, 21, 26, 27, 28, 29, 31, 33, 35, 36, 38, 39, 42, 43, 44, 48, 49, 54, 55, 56, 57, 59, 61, 62, 67, 72, 73, 76, 77, 81, 82, 83, 85, 86, 87, 88, 90, 92, 93, 95, 96, 99] [101, 103, 104, 105, 106, 107, 108, 109, 110, 111, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 126, 127, 128, 129, 131, 132, 134, 135, 136, 137, 138, 140, 141, 142, 143, 144, 145, 146, 147, 148, 150, 152, 153, 156, 158, 159, 160, 161, 163, 164, 165, 167, 168, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 190, 191, 192, 194, 196, 197, 198, 199, 200])," (-1) (getCommon [2, 5, 6, 7, 9, 10, 11, 13, 14, 15, 17, 21, 26, 27, 28, 29, 31, 33, 35, 36, 38, 39, 42, 43, 44, 48, 49, 54, 55, 56, 57, 59, 61, 62, 67, 72, 73, 76, 77, 81, 82, 83, 85, 86, 87, 88, 90, 92, 93, 95, 96, 99] [101, 103, 104, 105, 106, 107, 108, 109, 110, 111, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 126, 127, 128, 129, 131, 132, 134, 135, 136, 137, 138, 140, 141, 142, 143, 144, 145, 146, 147, 148, 150, 152, 153, 156, 158, 159, 160, 161, 163, 164, 165, 167, 168, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 190, 191, 192, 194, 196, 197, 198, 199, 200]))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (getCommon [4, 31, 55, 59, 80] [102, 104, 105, 106, 107, 108, 109, 110, 111, 114, 115, 116, 117, 118, 121, 123, 124, 126, 127, 128, 129, 133, 134, 135, 137, 140, 141, 142, 145, 146, 147, 150, 151, 153, 155, 157, 160, 163, 167, 168, 172, 173, 175, 176, 177, 178, 179, 188, 189, 190, 196, 198, 200])," (-1) (getCommon [4, 31, 55, 59, 80] [102, 104, 105, 106, 107, 108, 109, 110, 111, 114, 115, 116, 117, 118, 121, 123, 124, 126, 127, 128, 129, 133, 134, 135, 137, 140, 141, 142, 145, 146, 147, 150, 151, 153, 155, 157, 160, 163, 167, 168, 172, 173, 175, 176, 177, 178, 179, 188, 189, 190, 196, 198, 200]))
+
+
+-- 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_common_value/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, getCommon(new ArrayList<>(Arrays.asList(1,2,3)), new ArrayList<>(Arrays.asList(2,4))));
+}
+@Test
+public void test2() {
+    assertEquals(2, getCommon(new ArrayList<>(Arrays.asList(1,2,3,6)), new ArrayList<>(Arrays.asList(2,3,4,5))));
+}
+
+}

minimum_common_value/meta.json

@@ -0,0 +1,1153 @@
+{
+    "id": 2634,
+    "name": "minimum_common_value",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/minimum-common-value/",
+    "date": "2023-01-07 00:00:00",
+    "task_description": "Given two integer arrays `nums1` and `nums2`, sorted in non-decreasing order, return _the **minimum integer common** to both arrays_. If there is no common integer amongst `nums1` and `nums2`, return `-1`. Note that an integer is said to be **common** to `nums1` and `nums2` if both arrays have **at least one** occurrence of that integer. **Example 1:** ``` **Input:** nums1 = [1,2,3], nums2 = [2,4] **Output:** 2 **Explanation:** The smallest element common to both arrays is 2, so we return 2. ``` **Example 2:** ``` **Input:** nums1 = [1,2,3,6], nums2 = [2,3,4,5] **Output:** 2 **Explanation:** There are two common elements in the array 2 and 3 out of which 2 is the smallest, so 2 is returned. ``` **Constraints:** `1 <= nums1.length, nums2.length <= 105` `1 <= nums1[i], nums2[j] <= 109` Both `nums1` and `nums2` are sorted in **non-decreasing** order.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "nums1 = [1,2,3], nums2 = [2,4]",
+            "output": "2 "
+        },
+        {
+            "label": "Example 2",
+            "input": "nums1 = [1,2,3,6], nums2 = [2,3,4,5]",
+            "output": "2 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                [
+                    1,
+                    2,
+                    3,
+                    4,
+                    5,
+                    6,
+                    7,
+                    8,
+                    9,
+                    10,
+                    11,
+                    12,
+                    13,
+                    15,
+                    16,
+                    17,
+                    18,
+                    20,
+                    21,
+                    22,
+                    23,
+                    24,
+                    25,
+                    26,
+                    27,
+                    28,
+                    29,
+                    30,
+                    31,
+                    32,
+                    33,
+                    34,
+                    35,
+                    36,
+                    37,
+                    38,
+                    39,
+                    40,
+                    41,
+                    42,
+                    43,
+                    44,
+                    45,
+                    46,
+                    47,
+                    48,
+                    49,
+                    50,
+                    51,
+                    52,
+                    53,
+                    54,
+                    55,
+                    56,
+                    57,
+                    58,
+                    59,
+                    60,
+                    61,
+                    62,
+                    63,
+                    64,
+                    65,
+                    66,
+                    67,
+                    68,
+                    69,
+                    70,
+                    71,
+                    72,
+                    73,
+                    74,
+                    75,
+                    76,
+                    77,
+                    78,
+                    79,
+                    80,
+                    81,
+                    83,
+                    86,
+                    88,
+                    89,
+                    90,
+                    91,
+                    92,
+                    93,
+                    94,
+                    95,
+                    96,
+                    97,
+                    98,
+                    99,
+                    100
+                ],
+                [
+                    1,
+                    3,
+                    20,
+                    21,
+                    22,
+                    25,
+                    26,
+                    32,
+                    37,
+                    38,
+                    39,
+                    40,
+                    42,
+                    43,
+                    44,
+                    46,
+                    48,
+                    50,
+                    56,
+                    57,
+                    58,
+                    59,
+                    67,
+                    68,
+                    69,
+                    71,
+                    72,
+                    80,
+                    83,
+                    87,
+                    89,
+                    92,
+                    93,
+                    96
+                ]
+            ],
+            "output": 1
+        },
+        {
+            "input": [
+                [
+                    1,
+                    2,
+                    4,
+                    5,
+                    11,
+                    12,
+                    13,
+                    14,
+                    19,
+                    23,
+                    26,
+                    35,
+                    38,
+                    40,
+                    42,
+                    45,
+                    47,
+                    49,
+                    51,
+                    52,
+                    57,
+                    58,
+                    59,
+                    60,
+                    63,
+                    66,
+                    68,
+                    69,
+                    71,
+                    75,
+                    81,
+                    89,
+                    91,
+                    93,
+                    95
+                ],
+                [
+                    1,
+                    3,
+                    4,
+                    5,
+                    7,
+                    8,
+                    9,
+                    10,
+                    11,
+                    12,
+                    13,
+                    14,
+                    15,
+                    16,
+                    18,
+                    19,
+                    20,
+                    22,
+                    23,
+                    24,
+                    26,
+                    28,
+                    29,
+                    30,
+                    33,
+                    34,
+                    35,
+                    36,
+                    37,
+                    38,
+                    40,
+                    41,
+                    42,
+                    43,
+                    44,
+                    45,
+                    46,
+                    47,
+                    48,
+                    49,
+                    51,
+                    52,
+                    53,
+                    55,
+                    58,
+                    60,
+                    61,
+                    62,
+                    63,
+                    64,
+                    65,
+                    66,
+                    67,
+                    68,
+                    69,
+                    70,
+                    74,
+                    76,
+                    79,
+                    80,
+                    81,
+                    82,
+                    83,
+                    84,
+                    85,
+                    86,
+                    87,
+                    88,
+                    89,
+                    90,
+                    91,
+                    92,
+                    93,
+                    94,
+                    95,
+                    96,
+                    97,
+                    99,
+                    100
+                ]
+            ],
+            "output": 1
+        },
+        {
+            "input": [
+                [
+                    1,
+                    3,
+                    8,
+                    10,
+                    14,
+                    16,
+                    19,
+                    27,
+                    28,
+                    32,
+                    34,
+                    35,
+                    37,
+                    42,
+                    44,
+                    47,
+                    55,
+                    57,
+                    61,
+                    65,
+                    67,
+                    69,
+                    70,
+                    73,
+                    76,
+                    80,
+                    84,
+                    85,
+                    89,
+                    90,
+                    91,
+                    95,
+                    98,
+                    100
+                ],
+                [
+                    56,
+                    76,
+                    82,
+                    88,
+                    89,
+                    90
+                ]
+            ],
+            "output": 76
+        },
+        {
+            "input": [
+                [
+                    11,
+                    13,
+                    15,
+                    18,
+                    19,
+                    25,
+                    33,
+                    43,
+                    44,
+                    45,
+                    49,
+                    52,
+                    55,
+                    71,
+                    72,
+                    76,
+                    84,
+                    89,
+                    90,
+                    91,
+                    97
+                ],
+                [
+                    1,
+                    6,
+                    8,
+                    9,
+                    13,
+                    14,
+                    15,
+                    25,
+                    28,
+                    29,
+                    35,
+                    36,
+                    43,
+                    45,
+                    47,
+                    49,
+                    53,
+                    54,
+                    61,
+                    68,
+                    72,
+                    74,
+                    82,
+                    84,
+                    86,
+                    90,
+                    92,
+                    93,
+                    94,
+                    96,
+                    98
+                ]
+            ],
+            "output": 13
+        },
+        {
+            "input": [
+                [
+                    3,
+                    5,
+                    6,
+                    13,
+                    14,
+                    16,
+                    17,
+                    20,
+                    21,
+                    22,
+                    24,
+                    26,
+                    27,
+                    28,
+                    29,
+                    34,
+                    37,
+                    38,
+                    39,
+                    41,
+                    42,
+                    43,
+                    45,
+                    47,
+                    48,
+                    50,
+                    51,
+                    52,
+                    53,
+                    57,
+                    58,
+                    59,
+                    60,
+                    62,
+                    64,
+                    65,
+                    67,
+                    68,
+                    72,
+                    74,
+                    76,
+                    77,
+                    78,
+                    79,
+                    80,
+                    82,
+                    83,
+                    84,
+                    86,
+                    87,
+                    89,
+                    91,
+                    93,
+                    94,
+                    95,
+                    96,
+                    98,
+                    99
+                ],
+                [
+                    2,
+                    5,
+                    6,
+                    8,
+                    9,
+                    10,
+                    11,
+                    12,
+                    13,
+                    14,
+                    15,
+                    16,
+                    18,
+                    19,
+                    20,
+                    22,
+                    24,
+                    25,
+                    26,
+                    27,
+                    30,
+                    32,
+                    33,
+                    35,
+                    36,
+                    38,
+                    40,
+                    41,
+                    42,
+                    43,
+                    44,
+                    45,
+                    47,
+                    48,
+                    49,
+                    50,
+                    51,
+                    52,
+                    53,
+                    54,
+                    55,
+                    57,
+                    58,
+                    59,
+                    60,
+                    64,
+                    67,
+                    68,
+                    70,
+                    71,
+                    76,
+                    78,
+                    79,
+                    80,
+                    81,
+                    82,
+                    84,
+                    85,
+                    86,
+                    87,
+                    88,
+                    89,
+                    90,
+                    92,
+                    93,
+                    94,
+                    96,
+                    98,
+                    99,
+                    100
+                ]
+            ],
+            "output": 5
+        },
+        {
+            "input": [
+                [
+                    2,
+                    5,
+                    6,
+                    7,
+                    9,
+                    10,
+                    11,
+                    13,
+                    14,
+                    15,
+                    17,
+                    21,
+                    26,
+                    27,
+                    28,
+                    29,
+                    31,
+                    33,
+                    35,
+                    36,
+                    38,
+                    39,
+                    42,
+                    43,
+                    44,
+                    48,
+                    49,
+                    54,
+                    55,
+                    56,
+                    57,
+                    59,
+                    61,
+                    62,
+                    67,
+                    72,
+                    73,
+                    76,
+                    77,
+                    81,
+                    82,
+                    83,
+                    85,
+                    86,
+                    87,
+                    88,
+                    90,
+                    92,
+                    93,
+                    95,
+                    96,
+                    99
+                ],
+                [
+                    101,
+                    103,
+                    104,
+                    105,
+                    106,
+                    107,
+                    108,
+                    109,
+                    110,
+                    111,
+                    113,
+                    114,
+                    115,
+                    116,
+                    117,
+                    118,
+                    119,
+                    120,
+                    121,
+                    122,
+                    123,
+                    126,
+                    127,
+                    128,
+                    129,
+                    131,
+                    132,
+                    134,
+                    135,
+                    136,
+                    137,
+                    138,
+                    140,
+                    141,
+                    142,
+                    143,
+                    144,
+                    145,
+                    146,
+                    147,
+                    148,
+                    150,
+                    152,
+                    153,
+                    156,
+                    158,
+                    159,
+                    160,
+                    161,
+                    163,
+                    164,
+                    165,
+                    167,
+                    168,
+                    170,
+                    171,
+                    172,
+                    173,
+                    174,
+                    175,
+                    176,
+                    177,
+                    178,
+                    179,
+                    180,
+                    181,
+                    182,
+                    183,
+                    184,
+                    185,
+                    186,
+                    187,
+                    188,
+                    190,
+                    191,
+                    192,
+                    194,
+                    196,
+                    197,
+                    198,
+                    199,
+                    200
+                ]
+            ],
+            "output": -1
+        },
+        {
+            "input": [
+                [
+                    4,
+                    31,
+                    55,
+                    59,
+                    80
+                ],
+                [
+                    102,
+                    104,
+                    105,
+                    106,
+                    107,
+                    108,
+                    109,
+                    110,
+                    111,
+                    114,
+                    115,
+                    116,
+                    117,
+                    118,
+                    121,
+                    123,
+                    124,
+                    126,
+                    127,
+                    128,
+                    129,
+                    133,
+                    134,
+                    135,
+                    137,
+                    140,
+                    141,
+                    142,
+                    145,
+                    146,
+                    147,
+                    150,
+                    151,
+                    153,
+                    155,
+                    157,
+                    160,
+                    163,
+                    167,
+                    168,
+                    172,
+                    173,
+                    175,
+                    176,
+                    177,
+                    178,
+                    179,
+                    188,
+                    189,
+                    190,
+                    196,
+                    198,
+                    200
+                ]
+            ],
+            "output": -1
+        },
+        {
+            "input": [
+                [
+                    1,
+                    2,
+                    3,
+                    4,
+                    5,
+                    6,
+                    8,
+                    9,
+                    10,
+                    12,
+                    13,
+                    14,
+                    15,
+                    16,
+                    17,
+                    18,
+                    19,
+                    20,
+                    21,
+                    22,
+                    23,
+                    24,
+                    25,
+                    26,
+                    27,
+                    28,
+                    30,
+                    31,
+                    32,
+                    33,
+                    34,
+                    35,
+                    36,
+                    37,
+                    38,
+                    39,
+                    40,
+                    41,
+                    42,
+                    43,
+                    44,
+                    45,
+                    46,
+                    47,
+                    48,
+                    49,
+                    50,
+                    51,
+                    52,
+                    53,
+                    54,
+                    55,
+                    57,
+                    58,
+                    59,
+                    60,
+                    61,
+                    62,
+                    63,
+                    64,
+                    65,
+                    66,
+                    67,
+                    68,
+                    69,
+                    70,
+                    71,
+                    72,
+                    73,
+                    74,
+                    75,
+                    76,
+                    77,
+                    78,
+                    79,
+                    81,
+                    82,
+                    83,
+                    84,
+                    85,
+                    86,
+                    87,
+                    88,
+                    89,
+                    90,
+                    92,
+                    93,
+                    94,
+                    95,
+                    96,
+                    97,
+                    98,
+                    99
+                ],
+                [
+                    101,
+                    102,
+                    103,
+                    104,
+                    105,
+                    107,
+                    108,
+                    109,
+                    110,
+                    112,
+                    113,
+                    115,
+                    116,
+                    117,
+                    118,
+                    119,
+                    120,
+                    121,
+                    123,
+                    124,
+                    125,
+                    126,
+                    128,
+                    129,
+                    131,
+                    132,
+                    133,
+                    134,
+                    135,
+                    136,
+                    137,
+                    138,
+                    140,
+                    141,
+                    142,
+                    143,
+                    144,
+                    145,
+                    147,
+                    148,
+                    149,
+                    150,
+                    151,
+                    153,
+                    154,
+                    155,
+                    156,
+                    157,
+                    158,
+                    159,
+                    160,
+                    161,
+                    162,
+                    163,
+                    166,
+                    167,
+                    168,
+                    169,
+                    170,
+                    172,
+                    173,
+                    174,
+                    175,
+                    176,
+                    177,
+                    178,
+                    179,
+                    181,
+                    182,
+                    183,
+                    185,
+                    186,
+                    187,
+                    188,
+                    189,
+                    190,
+                    191,
+                    192,
+                    193,
+                    194,
+                    195,
+                    196,
+                    197,
+                    198,
+                    199,
+                    200
+                ]
+            ],
+            "output": -1
+        },
+        {
+            "input": [
+                [
+                    1,
+                    2,
+                    3,
+                    4,
+                    5,
+                    6,
+                    7,
+                    8,
+                    9,
+                    10,
+                    11,
+                    12,
+                    15,
+                    16,
+                    17,
+                    18,
+                    19,
+                    20,
+                    21,
+                    22,
+                    23,
+                    24,
+                    25,
+                    26,
+                    27,
+                    28,
+                    29,
+                    30,
+                    31,
+                    32,
+                    33,
+                    34,
+                    35,
+                    36,
+                    37,
+                    38,
+                    39,
+                    40,
+                    41,
+                    42,
+                    43,
+                    44,
+                    45,
+                    46,
+                    47,
+                    48,
+                    50,
+                    51,
+                    52,
+                    53,
+                    54,
+                    55,
+                    56,
+                    57,
+                    58,
+                    59,
+                    60,
+                    61,
+                    62,
+                    64,
+                    66,
+                    67,
+                    68,
+                    69,
+                    70,
+                    72,
+                    73,
+                    74,
+                    75,
+                    76,
+                    77,
+                    78,
+                    79,
+                    80,
+                    81,
+                    82,
+                    83,
+                    84,
+                    86,
+                    87,
+                    88,
+                    89,
+                    90,
+                    91,
+                    92,
+                    93,
+                    94,
+                    95,
+                    96,
+                    97,
+                    98,
+                    99,
+                    100
+                ],
+                [
+                    101,
+                    103,
+                    104,
+                    105,
+                    106,
+                    108,
+                    109,
+                    110,
+                    112,
+                    114,
+                    115,
+                    117,
+                    118,
+                    119,
+                    120,
+                    122,
+                    124,
+                    125,
+                    126,
+                    127,
+                    129,
+                    131,
+                    133,
+                    134,
+                    135,
+                    138,
+                    140,
+                    141,
+                    144,
+                    145,
+                    146,
+                    147,
+                    152,
+                    153,
+                    154,
+                    157,
+                    158,
+                    159,
+                    160,
+                    162,
+                    163,
+                    164,
+                    165,
+                    167,
+                    168,
+                    170,
+                    172,
+                    177,
+                    179,
+                    181,
+                    183,
+                    187,
+                    188,
+                    189,
+                    190,
+                    191,
+                    192,
+                    194,
+                    200
+                ]
+            ],
+            "output": -1
+        },
+        {
+            "input": [
+                [
+                    5,
+                    8,
+                    9,
+                    12,
+                    13,
+                    15,
+                    21,
+                    23,
+                    24,
+                    25,
+                    28,
+                    30,
+                    31,
+                    32,
+                    33,
+                    36,
+                    44,
+                    45,
+                    49,
+                    52,
+                    56,
+                    58,
+                    61,
+                    68,
+                    72,
+                    75,
+                    76,
+                    79,
+                    80,
+                    84,
+                    87,
+                    88,
+                    90,
+                    91,
+                    92,
+                    94,
+                    97
+                ],
+                [
+                    103,
+                    108,
+                    113,
+                    116,
+                    141,
+                    146,
+                    151,
+                    162,
+                    168,
+                    171,
+                    173,
+                    176,
+                    182,
+                    199
+                ]
+            ],
+            "output": -1
+        }
+    ],
+    "haskell_template": "getCommon :: [Int] -> [Int] -> Int\ngetCommon nums1 nums2 ",
+    "ocaml_template": "let getCommon (nums1: int list) (nums2: int list) : int =  ",
+    "scala_template": "def getCommon(nums1: List[Int],nums2: List[Int]): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public int getCommon(int[] nums1, int[] nums2) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def getCommon(self, nums1, nums2):\n        \"\"\"\n        :type nums1: List[int]\n        :type nums2: List[int]\n        :rtype: int\n        \"\"\"\n        "
+}

minimum_common_value/ocaml_tests/main.ml

@@ -0,0 +1,50 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 2 (getCommon [1;2;3] [2;4])
+
+let test2 _ = assert_equal 2 (getCommon [1;2;3;6] [2;3;4;5])
+
+let test3 _ = assert_equal 1 (getCommon [1; 2; 3; 4; 5; 6; 7; 8; 9; 10; 11; 12; 13; 15; 16; 17; 18; 20; 21; 22; 23; 24; 25; 26; 27; 28; 29; 30; 31; 32; 33; 34; 35; 36; 37; 38; 39; 40; 41; 42; 43; 44; 45; 46; 47; 48; 49; 50; 51; 52; 53; 54; 55; 56; 57; 58; 59; 60; 61; 62; 63; 64; 65; 66; 67; 68; 69; 70; 71; 72; 73; 74; 75; 76; 77; 78; 79; 80; 81; 83; 86; 88; 89; 90; 91; 92; 93; 94; 95; 96; 97; 98; 99; 100] [1; 3; 20; 21; 22; 25; 26; 32; 37; 38; 39; 40; 42; 43; 44; 46; 48; 50; 56; 57; 58; 59; 67; 68; 69; 71; 72; 80; 83; 87; 89; 92; 93; 96])
+
+let test4 _ = assert_equal 1 (getCommon [1; 2; 4; 5; 11; 12; 13; 14; 19; 23; 26; 35; 38; 40; 42; 45; 47; 49; 51; 52; 57; 58; 59; 60; 63; 66; 68; 69; 71; 75; 81; 89; 91; 93; 95] [1; 3; 4; 5; 7; 8; 9; 10; 11; 12; 13; 14; 15; 16; 18; 19; 20; 22; 23; 24; 26; 28; 29; 30; 33; 34; 35; 36; 37; 38; 40; 41; 42; 43; 44; 45; 46; 47; 48; 49; 51; 52; 53; 55; 58; 60; 61; 62; 63; 64; 65; 66; 67; 68; 69; 70; 74; 76; 79; 80; 81; 82; 83; 84; 85; 86; 87; 88; 89; 90; 91; 92; 93; 94; 95; 96; 97; 99; 100])
+
+let test5 _ = assert_equal 76 (getCommon [1; 3; 8; 10; 14; 16; 19; 27; 28; 32; 34; 35; 37; 42; 44; 47; 55; 57; 61; 65; 67; 69; 70; 73; 76; 80; 84; 85; 89; 90; 91; 95; 98; 100] [56; 76; 82; 88; 89; 90])
+
+let test6 _ = assert_equal 13 (getCommon [11; 13; 15; 18; 19; 25; 33; 43; 44; 45; 49; 52; 55; 71; 72; 76; 84; 89; 90; 91; 97] [1; 6; 8; 9; 13; 14; 15; 25; 28; 29; 35; 36; 43; 45; 47; 49; 53; 54; 61; 68; 72; 74; 82; 84; 86; 90; 92; 93; 94; 96; 98])
+
+let test7 _ = assert_equal 5 (getCommon [3; 5; 6; 13; 14; 16; 17; 20; 21; 22; 24; 26; 27; 28; 29; 34; 37; 38; 39; 41; 42; 43; 45; 47; 48; 50; 51; 52; 53; 57; 58; 59; 60; 62; 64; 65; 67; 68; 72; 74; 76; 77; 78; 79; 80; 82; 83; 84; 86; 87; 89; 91; 93; 94; 95; 96; 98; 99] [2; 5; 6; 8; 9; 10; 11; 12; 13; 14; 15; 16; 18; 19; 20; 22; 24; 25; 26; 27; 30; 32; 33; 35; 36; 38; 40; 41; 42; 43; 44; 45; 47; 48; 49; 50; 51; 52; 53; 54; 55; 57; 58; 59; 60; 64; 67; 68; 70; 71; 76; 78; 79; 80; 81; 82; 84; 85; 86; 87; 88; 89; 90; 92; 93; 94; 96; 98; 99; 100])
+
+let test8 _ = assert_equal (-1) (getCommon [2; 5; 6; 7; 9; 10; 11; 13; 14; 15; 17; 21; 26; 27; 28; 29; 31; 33; 35; 36; 38; 39; 42; 43; 44; 48; 49; 54; 55; 56; 57; 59; 61; 62; 67; 72; 73; 76; 77; 81; 82; 83; 85; 86; 87; 88; 90; 92; 93; 95; 96; 99] [101; 103; 104; 105; 106; 107; 108; 109; 110; 111; 113; 114; 115; 116; 117; 118; 119; 120; 121; 122; 123; 126; 127; 128; 129; 131; 132; 134; 135; 136; 137; 138; 140; 141; 142; 143; 144; 145; 146; 147; 148; 150; 152; 153; 156; 158; 159; 160; 161; 163; 164; 165; 167; 168; 170; 171; 172; 173; 174; 175; 176; 177; 178; 179; 180; 181; 182; 183; 184; 185; 186; 187; 188; 190; 191; 192; 194; 196; 197; 198; 199; 200])
+
+let test9 _ = assert_equal (-1) (getCommon [4; 31; 55; 59; 80] [102; 104; 105; 106; 107; 108; 109; 110; 111; 114; 115; 116; 117; 118; 121; 123; 124; 126; 127; 128; 129; 133; 134; 135; 137; 140; 141; 142; 145; 146; 147; 150; 151; 153; 155; 157; 160; 163; 167; 168; 172; 173; 175; 176; 177; 178; 179; 188; 189; 190; 196; 198; 200])
+
+let test10 _ = assert_equal (-1) (getCommon [1; 2; 3; 4; 5; 6; 8; 9; 10; 12; 13; 14; 15; 16; 17; 18; 19; 20; 21; 22; 23; 24; 25; 26; 27; 28; 30; 31; 32; 33; 34; 35; 36; 37; 38; 39; 40; 41; 42; 43; 44; 45; 46; 47; 48; 49; 50; 51; 52; 53; 54; 55; 57; 58; 59; 60; 61; 62; 63; 64; 65; 66; 67; 68; 69; 70; 71; 72; 73; 74; 75; 76; 77; 78; 79; 81; 82; 83; 84; 85; 86; 87; 88; 89; 90; 92; 93; 94; 95; 96; 97; 98; 99] [101; 102; 103; 104; 105; 107; 108; 109; 110; 112; 113; 115; 116; 117; 118; 119; 120; 121; 123; 124; 125; 126; 128; 129; 131; 132; 133; 134; 135; 136; 137; 138; 140; 141; 142; 143; 144; 145; 147; 148; 149; 150; 151; 153; 154; 155; 156; 157; 158; 159; 160; 161; 162; 163; 166; 167; 168; 169; 170; 172; 173; 174; 175; 176; 177; 178; 179; 181; 182; 183; 185; 186; 187; 188; 189; 190; 191; 192; 193; 194; 195; 196; 197; 198; 199; 200])
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for getCommon" >::: [
+        
+  "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_common_value/scala_tests/MySuite.scala

@@ -0,0 +1,44 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.getCommon(List(1,2,3),List(2,4)), 2)
+  }
+
+  test("test2") {
+    assertEquals(Main.getCommon(List(1,2,3,6),List(2,3,4,5)), 2)
+  }
+
+  test("test3") {
+    assertEquals(Main.getCommon(List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 15, 16, 17, 18, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 83, 86, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100),List(1, 3, 20, 21, 22, 25, 26, 32, 37, 38, 39, 40, 42, 43, 44, 46, 48, 50, 56, 57, 58, 59, 67, 68, 69, 71, 72, 80, 83, 87, 89, 92, 93, 96)), 1)
+  }
+
+  test("test4") {
+    assertEquals(Main.getCommon(List(1, 2, 4, 5, 11, 12, 13, 14, 19, 23, 26, 35, 38, 40, 42, 45, 47, 49, 51, 52, 57, 58, 59, 60, 63, 66, 68, 69, 71, 75, 81, 89, 91, 93, 95),List(1, 3, 4, 5, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 18, 19, 20, 22, 23, 24, 26, 28, 29, 30, 33, 34, 35, 36, 37, 38, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 51, 52, 53, 55, 58, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 74, 76, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 99, 100)), 1)
+  }
+
+  test("test5") {
+    assertEquals(Main.getCommon(List(1, 3, 8, 10, 14, 16, 19, 27, 28, 32, 34, 35, 37, 42, 44, 47, 55, 57, 61, 65, 67, 69, 70, 73, 76, 80, 84, 85, 89, 90, 91, 95, 98, 100),List(56, 76, 82, 88, 89, 90)), 76)
+  }
+
+  test("test6") {
+    assertEquals(Main.getCommon(List(11, 13, 15, 18, 19, 25, 33, 43, 44, 45, 49, 52, 55, 71, 72, 76, 84, 89, 90, 91, 97),List(1, 6, 8, 9, 13, 14, 15, 25, 28, 29, 35, 36, 43, 45, 47, 49, 53, 54, 61, 68, 72, 74, 82, 84, 86, 90, 92, 93, 94, 96, 98)), 13)
+  }
+
+  test("test7") {
+    assertEquals(Main.getCommon(List(3, 5, 6, 13, 14, 16, 17, 20, 21, 22, 24, 26, 27, 28, 29, 34, 37, 38, 39, 41, 42, 43, 45, 47, 48, 50, 51, 52, 53, 57, 58, 59, 60, 62, 64, 65, 67, 68, 72, 74, 76, 77, 78, 79, 80, 82, 83, 84, 86, 87, 89, 91, 93, 94, 95, 96, 98, 99),List(2, 5, 6, 8, 9, 10, 11, 12, 13, 14, 15, 16, 18, 19, 20, 22, 24, 25, 26, 27, 30, 32, 33, 35, 36, 38, 40, 41, 42, 43, 44, 45, 47, 48, 49, 50, 51, 52, 53, 54, 55, 57, 58, 59, 60, 64, 67, 68, 70, 71, 76, 78, 79, 80, 81, 82, 84, 85, 86, 87, 88, 89, 90, 92, 93, 94, 96, 98, 99, 100)), 5)
+  }
+
+  test("test8") {
+    assertEquals(Main.getCommon(List(2, 5, 6, 7, 9, 10, 11, 13, 14, 15, 17, 21, 26, 27, 28, 29, 31, 33, 35, 36, 38, 39, 42, 43, 44, 48, 49, 54, 55, 56, 57, 59, 61, 62, 67, 72, 73, 76, 77, 81, 82, 83, 85, 86, 87, 88, 90, 92, 93, 95, 96, 99),List(101, 103, 104, 105, 106, 107, 108, 109, 110, 111, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 126, 127, 128, 129, 131, 132, 134, 135, 136, 137, 138, 140, 141, 142, 143, 144, 145, 146, 147, 148, 150, 152, 153, 156, 158, 159, 160, 161, 163, 164, 165, 167, 168, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 190, 191, 192, 194, 196, 197, 198, 199, 200)), -1)
+  }
+
+  test("test9") {
+    assertEquals(Main.getCommon(List(4, 31, 55, 59, 80),List(102, 104, 105, 106, 107, 108, 109, 110, 111, 114, 115, 116, 117, 118, 121, 123, 124, 126, 127, 128, 129, 133, 134, 135, 137, 140, 141, 142, 145, 146, 147, 150, 151, 153, 155, 157, 160, 163, 167, 168, 172, 173, 175, 176, 177, 178, 179, 188, 189, 190, 196, 198, 200)), -1)
+  }
+
+  test("test10") {
+    assertEquals(Main.getCommon(List(1, 2, 3, 4, 5, 6, 8, 9, 10, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 92, 93, 94, 95, 96, 97, 98, 99),List(101, 102, 103, 104, 105, 107, 108, 109, 110, 112, 113, 115, 116, 117, 118, 119, 120, 121, 123, 124, 125, 126, 128, 129, 131, 132, 133, 134, 135, 136, 137, 138, 140, 141, 142, 143, 144, 145, 147, 148, 149, 150, 151, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 166, 167, 168, 169, 170, 172, 173, 174, 175, 176, 177, 178, 179, 181, 182, 183, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200)), -1)
+  }
+
+}

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

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

minimum_consecutive_cards_to_pick_up/ocaml_tests/main.ml

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

minimum_consecutive_cards_to_pick_up/scala_tests/MySuite.scala

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

minimum_cost_for_cutting_cake_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 (minimumCost 3 2 [1,3] [5])," 13 (minimumCost 3 2 [1,3] [5]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (minimumCost 2 2 [7] [4])," 15 (minimumCost 2 2 [7] [4]))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (minimumCost 9 19 [] [])," 7332 (minimumCost 9 19 [] []))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (minimumCost 13 20 [] [])," 9876 (minimumCost 13 20 [] []))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (minimumCost 1 14 [] [])," 815 (minimumCost 1 14 [] []))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (minimumCost 15 1 [] [])," 826 (minimumCost 15 1 [] []))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (minimumCost 13 7 [] [])," 4489 (minimumCost 13 7 [] []))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (minimumCost 18 20 [] [])," 9671 (minimumCost 18 20 [] []))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (minimumCost 8 17 [] [])," 4105 (minimumCost 8 17 [] []))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1, TestLabel "Test2" test2, TestLabel "Test3" test3, TestLabel "Test4" test4, TestLabel "Test5" test5, TestLabel "Test6" test6, TestLabel "Test7" test7, TestLabel "Test8" test8, TestLabel "Test9" test9]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

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

minimum_cost_for_cutting_cake_i/meta.json

@@ -0,0 +1,117 @@
+{
+    "id": 3494,
+    "name": "minimum_cost_for_cutting_cake_i",
+    "difficulty": "Medium",
+    "link": "https://leetcode.com/problems/minimum-cost-for-cutting-cake-i/",
+    "date": "2024-07-07 00:00:00",
+    "task_description": "There is an `m x n` cake that needs to be cut into `1 x 1` pieces. You are given integers `m`, `n`, and two arrays: `horizontalCut` of size `m - 1`, where `horizontalCut[i]` represents the cost to cut along the horizontal line `i`. `verticalCut` of size `n - 1`, where `verticalCut[j]` represents the cost to cut along the vertical line `j`. In one operation, you can choose any piece of cake that is not yet a `1 x 1` square and perform one of the following cuts: Cut along a horizontal line `i` at a cost of `horizontalCut[i]`. Cut along a vertical line `j` at a cost of `verticalCut[j]`. After the cut, the piece of cake is divided into two distinct pieces. The cost of a cut depends only on the initial cost of the line and does not change. Return the **minimum** total cost to cut the entire cake into `1 x 1` pieces. **Example 1:** **Input:** m = 3, n = 2, horizontalCut = [1,3], verticalCut = [5] **Output:** 13 **Explanation:** Perform a cut on the vertical line 0 with cost 5, current total cost is 5. Perform a cut on the horizontal line 0 on `3 x 1` subgrid with cost 1. Perform a cut on the horizontal line 0 on `3 x 1` subgrid with cost 1. Perform a cut on the horizontal line 1 on `2 x 1` subgrid with cost 3. Perform a cut on the horizontal line 1 on `2 x 1` subgrid with cost 3. The total cost is `5 + 1 + 1 + 3 + 3 = 13`. **Example 2:** **Input:** m = 2, n = 2, horizontalCut = [7], verticalCut = [4] **Output:** 15 **Explanation:** Perform a cut on the horizontal line 0 with cost 7. Perform a cut on the vertical line 0 on `1 x 2` subgrid with cost 4. Perform a cut on the vertical line 0 on `1 x 2` subgrid with cost 4. The total cost is `7 + 4 + 4 = 15`. **Constraints:** `1 <= m, n <= 20` `horizontalCut.length == m - 1` `verticalCut.length == n - 1` `1 <= horizontalCut[i], verticalCut[i] <= 103`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "m = 3, n = 2, horizontalCut = [1,3], verticalCut = [5]",
+            "output": "13 "
+        },
+        {
+            "label": "Example 2",
+            "input": "m = 2, n = 2, horizontalCut = [7], verticalCut = [4]",
+            "output": "15 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                9,
+                19,
+                [],
+                []
+            ],
+            "output": 7332
+        },
+        {
+            "input": [
+                13,
+                20,
+                [],
+                []
+            ],
+            "output": 9876
+        },
+        {
+            "input": [
+                1,
+                14,
+                [],
+                []
+            ],
+            "output": 815
+        },
+        {
+            "input": [
+                15,
+                1,
+                [],
+                []
+            ],
+            "output": 826
+        },
+        {
+            "input": [
+                13,
+                7,
+                [],
+                []
+            ],
+            "output": 4489
+        },
+        {
+            "input": [
+                18,
+                20,
+                [],
+                []
+            ],
+            "output": 9671
+        },
+        {
+            "input": [
+                8,
+                17,
+                [],
+                []
+            ],
+            "output": 4105
+        },
+        {
+            "input": [
+                17,
+                17,
+                [],
+                []
+            ],
+            "output": 11577
+        },
+        {
+            "input": [
+                16,
+                7,
+                [],
+                []
+            ],
+            "output": 5144
+        },
+        {
+            "input": [
+                11,
+                9,
+                [],
+                []
+            ],
+            "output": 3790
+        }
+    ],
+    "haskell_template": "minimumCost :: Int -> Int -> [Int] -> [Int] -> Int\nminimumCost m n horizontalCut verticalCut ",
+    "ocaml_template": "let minimumCost (m: int) (n: int) (horizontalCut: int list) (verticalCut: int list) : int =  ",
+    "scala_template": "def minimumCost(m: Int,n: Int,horizontalCut: List[Int],verticalCut: List[Int]): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public int minimumCost(int m, int n, int[] horizontalCut, int[] verticalCut) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def minimumCost(self, m, n, horizontalCut, verticalCut):\n        \"\"\"\n        :type m: int\n        :type n: int\n        :type horizontalCut: List[int]\n        :type verticalCut: List[int]\n        :rtype: int\n        \"\"\"\n        "
+}

minimum_cost_for_cutting_cake_i/ocaml_tests/main.ml

@@ -0,0 +1,50 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 13 (minimumCost 3 2 [1;3] [5])
+
+let test2 _ = assert_equal 15 (minimumCost 2 2 [7] [4])
+
+let test3 _ = assert_equal 7332 (minimumCost 9 19 [] [])
+
+let test4 _ = assert_equal 9876 (minimumCost 13 20 [] [])
+
+let test5 _ = assert_equal 815 (minimumCost 1 14 [] [])
+
+let test6 _ = assert_equal 826 (minimumCost 15 1 [] [])
+
+let test7 _ = assert_equal 4489 (minimumCost 13 7 [] [])
+
+let test8 _ = assert_equal 9671 (minimumCost 18 20 [] [])
+
+let test9 _ = assert_equal 4105 (minimumCost 8 17 [] [])
+
+let test10 _ = assert_equal 11577 (minimumCost 17 17 [] [])
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for minimumCost" >::: [
+        
+  "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_cost_for_cutting_cake_i/scala_tests/MySuite.scala

@@ -0,0 +1,44 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.minimumCost(3,2,List(1,3),List(5)), 13)
+  }
+
+  test("test2") {
+    assertEquals(Main.minimumCost(2,2,List(7),List(4)), 15)
+  }
+
+  test("test3") {
+    assertEquals(Main.minimumCost(9,19,List(),List()), 7332)
+  }
+
+  test("test4") {
+    assertEquals(Main.minimumCost(13,20,List(),List()), 9876)
+  }
+
+  test("test5") {
+    assertEquals(Main.minimumCost(1,14,List(),List()), 815)
+  }
+
+  test("test6") {
+    assertEquals(Main.minimumCost(15,1,List(),List()), 826)
+  }
+
+  test("test7") {
+    assertEquals(Main.minimumCost(13,7,List(),List()), 4489)
+  }
+
+  test("test8") {
+    assertEquals(Main.minimumCost(18,20,List(),List()), 9671)
+  }
+
+  test("test9") {
+    assertEquals(Main.minimumCost(8,17,List(),List()), 4105)
+  }
+
+  test("test10") {
+    assertEquals(Main.minimumCost(17,17,List(),List()), 11577)
+  }
+
+}

minimum_cost_for_cutting_cake_ii/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 (minimumCost 3 2 [1,3] [5])," 13 (minimumCost 3 2 [1,3] [5]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (minimumCost 2 2 [7] [4])," 15 (minimumCost 2 2 [7] [4]))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (minimumCost 89625 86605 [] [])," 270184373677 (minimumCost 89625 86605 [] []))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (minimumCost 24520 74173 [] [])," 63056735664 (minimumCost 24520 74173 [] []))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (minimumCost 86957 32234 [] [])," 97433797491 (minimumCost 86957 32234 [] []))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (minimumCost 85068 26951 [] [])," 79683655056 (minimumCost 85068 26951 [] []))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (minimumCost 9975 93053 [] [])," 32327998720 (minimumCost 9975 93053 [] []))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (minimumCost 32757 15609 [] [])," 17891510836 (minimumCost 32757 15609 [] []))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (minimumCost 11492 52523 [] [])," 21084351324 (minimumCost 11492 52523 [] []))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1, TestLabel "Test2" test2, TestLabel "Test3" test3, TestLabel "Test4" test4, TestLabel "Test5" test5, TestLabel "Test6" test6, TestLabel "Test7" test7, TestLabel "Test8" test8, TestLabel "Test9" test9]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

minimum_cost_for_cutting_cake_ii/java_tests/Main.java

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

minimum_cost_for_cutting_cake_ii/meta.json

@@ -0,0 +1,117 @@
+{
+    "id": 3500,
+    "name": "minimum_cost_for_cutting_cake_ii",
+    "difficulty": "Hard",
+    "link": "https://leetcode.com/problems/minimum-cost-for-cutting-cake-ii/",
+    "date": "2024-07-07 00:00:00",
+    "task_description": "There is an `m x n` cake that needs to be cut into `1 x 1` pieces. You are given integers `m`, `n`, and two arrays: `horizontalCut` of size `m - 1`, where `horizontalCut[i]` represents the cost to cut along the horizontal line `i`. `verticalCut` of size `n - 1`, where `verticalCut[j]` represents the cost to cut along the vertical line `j`. In one operation, you can choose any piece of cake that is not yet a `1 x 1` square and perform one of the following cuts: Cut along a horizontal line `i` at a cost of `horizontalCut[i]`. Cut along a vertical line `j` at a cost of `verticalCut[j]`. After the cut, the piece of cake is divided into two distinct pieces. The cost of a cut depends only on the initial cost of the line and does not change. Return the **minimum** total cost to cut the entire cake into `1 x 1` pieces. **Example 1:** **Input:** m = 3, n = 2, horizontalCut = [1,3], verticalCut = [5] **Output:** 13 **Explanation:** Perform a cut on the vertical line 0 with cost 5, current total cost is 5. Perform a cut on the horizontal line 0 on `3 x 1` subgrid with cost 1. Perform a cut on the horizontal line 0 on `3 x 1` subgrid with cost 1. Perform a cut on the horizontal line 1 on `2 x 1` subgrid with cost 3. Perform a cut on the horizontal line 1 on `2 x 1` subgrid with cost 3. The total cost is `5 + 1 + 1 + 3 + 3 = 13`. **Example 2:** **Input:** m = 2, n = 2, horizontalCut = [7], verticalCut = [4] **Output:** 15 **Explanation:** Perform a cut on the horizontal line 0 with cost 7. Perform a cut on the vertical line 0 on `1 x 2` subgrid with cost 4. Perform a cut on the vertical line 0 on `1 x 2` subgrid with cost 4. The total cost is `7 + 4 + 4 = 15`. **Constraints:** `1 <= m, n <= 105` `horizontalCut.length == m - 1` `verticalCut.length == n - 1` `1 <= horizontalCut[i], verticalCut[i] <= 103`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "m = 3, n = 2, horizontalCut = [1,3], verticalCut = [5]",
+            "output": "13 "
+        },
+        {
+            "label": "Example 2",
+            "input": "m = 2, n = 2, horizontalCut = [7], verticalCut = [4]",
+            "output": "15 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                89625,
+                86605,
+                [],
+                []
+            ],
+            "output": 270184373677
+        },
+        {
+            "input": [
+                24520,
+                74173,
+                [],
+                []
+            ],
+            "output": 63056735664
+        },
+        {
+            "input": [
+                86957,
+                32234,
+                [],
+                []
+            ],
+            "output": 97433797491
+        },
+        {
+            "input": [
+                85068,
+                26951,
+                [],
+                []
+            ],
+            "output": 79683655056
+        },
+        {
+            "input": [
+                9975,
+                93053,
+                [],
+                []
+            ],
+            "output": 32327998720
+        },
+        {
+            "input": [
+                32757,
+                15609,
+                [],
+                []
+            ],
+            "output": 17891510836
+        },
+        {
+            "input": [
+                11492,
+                52523,
+                [],
+                []
+            ],
+            "output": 21084351324
+        },
+        {
+            "input": [
+                84008,
+                3918,
+                [],
+                []
+            ],
+            "output": 11524807547
+        },
+        {
+            "input": [
+                73955,
+                16674,
+                [],
+                []
+            ],
+            "output": 42937148241
+        },
+        {
+            "input": [
+                30041,
+                32034,
+                [],
+                []
+            ],
+            "output": 33349734393
+        }
+    ],
+    "haskell_template": "minimumCost :: Int -> Int -> [Int] -> [Int] -> Int\nminimumCost m n horizontalCut verticalCut ",
+    "ocaml_template": "let minimumCost (m: int) (n: int) (horizontalCut: int list) (verticalCut: int list) : int =  ",
+    "scala_template": "def minimumCost(m: Int,n: Int,horizontalCut: List[Int],verticalCut: List[Int]): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public long minimumCost(int m, int n, int[] horizontalCut, int[] verticalCut) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def minimumCost(self, m, n, horizontalCut, verticalCut):\n        \"\"\"\n        :type m: int\n        :type n: int\n        :type horizontalCut: List[int]\n        :type verticalCut: List[int]\n        :rtype: int\n        \"\"\"\n        "
+}

minimum_cost_for_cutting_cake_ii/ocaml_tests/main.ml

@@ -0,0 +1,50 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 13 (minimumCost 3 2 [1;3] [5])
+
+let test2 _ = assert_equal 15 (minimumCost 2 2 [7] [4])
+
+let test3 _ = assert_equal 270184373677 (minimumCost 89625 86605 [] [])
+
+let test4 _ = assert_equal 63056735664 (minimumCost 24520 74173 [] [])
+
+let test5 _ = assert_equal 97433797491 (minimumCost 86957 32234 [] [])
+
+let test6 _ = assert_equal 79683655056 (minimumCost 85068 26951 [] [])
+
+let test7 _ = assert_equal 32327998720 (minimumCost 9975 93053 [] [])
+
+let test8 _ = assert_equal 17891510836 (minimumCost 32757 15609 [] [])
+
+let test9 _ = assert_equal 21084351324 (minimumCost 11492 52523 [] [])
+
+let test10 _ = assert_equal 11524807547 (minimumCost 84008 3918 [] [])
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for minimumCost" >::: [
+        
+  "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_cost_for_cutting_cake_ii/scala_tests/MySuite.scala

@@ -0,0 +1,44 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.minimumCost(3,2,List(1,3),List(5)), 13)
+  }
+
+  test("test2") {
+    assertEquals(Main.minimumCost(2,2,List(7),List(4)), 15)
+  }
+
+  test("test3") {
+    assertEquals(Main.minimumCost(89625,86605,List(),List()), BigInt("270184373677"))
+  }
+
+  test("test4") {
+    assertEquals(Main.minimumCost(24520,74173,List(),List()), BigInt("63056735664"))
+  }
+
+  test("test5") {
+    assertEquals(Main.minimumCost(86957,32234,List(),List()), BigInt("97433797491"))
+  }
+
+  test("test6") {
+    assertEquals(Main.minimumCost(85068,26951,List(),List()), BigInt("79683655056"))
+  }
+
+  test("test7") {
+    assertEquals(Main.minimumCost(9975,93053,List(),List()), BigInt("32327998720"))
+  }
+
+  test("test8") {
+    assertEquals(Main.minimumCost(32757,15609,List(),List()), BigInt("17891510836"))
+  }
+
+  test("test9") {
+    assertEquals(Main.minimumCost(11492,52523,List(),List()), BigInt("21084351324"))
+  }
+
+  test("test10") {
+    assertEquals(Main.minimumCost(84008,3918,List(),List()), BigInt("11524807547"))
+  }
+
+}

minimum_cost_good_caption/haskell_tests/Main.hs

@@ -0,0 +1,29 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+minCostGoodCaption :: String -> String
+minCostGoodCaption caption = undefined
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (minCostGoodCaption \"cdcd \")," "cccc" (minCostGoodCaption "cdcd"))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (minCostGoodCaption \"aca \")," "aaa" (minCostGoodCaption "aca"))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (minCostGoodCaption \"bc \")," "" (minCostGoodCaption "bc"))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1, TestLabel "Test2" test2]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

minimum_cost_good_caption/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("cdcd", minCostGoodCaption("cdcd"));
+}
+@Test
+public void test2() {
+    assertEquals("aca", minCostGoodCaption("aca"));
+}
+@Test
+public void test3() {
+    assertEquals("bc", minCostGoodCaption("bc"));
+}
+
+}

minimum_cost_good_caption/meta.json

@@ -0,0 +1,31 @@
+{
+    "id": 3701,
+    "name": "minimum_cost_good_caption",
+    "difficulty": "Hard",
+    "link": "https://leetcode.com/problems/minimum-cost-good-caption/",
+    "date": "2025-01-18 00:00:00",
+    "task_description": "You are given a string `caption` of length `n`. A **good** caption is a string where **every** character appears in groups of **at least 3** consecutive occurrences. For example: `\"aaabbb\"` and `\"aaaaccc\"` are **good** captions. `\"aabbb\"` and `\"ccccd\"` are **not** good captions. You can perform the following operation **any** number of times: Choose an index `i` (where `0 <= i < n`) and change the character at that index to either: The character immediately **before** it in the alphabet (if `caption[i] != 'a'`). The character immediately **after** it in the alphabet (if `caption[i] != 'z'`). Your task is to convert the given `caption` into a **good** caption using the **minimum** number of operations, and return it. If there are **multiple** possible good captions, return the **lexicographically smallest** one among them. If it is **impossible** to create a good caption, return an empty string `\"\"`. **Example 1:** **Input:** caption = \"cdcd\" **Output:** \"cccc\" **Explanation:** It can be shown that the given caption cannot be transformed into a good caption with fewer than 2 operations. The possible good captions that can be created using exactly 2 operations are: `\"dddd\"`: Change `caption[0]` and `caption[2]` to their next character `'d'`. `\"cccc\"`: Change `caption[1]` and `caption[3]` to their previous character `'c'`. Since `\"cccc\"` is lexicographically smaller than `\"dddd\"`, return `\"cccc\"`. **Example 2:** **Input:** caption = \"aca\" **Output:** \"aaa\" **Explanation:** It can be proven that the given caption requires at least 2 operations to be transformed into a good caption. The only good caption that can be obtained with exactly 2 operations is as follows: Operation 1: Change `caption[1]` to `'b'`. `caption = \"aba\"`. Operation 2: Change `caption[1]` to `'a'`. `caption = \"aaa\"`. Thus, return `\"aaa\"`. **Example 3:** **Input:** caption = \"bc\" **Output:** \"\" **Explanation:** It can be shown that the given caption cannot be converted to a good caption by using any number of operations. **Constraints:** `1 <= caption.length <= 5 * 104` `caption` consists only of lowercase English letters.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "caption = \"cdcd\"",
+            "output": "\"cccc\" "
+        },
+        {
+            "label": "Example 2",
+            "input": "caption = \"aca\"",
+            "output": "\"aaa\" "
+        },
+        {
+            "label": "Example 3",
+            "input": "caption = \"bc\"",
+            "output": "\"\" "
+        }
+    ],
+    "private_test_cases": [],
+    "haskell_template": "minCostGoodCaption :: String -> String\nminCostGoodCaption caption ",
+    "ocaml_template": "let minCostGoodCaption (caption: string) : string =  ",
+    "scala_template": "def minCostGoodCaption(caption: String): String = { \n    \n}",
+    "java_template": "class Solution {\n    public String minCostGoodCaption(String caption) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def minCostGoodCaption(self, caption):\n        \"\"\"\n        :type caption: str\n        :rtype: str\n        \"\"\"\n        "
+}

minimum_cost_good_caption/ocaml_tests/main.ml

@@ -0,0 +1,30 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+    let minCostGoodCaption (caption: string) : string =   failwith "Not implemented"
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal "cccc" (minCostGoodCaption "cdcd")
+
+let test2 _ = assert_equal "aaa" (minCostGoodCaption "aca")
+
+let test3 _ = assert_equal "" (minCostGoodCaption "bc")
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for minCostGoodCaption" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+  "test3" >:: test3;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

minimum_cost_good_caption/scala_tests/MySuite.scala

@@ -0,0 +1,16 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.minCostGoodCaption("cdcd"), "cccc")
+  }
+
+  test("test2") {
+    assertEquals(Main.minCostGoodCaption("aca"), "aaa")
+  }
+
+  test("test3") {
+    assertEquals(Main.minCostGoodCaption("bc"), "")
+  }
+
+}