b187339e7ae2f691d78aa1c6debf0346a26e463712ff7c1b589c6473ca9fdbc3

.gitattributes

@@ -218,3 +218,5 @@ minimum_cost_to_make_arrays_identical/meta.json filter=lfs diff=lfs merge=lfs -t
 minimum_difference_in_sums_after_removal_of_elements/meta.json filter=lfs diff=lfs merge=lfs -text
 minimum_fuel_cost_to_report_to_the_capital/meta.json filter=lfs diff=lfs merge=lfs -text
 minimum_impossible_or/meta.json filter=lfs diff=lfs merge=lfs -text
+minimum_lines_to_represent_a_line_chart/meta.json filter=lfs diff=lfs merge=lfs -text
+minimum_money_required_before_transactions/meta.json filter=lfs diff=lfs merge=lfs -text

minimum_impossible_or/scala_tests/MySuite.scala

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

minimum_increment_operations_to_make_array_beautiful/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 (minIncrementOperations [2,3,0,0,2] 4)," 3 (minIncrementOperations [2,3,0,0,2] 4))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (minIncrementOperations [0,1,3,3] 5)," 2 (minIncrementOperations [0,1,3,3] 5))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (minIncrementOperations [1,1,2] 1)," 0 (minIncrementOperations [1,1,2] 1))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (minIncrementOperations [462325066, 206420187, 521315460, 318264093, 66475813, 619438353, 499937120, 9685155, 2855537, 913944240] 373173460)," 0 (minIncrementOperations [462325066, 206420187, 521315460, 318264093, 66475813, 619438353, 499937120, 9685155, 2855537, 913944240] 373173460))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (minIncrementOperations [317576829, 230943442, 194377313, 217961295, 179889103, 421788827, 346731151, 31378563, 457215528] 663944532)," 918451928 (minIncrementOperations [317576829, 230943442, 194377313, 217961295, 179889103, 421788827, 346731151, 31378563, 457215528] 663944532))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (minIncrementOperations [554240499, 168910099, 370475323, 72793279, 181768111, 415255001] 179842580)," 0 (minIncrementOperations [554240499, 168910099, 370475323, 72793279, 181768111, 415255001] 179842580))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (minIncrementOperations [168413874, 337615557, 757898546, 697884066, 97110609, 987627695, 755555424, 530718081, 976002691] 944893763)," 186995217 (minIncrementOperations [168413874, 337615557, 757898546, 697884066, 97110609, 987627695, 755555424, 530718081, 976002691] 944893763))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (minIncrementOperations [484598604, 491482864, 339460418, 940057113, 528767250, 102185549] 189117733)," 0 (minIncrementOperations [484598604, 491482864, 339460418, 940057113, 528767250, 102185549] 189117733))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (minIncrementOperations [719164977, 892326581, 957540324, 991726451, 280307765, 41099724, 871482641] 740459607)," 0 (minIncrementOperations [719164977, 892326581, 957540324, 991726451, 280307765, 41099724, 871482641] 740459607))
+
+
+-- 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_increment_operations_to_make_array_beautiful/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(3, minIncrementOperations(new ArrayList<>(Arrays.asList(2,3,0,0,2)), 4));
+}
+@Test
+public void test2() {
+    assertEquals(2, minIncrementOperations(new ArrayList<>(Arrays.asList(0,1,3,3)), 5));
+}
+@Test
+public void test3() {
+    assertEquals(0, minIncrementOperations(new ArrayList<>(Arrays.asList(1,1,2)), 1));
+}
+
+}

minimum_increment_operations_to_make_array_beautiful/meta.json

@@ -0,0 +1,184 @@
+{
+    "id": 3178,
+    "name": "minimum_increment_operations_to_make_array_beautiful",
+    "difficulty": "Medium",
+    "link": "https://leetcode.com/problems/minimum-increment-operations-to-make-array-beautiful/",
+    "date": "2023-10-22 00:00:00",
+    "task_description": "You are given a **0-indexed** integer array `nums` having length `n`, and an integer `k`. You can perform the following **increment** operation **any** number of times (**including zero**): Choose an index `i` in the range `[0, n - 1]`, and increase `nums[i]` by `1`. An array is considered **beautiful** if, for any **subarray** with a size of `3` or **more**, its **maximum** element is **greater than or equal** to `k`. Return _an integer denoting the **minimum** number of increment operations needed to make _`nums`_ **beautiful**._ A subarray is a contiguous **non-empty** sequence of elements within an array. **Example 1:** ``` **Input:** nums = [2,3,0,0,2], k = 4 **Output:** 3 **Explanation:** We can perform the following increment operations to make nums beautiful: Choose index i = 1 and increase nums[1] by 1 -> [2,4,0,0,2]. Choose index i = 4 and increase nums[4] by 1 -> [2,4,0,0,3]. Choose index i = 4 and increase nums[4] by 1 -> [2,4,0,0,4]. The subarrays with a size of 3 or more are: [2,4,0], [4,0,0], [0,0,4], [2,4,0,0], [4,0,0,4], [2,4,0,0,4]. In all the subarrays, the maximum element is equal to k = 4, so nums is now beautiful. It can be shown that nums cannot be made beautiful with fewer than 3 increment operations. Hence, the answer is 3. ``` **Example 2:** ``` **Input:** nums = [0,1,3,3], k = 5 **Output:** 2 **Explanation:** We can perform the following increment operations to make nums beautiful: Choose index i = 2 and increase nums[2] by 1 -> [0,1,4,3]. Choose index i = 2 and increase nums[2] by 1 -> [0,1,5,3]. The subarrays with a size of 3 or more are: [0,1,5], [1,5,3], [0,1,5,3]. In all the subarrays, the maximum element is equal to k = 5, so nums is now beautiful. It can be shown that nums cannot be made beautiful with fewer than 2 increment operations. Hence, the answer is 2. ``` **Example 3:** ``` **Input:** nums = [1,1,2], k = 1 **Output:** 0 **Explanation:** The only subarray with a size of 3 or more in this example is [1,1,2]. The maximum element, 2, is already greater than k = 1, so we don't need any increment operation. Hence, the answer is 0. ``` **Constraints:** `3 <= n == nums.length <= 105` `0 <= nums[i] <= 109` `0 <= k <= 109`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "nums = [2,3,0,0,2], k = 4",
+            "output": "3 "
+        },
+        {
+            "label": "Example 2",
+            "input": "nums = [0,1,3,3], k = 5",
+            "output": "2 "
+        },
+        {
+            "label": "Example 3",
+            "input": "nums = [1,1,2], k = 1",
+            "output": "0 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                [
+                    462325066,
+                    206420187,
+                    521315460,
+                    318264093,
+                    66475813,
+                    619438353,
+                    499937120,
+                    9685155,
+                    2855537,
+                    913944240
+                ],
+                373173460
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                [
+                    317576829,
+                    230943442,
+                    194377313,
+                    217961295,
+                    179889103,
+                    421788827,
+                    346731151,
+                    31378563,
+                    457215528
+                ],
+                663944532
+            ],
+            "output": 918451928
+        },
+        {
+            "input": [
+                [
+                    554240499,
+                    168910099,
+                    370475323,
+                    72793279,
+                    181768111,
+                    415255001
+                ],
+                179842580
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                [
+                    168413874,
+                    337615557,
+                    757898546,
+                    697884066,
+                    97110609,
+                    987627695,
+                    755555424,
+                    530718081,
+                    976002691
+                ],
+                944893763
+            ],
+            "output": 186995217
+        },
+        {
+            "input": [
+                [
+                    484598604,
+                    491482864,
+                    339460418,
+                    940057113,
+                    528767250,
+                    102185549
+                ],
+                189117733
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                [
+                    719164977,
+                    892326581,
+                    957540324,
+                    991726451,
+                    280307765,
+                    41099724,
+                    871482641
+                ],
+                740459607
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                [
+                    49010645,
+                    338826954,
+                    801318173,
+                    348190584,
+                    354157732,
+                    232141023
+                ],
+                94104474
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                [
+                    305762391,
+                    417436427,
+                    338549371,
+                    153703212
+                ],
+                649513426
+            ],
+            "output": 232076999
+        },
+        {
+            "input": [
+                [
+                    220369410,
+                    282934213,
+                    198247569,
+                    726195262,
+                    41979645,
+                    117267716,
+                    555256808,
+                    683741535,
+                    880011605,
+                    218580428
+                ],
+                493276257
+            ],
+            "output": 210342044
+        },
+        {
+            "input": [
+                [
+                    902477971,
+                    881152273,
+                    639491946,
+                    510273653,
+                    365179409
+                ],
+                422822051
+            ],
+            "output": 0
+        }
+    ],
+    "haskell_template": "minIncrementOperations :: [Int] -> Int -> Int\nminIncrementOperations nums k ",
+    "ocaml_template": "let minIncrementOperations (nums: int list) (k: int) : int =  ",
+    "scala_template": "def minIncrementOperations(nums: List[Int],k: Int): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public long minIncrementOperations(int[] nums, int k) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def minIncrementOperations(self, nums, k):\n        \"\"\"\n        :type nums: List[int]\n        :type k: int\n        :rtype: int\n        \"\"\"\n        "
+}

minimum_increment_operations_to_make_array_beautiful/ocaml_tests/main.ml

@@ -0,0 +1,50 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 3 (minIncrementOperations [2;3;0;0;2] 4)
+
+let test2 _ = assert_equal 2 (minIncrementOperations [0;1;3;3] 5)
+
+let test3 _ = assert_equal 0 (minIncrementOperations [1;1;2] 1)
+
+let test4 _ = assert_equal 0 (minIncrementOperations [462325066; 206420187; 521315460; 318264093; 66475813; 619438353; 499937120; 9685155; 2855537; 913944240] 373173460)
+
+let test5 _ = assert_equal 918451928 (minIncrementOperations [317576829; 230943442; 194377313; 217961295; 179889103; 421788827; 346731151; 31378563; 457215528] 663944532)
+
+let test6 _ = assert_equal 0 (minIncrementOperations [554240499; 168910099; 370475323; 72793279; 181768111; 415255001] 179842580)
+
+let test7 _ = assert_equal 186995217 (minIncrementOperations [168413874; 337615557; 757898546; 697884066; 97110609; 987627695; 755555424; 530718081; 976002691] 944893763)
+
+let test8 _ = assert_equal 0 (minIncrementOperations [484598604; 491482864; 339460418; 940057113; 528767250; 102185549] 189117733)
+
+let test9 _ = assert_equal 0 (minIncrementOperations [719164977; 892326581; 957540324; 991726451; 280307765; 41099724; 871482641] 740459607)
+
+let test10 _ = assert_equal 0 (minIncrementOperations [49010645; 338826954; 801318173; 348190584; 354157732; 232141023] 94104474)
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for minIncrementOperations" >::: [
+        
+  "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_increment_operations_to_make_array_beautiful/scala_tests/MySuite.scala

@@ -0,0 +1,44 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.minIncrementOperations(List(2,3,0,0,2),4), 3)
+  }
+
+  test("test2") {
+    assertEquals(Main.minIncrementOperations(List(0,1,3,3),5), 2)
+  }
+
+  test("test3") {
+    assertEquals(Main.minIncrementOperations(List(1,1,2),1), 0)
+  }
+
+  test("test4") {
+    assertEquals(Main.minIncrementOperations(List(462325066, 206420187, 521315460, 318264093, 66475813, 619438353, 499937120, 9685155, 2855537, 913944240),373173460), 0)
+  }
+
+  test("test5") {
+    assertEquals(Main.minIncrementOperations(List(317576829, 230943442, 194377313, 217961295, 179889103, 421788827, 346731151, 31378563, 457215528),663944532), 918451928)
+  }
+
+  test("test6") {
+    assertEquals(Main.minIncrementOperations(List(554240499, 168910099, 370475323, 72793279, 181768111, 415255001),179842580), 0)
+  }
+
+  test("test7") {
+    assertEquals(Main.minIncrementOperations(List(168413874, 337615557, 757898546, 697884066, 97110609, 987627695, 755555424, 530718081, 976002691),944893763), 186995217)
+  }
+
+  test("test8") {
+    assertEquals(Main.minIncrementOperations(List(484598604, 491482864, 339460418, 940057113, 528767250, 102185549),189117733), 0)
+  }
+
+  test("test9") {
+    assertEquals(Main.minIncrementOperations(List(719164977, 892326581, 957540324, 991726451, 280307765, 41099724, 871482641),740459607), 0)
+  }
+
+  test("test10") {
+    assertEquals(Main.minIncrementOperations(List(49010645, 338826954, 801318173, 348190584, 354157732, 232141023),94104474), 0)
+  }
+
+}

minimum_increments_for_target_multiples_in_an_array/java_tests/Main.java

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

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

minimum_index_of_a_valid_split/java_tests/Main.java

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

minimum_index_of_a_valid_split/ocaml_tests/main.ml

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

minimum_index_of_a_valid_split/scala_tests/MySuite.scala

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

minimum_length_of_anagram_concatenation/java_tests/Main.java

@@ -0,0 +1,20 @@
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+import java.util.List;
+import java.util.Arrays;
+public class Main {
+    //Program start
+
+    //Program end
+
+    @Test
+public void test1() {
+    assertEquals(2, minAnagramLength("abba"));
+}
+@Test
+public void test2() {
+    assertEquals(4, minAnagramLength("cdef"));
+}
+
+}

minimum_length_of_string_after_operations/java_tests/Main.java

@@ -0,0 +1,20 @@
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+import java.util.List;
+import java.util.Arrays;
+public class Main {
+    //Program start
+
+    //Program end
+
+    @Test
+public void test1() {
+    assertEquals(5, minimumLength("abaacbcbb"));
+}
+@Test
+public void test2() {
+    assertEquals(2, minimumLength("aa"));
+}
+
+}

minimum_levels_to_gain_more_points/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(1, minimumLevels(Arrays.asList(1,0,1,0)));
+}
+@Test
+public void test2() {
+    assertEquals(3, minimumLevels(Arrays.asList(1,1,1,1,1)));
+}
+@Test
+public void test3() {
+    assertEquals(-1, minimumLevels(Arrays.asList(0,0)));
+}
+
+}

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

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

minimum_lines_to_represent_a_line_chart/meta.json

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

minimum_lines_to_represent_a_line_chart/ocaml_tests/main.ml

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

minimum_lines_to_represent_a_line_chart/scala_tests/MySuite.scala

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

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

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

minimum_money_required_before_transactions/meta.json

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

minimum_money_required_before_transactions/ocaml_tests/main.ml

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

minimum_money_required_before_transactions/scala_tests/MySuite.scala

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

minimum_moves_to_capture_the_queen/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 (minMovesToCaptureTheQueen 1 1 8 8 2 3)," 2 (minMovesToCaptureTheQueen 1 1 8 8 2 3))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (minMovesToCaptureTheQueen 5 3 3 4 5 2)," 1 (minMovesToCaptureTheQueen 5 3 3 4 5 2))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (minMovesToCaptureTheQueen 8 4 6 7 2 1)," 2 (minMovesToCaptureTheQueen 8 4 6 7 2 1))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (minMovesToCaptureTheQueen 4 7 1 4 4 1)," 1 (minMovesToCaptureTheQueen 4 7 1 4 4 1))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (minMovesToCaptureTheQueen 3 7 3 5 5 8)," 2 (minMovesToCaptureTheQueen 3 7 3 5 5 8))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (minMovesToCaptureTheQueen 6 2 4 4 4 6)," 2 (minMovesToCaptureTheQueen 6 2 4 4 4 6))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (minMovesToCaptureTheQueen 7 3 3 4 5 3)," 1 (minMovesToCaptureTheQueen 7 3 3 4 5 3))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (minMovesToCaptureTheQueen 8 6 2 1 1 3)," 2 (minMovesToCaptureTheQueen 8 6 2 1 1 3))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (minMovesToCaptureTheQueen 6 8 1 1 6 3)," 1 (minMovesToCaptureTheQueen 6 8 1 1 6 3))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1, TestLabel "Test2" test2, TestLabel "Test3" test3, TestLabel "Test4" test4, TestLabel "Test5" test5, TestLabel "Test6" test6, TestLabel "Test7" test7, TestLabel "Test8" test8, TestLabel "Test9" test9]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

minimum_moves_to_capture_the_queen/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, minMovesToCaptureTheQueen(1, 1, 8, 8, 2, 3));
+}
+@Test
+public void test2() {
+    assertEquals(1, minMovesToCaptureTheQueen(5, 3, 3, 4, 5, 2));
+}
+
+}

minimum_moves_to_capture_the_queen/meta.json

@@ -0,0 +1,137 @@
+{
+    "id": 3270,
+    "name": "minimum_moves_to_capture_the_queen",
+    "difficulty": "Medium",
+    "link": "https://leetcode.com/problems/minimum-moves-to-capture-the-queen/",
+    "date": "2023-12-31 00:00:00",
+    "task_description": "There is a **1-indexed** `8 x 8` chessboard containing `3` pieces. You are given `6` integers `a`, `b`, `c`, `d`, `e`, and `f` where: `(a, b)` denotes the position of the white rook. `(c, d)` denotes the position of the white bishop. `(e, f)` denotes the position of the black queen. Given that you can only move the white pieces, return _the **minimum** number of moves required to capture the black queen_. **Note** that: Rooks can move any number of squares either vertically or horizontally, but cannot jump over other pieces. Bishops can move any number of squares diagonally, but cannot jump over other pieces. A rook or a bishop can capture the queen if it is located in a square that they can move to. The queen does not move. **Example 1:** ``` **Input:** a = 1, b = 1, c = 8, d = 8, e = 2, f = 3 **Output:** 2 **Explanation:** We can capture the black queen in two moves by moving the white rook to (1, 3) then to (2, 3). It is impossible to capture the black queen in less than two moves since it is not being attacked by any of the pieces at the beginning. ``` **Example 2:** ``` **Input:** a = 5, b = 3, c = 3, d = 4, e = 5, f = 2 **Output:** 1 **Explanation:** We can capture the black queen in a single move by doing one of the following: - Move the white rook to (5, 2). - Move the white bishop to (5, 2). ``` **Constraints:** `1 <= a, b, c, d, e, f <= 8` No two pieces are on the same square.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "a = 1, b = 1, c = 8, d = 8, e = 2, f = 3",
+            "output": "2 "
+        },
+        {
+            "label": "Example 2",
+            "input": "a = 5, b = 3, c = 3, d = 4, e = 5, f = 2",
+            "output": "1 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                8,
+                4,
+                6,
+                7,
+                2,
+                1
+            ],
+            "output": 2
+        },
+        {
+            "input": [
+                4,
+                7,
+                1,
+                4,
+                4,
+                1
+            ],
+            "output": 1
+        },
+        {
+            "input": [
+                3,
+                7,
+                3,
+                5,
+                5,
+                8
+            ],
+            "output": 2
+        },
+        {
+            "input": [
+                6,
+                2,
+                4,
+                4,
+                4,
+                6
+            ],
+            "output": 2
+        },
+        {
+            "input": [
+                7,
+                3,
+                3,
+                4,
+                5,
+                3
+            ],
+            "output": 1
+        },
+        {
+            "input": [
+                8,
+                6,
+                2,
+                1,
+                1,
+                3
+            ],
+            "output": 2
+        },
+        {
+            "input": [
+                6,
+                8,
+                1,
+                1,
+                6,
+                3
+            ],
+            "output": 1
+        },
+        {
+            "input": [
+                2,
+                4,
+                6,
+                7,
+                1,
+                3
+            ],
+            "output": 2
+        },
+        {
+            "input": [
+                7,
+                1,
+                4,
+                7,
+                7,
+                5
+            ],
+            "output": 1
+        },
+        {
+            "input": [
+                3,
+                4,
+                1,
+                5,
+                6,
+                2
+            ],
+            "output": 2
+        }
+    ],
+    "haskell_template": "minMovesToCaptureTheQueen :: Int -> Int -> Int -> Int -> Int -> Int -> Int\nminMovesToCaptureTheQueen a b c d e f ",
+    "ocaml_template": "let minMovesToCaptureTheQueen (a: int) (b: int) (c: int) (d: int) (e: int) (f: int) : int =  ",
+    "scala_template": "def minMovesToCaptureTheQueen(a: Int,b: Int,c: Int,d: Int,e: Int,f: Int): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public int minMovesToCaptureTheQueen(int a, int b, int c, int d, int e, int f) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def minMovesToCaptureTheQueen(self, a, b, c, d, e, f):\n        \"\"\"\n        :type a: int\n        :type b: int\n        :type c: int\n        :type d: int\n        :type e: int\n        :type f: int\n        :rtype: int\n        \"\"\"\n        "
+}

minimum_moves_to_capture_the_queen/ocaml_tests/main.ml

@@ -0,0 +1,50 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 2 (minMovesToCaptureTheQueen 1 1 8 8 2 3)
+
+let test2 _ = assert_equal 1 (minMovesToCaptureTheQueen 5 3 3 4 5 2)
+
+let test3 _ = assert_equal 2 (minMovesToCaptureTheQueen 8 4 6 7 2 1)
+
+let test4 _ = assert_equal 1 (minMovesToCaptureTheQueen 4 7 1 4 4 1)
+
+let test5 _ = assert_equal 2 (minMovesToCaptureTheQueen 3 7 3 5 5 8)
+
+let test6 _ = assert_equal 2 (minMovesToCaptureTheQueen 6 2 4 4 4 6)
+
+let test7 _ = assert_equal 1 (minMovesToCaptureTheQueen 7 3 3 4 5 3)
+
+let test8 _ = assert_equal 2 (minMovesToCaptureTheQueen 8 6 2 1 1 3)
+
+let test9 _ = assert_equal 1 (minMovesToCaptureTheQueen 6 8 1 1 6 3)
+
+let test10 _ = assert_equal 2 (minMovesToCaptureTheQueen 2 4 6 7 1 3)
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for minMovesToCaptureTheQueen" >::: [
+        
+  "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_moves_to_capture_the_queen/scala_tests/MySuite.scala

@@ -0,0 +1,44 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.minMovesToCaptureTheQueen(1,1,8,8,2,3), 2)
+  }
+
+  test("test2") {
+    assertEquals(Main.minMovesToCaptureTheQueen(5,3,3,4,5,2), 1)
+  }
+
+  test("test3") {
+    assertEquals(Main.minMovesToCaptureTheQueen(8,4,6,7,2,1), 2)
+  }
+
+  test("test4") {
+    assertEquals(Main.minMovesToCaptureTheQueen(4,7,1,4,4,1), 1)
+  }
+
+  test("test5") {
+    assertEquals(Main.minMovesToCaptureTheQueen(3,7,3,5,5,8), 2)
+  }
+
+  test("test6") {
+    assertEquals(Main.minMovesToCaptureTheQueen(6,2,4,4,4,6), 2)
+  }
+
+  test("test7") {
+    assertEquals(Main.minMovesToCaptureTheQueen(7,3,3,4,5,3), 1)
+  }
+
+  test("test8") {
+    assertEquals(Main.minMovesToCaptureTheQueen(8,6,2,1,1,3), 2)
+  }
+
+  test("test9") {
+    assertEquals(Main.minMovesToCaptureTheQueen(6,8,1,1,6,3), 1)
+  }
+
+  test("test10") {
+    assertEquals(Main.minMovesToCaptureTheQueen(2,4,6,7,1,3), 2)
+  }
+
+}