ece040cec26d5826aa5bd6f2dee393fb1cbbc5499c3603466ca7aeec86debd37

.gitattributes

@@ -227,3 +227,9 @@ minimum_number_of_operations_to_satisfy_conditions/meta.json filter=lfs diff=lfs
 minimum_operations_to_exceed_threshold_value_ii/haskell_tests/Main.hs filter=lfs diff=lfs merge=lfs -text
 minimum_operations_to_exceed_threshold_value_ii/meta.json filter=lfs diff=lfs merge=lfs -text
 minimum_operations_to_halve_array_sum/meta.json filter=lfs diff=lfs merge=lfs -text
+minimum_operations_to_make_array_equal_ii/meta.json filter=lfs diff=lfs merge=lfs -text
+minimum_operations_to_make_array_equal_to_target/haskell_tests/Main.hs filter=lfs diff=lfs merge=lfs -text
+minimum_operations_to_make_array_equal_to_target/meta.json filter=lfs diff=lfs merge=lfs -text
+minimum_operations_to_make_median_of_array_equal_to_k/haskell_tests/Main.hs filter=lfs diff=lfs merge=lfs -text
+minimum_operations_to_make_median_of_array_equal_to_k/meta.json filter=lfs diff=lfs merge=lfs -text
+minimum_operations_to_make_the_array_alternating/meta.json filter=lfs diff=lfs merge=lfs -text

minimum_operations_to_make_all_array_elements_equal/meta.json

@@ -0,0 +1,26 @@
+{
+    "id": 2718,
+    "name": "minimum_operations_to_make_all_array_elements_equal",
+    "difficulty": "Medium",
+    "link": "https://leetcode.com/problems/minimum-operations-to-make-all-array-elements-equal/",
+    "date": "1679184000000",
+    "task_description": "You are given an array `nums` consisting of positive integers. You are also given an integer array `queries` of size `m`. For the `ith` query, you want to make all of the elements of `nums` equal to` queries[i]`. You can perform the following operation on the array **any** number of times: **Increase** or **decrease** an element of the array by `1`. Return _an array _`answer`_ of size _`m`_ where _`answer[i]`_ is the **minimum** number of operations to make all elements of _`nums`_ equal to _`queries[i]`. **Note** that after each query the array is reset to its original state. **Example 1:** ``` **Input:** nums = [3,1,6,8], queries = [1,5] **Output:** [14,10] **Explanation:** For the first query we can do the following operations: - Decrease nums[0] 2 times, so that nums = [1,1,6,8]. - Decrease nums[2] 5 times, so that nums = [1,1,1,8]. - Decrease nums[3] 7 times, so that nums = [1,1,1,1]. So the total number of operations for the first query is 2 + 5 + 7 = 14. For the second query we can do the following operations: - Increase nums[0] 2 times, so that nums = [5,1,6,8]. - Increase nums[1] 4 times, so that nums = [5,5,6,8]. - Decrease nums[2] 1 time, so that nums = [5,5,5,8]. - Decrease nums[3] 3 times, so that nums = [5,5,5,5]. So the total number of operations for the second query is 2 + 4 + 1 + 3 = 10. ``` **Example 2:** ``` **Input:** nums = [2,9,6,3], queries = [10] **Output:** [20] **Explanation:** We can increase each value in the array to 10. The total number of operations will be 8 + 1 + 4 + 7 = 20. ``` **Constraints:** `n == nums.length` `m == queries.length` `1 <= n, m <= 105` `1 <= nums[i], queries[i] <= 109`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "nums = [3,1,6,8], queries = [1,5]",
+            "output": "[14,10] "
+        },
+        {
+            "label": "Example 2",
+            "input": "nums = [2,9,6,3], queries = [10]",
+            "output": "[20] "
+        }
+    ],
+    "private_test_cases": [],
+    "haskell_template": "minOperations :: [Int] -> [Int] -> [Int]\nminOperations nums queries ",
+    "ocaml_template": "let minOperations (nums: int list) (queries: int list) : int list =  ",
+    "scala_template": "def minOperations(nums: List[Int],queries: List[Int]): List[Int] = { \n    \n}",
+    "java_template": "public static List<Integer> minOperations(List<Integer> nums, List<Integer> queries) {\n\n}",
+    "python_template": "class Solution(object):\n    def minOperations(self, nums, queries):\n        \"\"\"\n        :type nums: List[int]\n        :type queries: List[int]\n        :rtype: List[int]\n        \"\"\"\n        "
+}

minimum_operations_to_make_all_array_elements_equal/ocaml_tests/main.ml

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

minimum_operations_to_make_all_array_elements_equal/scala_tests/MySuite.scala

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

minimum_operations_to_make_array_elements_zero/haskell_tests/Main.hs

@@ -0,0 +1,26 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+minOperations :: [[Int]] -> Int
+minOperations queries = undefined
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (minOperations [[1,2],[2,4]])," 3 (minOperations [[1,2],[2,4]]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (minOperations [[2,6]])," 4 (minOperations [[2,6]]))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

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

minimum_operations_to_make_array_elements_zero/meta.json

@@ -0,0 +1,26 @@
+{
+    "id": 3744,
+    "name": "minimum_operations_to_make_array_elements_zero",
+    "difficulty": "Hard",
+    "link": "https://leetcode.com/problems/minimum-operations-to-make-array-elements-zero/",
+    "date": "2025-03-16 00:00:00",
+    "task_description": "You are given a 2D array `queries`, where `queries[i]` is of the form `[l, r]`. Each `queries[i]` defines an array of integers `nums` consisting of elements ranging from `l` to `r`, both **inclusive**. In one operation, you can: Select two integers `a` and `b` from the array. Replace them with `floor(a / 4)` and `floor(b / 4)`. Your task is to determine the **minimum** number of operations required to reduce all elements of the array to zero for each query. Return the sum of the results for all queries. **Example 1:** **Input:** queries = [[1,2],[2,4]] **Output:** 3 **Explanation:** For `queries[0]`: The initial array is `nums = [1, 2]`. In the first operation, select `nums[0]` and `nums[1]`. The array becomes `[0, 0]`. The minimum number of operations required is 1. For `queries[1]`: The initial array is `nums = [2, 3, 4]`. In the first operation, select `nums[0]` and `nums[2]`. The array becomes `[0, 3, 1]`. In the second operation, select `nums[1]` and `nums[2]`. The array becomes `[0, 0, 0]`. The minimum number of operations required is 2. The output is `1 + 2 = 3`. **Example 2:** **Input:** queries = [[2,6]] **Output:** 4 **Explanation:** For `queries[0]`: The initial array is `nums = [2, 3, 4, 5, 6]`. In the first operation, select `nums[0]` and `nums[3]`. The array becomes `[0, 3, 4, 1, 6]`. In the second operation, select `nums[2]` and `nums[4]`. The array becomes `[0, 3, 1, 1, 1]`. In the third operation, select `nums[1]` and `nums[2]`. The array becomes `[0, 0, 0, 1, 1]`. In the fourth operation, select `nums[3]` and `nums[4]`. The array becomes `[0, 0, 0, 0, 0]`. The minimum number of operations required is 4. The output is 4. **Constraints:** `1 <= queries.length <= 105` `queries[i].length == 2` `queries[i] == [l, r]` `1 <= l < r <= 109`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "queries = [[1,2],[2,4]]",
+            "output": "3 "
+        },
+        {
+            "label": "Example 2",
+            "input": "queries = [[2,6]]",
+            "output": "4 "
+        }
+    ],
+    "private_test_cases": [],
+    "haskell_template": "minOperations :: [[Int]] -> Int\nminOperations queries ",
+    "ocaml_template": "let minOperations (queries: int list list) : int =  ",
+    "scala_template": "def minOperations(queries: List[List[Int]]): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public long minOperations(int[][] queries) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def minOperations(self, queries):\n        \"\"\"\n        :type queries: List[List[int]]\n        :rtype: int\n        \"\"\"\n        "
+}

minimum_operations_to_make_array_elements_zero/ocaml_tests/main.ml

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

minimum_operations_to_make_array_elements_zero/scala_tests/MySuite.scala

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

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

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

minimum_operations_to_make_array_equal_ii/meta.json

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

minimum_operations_to_make_array_equal_ii/ocaml_tests/main.ml

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

minimum_operations_to_make_array_equal_ii/scala_tests/MySuite.scala

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

minimum_operations_to_make_array_equal_to_target/haskell_tests/Main.hs

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

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

minimum_operations_to_make_array_equal_to_target/meta.json

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

minimum_operations_to_make_array_values_equal_to_k/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 (minOperations [5,2,5,4,5] 2)," 2 (minOperations [5,2,5,4,5] 2))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (minOperations [2,1,2] 2)," (-1) (minOperations [2,1,2] 2))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (minOperations [9,7,5,3] 1)," 4 (minOperations [9,7,5,3] 1))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (minOperations [40, 99, 29, 74, 59, 35, 87, 76, 92, 18, 23, 59, 37, 72, 59, 22, 100, 34, 34, 63, 84, 38, 96, 63, 65, 64, 15, 55, 54, 36, 6, 87, 48, 10, 61, 40, 62, 51, 64, 77, 61, 60, 90, 93, 41, 64, 39, 72, 27, 75, 71, 82, 15] 46)," (-1) (minOperations [40, 99, 29, 74, 59, 35, 87, 76, 92, 18, 23, 59, 37, 72, 59, 22, 100, 34, 34, 63, 84, 38, 96, 63, 65, 64, 15, 55, 54, 36, 6, 87, 48, 10, 61, 40, 62, 51, 64, 77, 61, 60, 90, 93, 41, 64, 39, 72, 27, 75, 71, 82, 15] 46))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (minOperations [73, 80, 65, 6, 85, 3, 67, 52, 37, 97, 24, 59, 34, 5, 95, 10, 52, 80, 99, 93, 42, 66, 19, 95, 74, 76, 71, 66, 77, 76, 30, 34, 83, 55, 81, 97, 38, 86, 65, 24, 48, 80, 17, 54, 29, 3, 63, 4, 38, 88, 30, 2, 30, 75, 81, 8, 5, 90, 31] 65)," (-1) (minOperations [73, 80, 65, 6, 85, 3, 67, 52, 37, 97, 24, 59, 34, 5, 95, 10, 52, 80, 99, 93, 42, 66, 19, 95, 74, 76, 71, 66, 77, 76, 30, 34, 83, 55, 81, 97, 38, 86, 65, 24, 48, 80, 17, 54, 29, 3, 63, 4, 38, 88, 30, 2, 30, 75, 81, 8, 5, 90, 31] 65))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (minOperations [63, 21, 26, 82, 95, 2, 100, 69, 52, 67, 67, 78, 36, 22, 17, 76, 2, 10, 65, 61, 20, 49, 27, 63, 74, 99, 56, 85, 30, 94, 56, 66, 78, 99, 10, 30, 68, 39, 34, 27, 83, 18, 23, 18, 27, 30, 26, 1, 78, 16, 16, 19, 31, 98, 30, 95, 10, 10, 20, 5, 80, 6, 39, 14, 98, 21, 9, 33, 82, 13, 33, 33, 42, 73, 29, 67, 17, 76, 19, 92, 55, 69, 56, 35, 71, 70, 39, 44, 38, 19, 100, 4, 54, 31] 68)," (-1) (minOperations [63, 21, 26, 82, 95, 2, 100, 69, 52, 67, 67, 78, 36, 22, 17, 76, 2, 10, 65, 61, 20, 49, 27, 63, 74, 99, 56, 85, 30, 94, 56, 66, 78, 99, 10, 30, 68, 39, 34, 27, 83, 18, 23, 18, 27, 30, 26, 1, 78, 16, 16, 19, 31, 98, 30, 95, 10, 10, 20, 5, 80, 6, 39, 14, 98, 21, 9, 33, 82, 13, 33, 33, 42, 73, 29, 67, 17, 76, 19, 92, 55, 69, 56, 35, 71, 70, 39, 44, 38, 19, 100, 4, 54, 31] 68))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (minOperations [82, 17, 35, 3, 93, 79, 33, 29, 77, 50, 47, 48, 8, 61, 78, 34, 63, 21, 82, 84, 85, 84, 58, 76, 48, 69, 55, 31, 55, 90, 28, 46, 4, 45, 71, 42, 40, 82, 37, 20] 31)," (-1) (minOperations [82, 17, 35, 3, 93, 79, 33, 29, 77, 50, 47, 48, 8, 61, 78, 34, 63, 21, 82, 84, 85, 84, 58, 76, 48, 69, 55, 31, 55, 90, 28, 46, 4, 45, 71, 42, 40, 82, 37, 20] 31))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (minOperations [89, 22, 3, 78, 1, 77, 18, 60, 12, 10, 61, 93, 14, 49, 23, 34, 92, 54, 92, 4, 68, 15, 39, 86, 16, 94, 26, 45, 8, 59, 28, 84, 75, 66, 32, 85, 11, 6, 55] 55)," (-1) (minOperations [89, 22, 3, 78, 1, 77, 18, 60, 12, 10, 61, 93, 14, 49, 23, 34, 92, 54, 92, 4, 68, 15, 39, 86, 16, 94, 26, 45, 8, 59, 28, 84, 75, 66, 32, 85, 11, 6, 55] 55))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (minOperations [60, 52, 92, 54, 70, 29, 16, 30, 10, 45, 3, 31, 48, 85, 2, 91, 75, 49] 49)," (-1) (minOperations [60, 52, 92, 54, 70, 29, 16, 30, 10, 45, 3, 31, 48, 85, 2, 91, 75, 49] 49))
+
+
+-- 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_operations_to_make_array_values_equal_to_k/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, minOperations(new ArrayList<>(Arrays.asList(5,2,5,4,5)), 2));
+}
+@Test
+public void test2() {
+    assertEquals(-1, minOperations(new ArrayList<>(Arrays.asList(2,1,2)), 2));
+}
+@Test
+public void test3() {
+    assertEquals(4, minOperations(new ArrayList<>(Arrays.asList(9,7,5,3)), 1));
+}
+
+}

minimum_operations_to_make_array_values_equal_to_k/meta.json

@@ -0,0 +1,565 @@
+{
+    "id": 3621,
+    "name": "minimum_operations_to_make_array_values_equal_to_k",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/minimum-operations-to-make-array-values-equal-to-k/",
+    "date": "2024-11-23 00:00:00",
+    "task_description": "You are given an integer array `nums` and an integer `k`. An integer `h` is called **valid** if all values in the array that are **strictly greater** than `h` are _identical_. For example, if `nums = [10, 8, 10, 8]`, a **valid** integer is `h = 9` because all `nums[i] > 9` are equal to 10, but 5 is not a **valid** integer. You are allowed to perform the following operation on `nums`: Select an integer `h` that is _valid_ for the **current** values in `nums`. For each index `i` where `nums[i] > h`, set `nums[i]` to `h`. Return the **minimum** number of operations required to make every element in `nums` **equal** to `k`. If it is impossible to make all elements equal to `k`, return -1. **Example 1:** **Input:** nums = [5,2,5,4,5], k = 2 **Output:** 2 **Explanation:** The operations can be performed in order using valid integers 4 and then 2. **Example 2:** **Input:** nums = [2,1,2], k = 2 **Output:** -1 **Explanation:** It is impossible to make all the values equal to 2. **Example 3:** **Input:** nums = [9,7,5,3], k = 1 **Output:** 4 **Explanation:** The operations can be performed using valid integers in the order 7, 5, 3, and 1. **Constraints:** `1 <= nums.length <= 100 ` `1 <= nums[i] <= 100` `1 <= k <= 100`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "nums = [5,2,5,4,5], k = 2",
+            "output": "2 "
+        },
+        {
+            "label": "Example 2",
+            "input": "nums = [2,1,2], k = 2",
+            "output": "-1 "
+        },
+        {
+            "label": "Example 3",
+            "input": "nums = [9,7,5,3], k = 1",
+            "output": "4 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                [
+                    40,
+                    99,
+                    29,
+                    74,
+                    59,
+                    35,
+                    87,
+                    76,
+                    92,
+                    18,
+                    23,
+                    59,
+                    37,
+                    72,
+                    59,
+                    22,
+                    100,
+                    34,
+                    34,
+                    63,
+                    84,
+                    38,
+                    96,
+                    63,
+                    65,
+                    64,
+                    15,
+                    55,
+                    54,
+                    36,
+                    6,
+                    87,
+                    48,
+                    10,
+                    61,
+                    40,
+                    62,
+                    51,
+                    64,
+                    77,
+                    61,
+                    60,
+                    90,
+                    93,
+                    41,
+                    64,
+                    39,
+                    72,
+                    27,
+                    75,
+                    71,
+                    82,
+                    15
+                ],
+                46
+            ],
+            "output": -1
+        },
+        {
+            "input": [
+                [
+                    73,
+                    80,
+                    65,
+                    6,
+                    85,
+                    3,
+                    67,
+                    52,
+                    37,
+                    97,
+                    24,
+                    59,
+                    34,
+                    5,
+                    95,
+                    10,
+                    52,
+                    80,
+                    99,
+                    93,
+                    42,
+                    66,
+                    19,
+                    95,
+                    74,
+                    76,
+                    71,
+                    66,
+                    77,
+                    76,
+                    30,
+                    34,
+                    83,
+                    55,
+                    81,
+                    97,
+                    38,
+                    86,
+                    65,
+                    24,
+                    48,
+                    80,
+                    17,
+                    54,
+                    29,
+                    3,
+                    63,
+                    4,
+                    38,
+                    88,
+                    30,
+                    2,
+                    30,
+                    75,
+                    81,
+                    8,
+                    5,
+                    90,
+                    31
+                ],
+                65
+            ],
+            "output": -1
+        },
+        {
+            "input": [
+                [
+                    63,
+                    21,
+                    26,
+                    82,
+                    95,
+                    2,
+                    100,
+                    69,
+                    52,
+                    67,
+                    67,
+                    78,
+                    36,
+                    22,
+                    17,
+                    76,
+                    2,
+                    10,
+                    65,
+                    61,
+                    20,
+                    49,
+                    27,
+                    63,
+                    74,
+                    99,
+                    56,
+                    85,
+                    30,
+                    94,
+                    56,
+                    66,
+                    78,
+                    99,
+                    10,
+                    30,
+                    68,
+                    39,
+                    34,
+                    27,
+                    83,
+                    18,
+                    23,
+                    18,
+                    27,
+                    30,
+                    26,
+                    1,
+                    78,
+                    16,
+                    16,
+                    19,
+                    31,
+                    98,
+                    30,
+                    95,
+                    10,
+                    10,
+                    20,
+                    5,
+                    80,
+                    6,
+                    39,
+                    14,
+                    98,
+                    21,
+                    9,
+                    33,
+                    82,
+                    13,
+                    33,
+                    33,
+                    42,
+                    73,
+                    29,
+                    67,
+                    17,
+                    76,
+                    19,
+                    92,
+                    55,
+                    69,
+                    56,
+                    35,
+                    71,
+                    70,
+                    39,
+                    44,
+                    38,
+                    19,
+                    100,
+                    4,
+                    54,
+                    31
+                ],
+                68
+            ],
+            "output": -1
+        },
+        {
+            "input": [
+                [
+                    82,
+                    17,
+                    35,
+                    3,
+                    93,
+                    79,
+                    33,
+                    29,
+                    77,
+                    50,
+                    47,
+                    48,
+                    8,
+                    61,
+                    78,
+                    34,
+                    63,
+                    21,
+                    82,
+                    84,
+                    85,
+                    84,
+                    58,
+                    76,
+                    48,
+                    69,
+                    55,
+                    31,
+                    55,
+                    90,
+                    28,
+                    46,
+                    4,
+                    45,
+                    71,
+                    42,
+                    40,
+                    82,
+                    37,
+                    20
+                ],
+                31
+            ],
+            "output": -1
+        },
+        {
+            "input": [
+                [
+                    89,
+                    22,
+                    3,
+                    78,
+                    1,
+                    77,
+                    18,
+                    60,
+                    12,
+                    10,
+                    61,
+                    93,
+                    14,
+                    49,
+                    23,
+                    34,
+                    92,
+                    54,
+                    92,
+                    4,
+                    68,
+                    15,
+                    39,
+                    86,
+                    16,
+                    94,
+                    26,
+                    45,
+                    8,
+                    59,
+                    28,
+                    84,
+                    75,
+                    66,
+                    32,
+                    85,
+                    11,
+                    6,
+                    55
+                ],
+                55
+            ],
+            "output": -1
+        },
+        {
+            "input": [
+                [
+                    60,
+                    52,
+                    92,
+                    54,
+                    70,
+                    29,
+                    16,
+                    30,
+                    10,
+                    45,
+                    3,
+                    31,
+                    48,
+                    85,
+                    2,
+                    91,
+                    75,
+                    49
+                ],
+                49
+            ],
+            "output": -1
+        },
+        {
+            "input": [
+                [
+                    21,
+                    15,
+                    83,
+                    9,
+                    55,
+                    79,
+                    99,
+                    79,
+                    25,
+                    37,
+                    88,
+                    61,
+                    11,
+                    63,
+                    18,
+                    20,
+                    60,
+                    15,
+                    96,
+                    77,
+                    79,
+                    93,
+                    25,
+                    14,
+                    10,
+                    31,
+                    28,
+                    37,
+                    26,
+                    2,
+                    5,
+                    38,
+                    98,
+                    85,
+                    26,
+                    51,
+                    94,
+                    67,
+                    84,
+                    77,
+                    30,
+                    58,
+                    97,
+                    30,
+                    95,
+                    82,
+                    64
+                ],
+                14
+            ],
+            "output": -1
+        },
+        {
+            "input": [
+                [
+                    68,
+                    3,
+                    91,
+                    58,
+                    85,
+                    75,
+                    42,
+                    7,
+                    13,
+                    12,
+                    51,
+                    12,
+                    43,
+                    46,
+                    16,
+                    10,
+                    28,
+                    73,
+                    73,
+                    65,
+                    31,
+                    17,
+                    54,
+                    9,
+                    39,
+                    86,
+                    85,
+                    24,
+                    19,
+                    66,
+                    36,
+                    50,
+                    75,
+                    55,
+                    50,
+                    25
+                ],
+                88
+            ],
+            "output": -1
+        },
+        {
+            "input": [
+                [
+                    90,
+                    77,
+                    80,
+                    41,
+                    9,
+                    49,
+                    55,
+                    60,
+                    46,
+                    54,
+                    46,
+                    20,
+                    3,
+                    72,
+                    17,
+                    96,
+                    41,
+                    73
+                ],
+                20
+            ],
+            "output": -1
+        },
+        {
+            "input": [
+                [
+                    34,
+                    99,
+                    20,
+                    50,
+                    29,
+                    80,
+                    87,
+                    46,
+                    38,
+                    64,
+                    95,
+                    18,
+                    14,
+                    9,
+                    72,
+                    42,
+                    7,
+                    76,
+                    62,
+                    17,
+                    28,
+                    76,
+                    70,
+                    60,
+                    95,
+                    61,
+                    85,
+                    70,
+                    21,
+                    11,
+                    56,
+                    93,
+                    34,
+                    32,
+                    87,
+                    73,
+                    28,
+                    56,
+                    77,
+                    84,
+                    53,
+                    58,
+                    78,
+                    1,
+                    95,
+                    39,
+                    83,
+                    44,
+                    93
+                ],
+                8
+            ],
+            "output": -1
+        }
+    ],
+    "haskell_template": "minOperations :: [Int] -> Int -> Int\nminOperations nums k ",
+    "ocaml_template": "let minOperations (nums: int list) (k: int) : int =  ",
+    "scala_template": "def minOperations(nums: List[Int],k: Int): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public int minOperations(int[] nums, int k) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def minOperations(self, nums, k):\n        \"\"\"\n        :type nums: List[int]\n        :type k: int\n        :rtype: int\n        \"\"\"\n        "
+}

minimum_operations_to_make_array_values_equal_to_k/ocaml_tests/main.ml

@@ -0,0 +1,50 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 2 (minOperations [5;2;5;4;5] 2)
+
+let test2 _ = assert_equal (-1) (minOperations [2;1;2] 2)
+
+let test3 _ = assert_equal 4 (minOperations [9;7;5;3] 1)
+
+let test4 _ = assert_equal (-1) (minOperations [40; 99; 29; 74; 59; 35; 87; 76; 92; 18; 23; 59; 37; 72; 59; 22; 100; 34; 34; 63; 84; 38; 96; 63; 65; 64; 15; 55; 54; 36; 6; 87; 48; 10; 61; 40; 62; 51; 64; 77; 61; 60; 90; 93; 41; 64; 39; 72; 27; 75; 71; 82; 15] 46)
+
+let test5 _ = assert_equal (-1) (minOperations [73; 80; 65; 6; 85; 3; 67; 52; 37; 97; 24; 59; 34; 5; 95; 10; 52; 80; 99; 93; 42; 66; 19; 95; 74; 76; 71; 66; 77; 76; 30; 34; 83; 55; 81; 97; 38; 86; 65; 24; 48; 80; 17; 54; 29; 3; 63; 4; 38; 88; 30; 2; 30; 75; 81; 8; 5; 90; 31] 65)
+
+let test6 _ = assert_equal (-1) (minOperations [63; 21; 26; 82; 95; 2; 100; 69; 52; 67; 67; 78; 36; 22; 17; 76; 2; 10; 65; 61; 20; 49; 27; 63; 74; 99; 56; 85; 30; 94; 56; 66; 78; 99; 10; 30; 68; 39; 34; 27; 83; 18; 23; 18; 27; 30; 26; 1; 78; 16; 16; 19; 31; 98; 30; 95; 10; 10; 20; 5; 80; 6; 39; 14; 98; 21; 9; 33; 82; 13; 33; 33; 42; 73; 29; 67; 17; 76; 19; 92; 55; 69; 56; 35; 71; 70; 39; 44; 38; 19; 100; 4; 54; 31] 68)
+
+let test7 _ = assert_equal (-1) (minOperations [82; 17; 35; 3; 93; 79; 33; 29; 77; 50; 47; 48; 8; 61; 78; 34; 63; 21; 82; 84; 85; 84; 58; 76; 48; 69; 55; 31; 55; 90; 28; 46; 4; 45; 71; 42; 40; 82; 37; 20] 31)
+
+let test8 _ = assert_equal (-1) (minOperations [89; 22; 3; 78; 1; 77; 18; 60; 12; 10; 61; 93; 14; 49; 23; 34; 92; 54; 92; 4; 68; 15; 39; 86; 16; 94; 26; 45; 8; 59; 28; 84; 75; 66; 32; 85; 11; 6; 55] 55)
+
+let test9 _ = assert_equal (-1) (minOperations [60; 52; 92; 54; 70; 29; 16; 30; 10; 45; 3; 31; 48; 85; 2; 91; 75; 49] 49)
+
+let test10 _ = assert_equal (-1) (minOperations [21; 15; 83; 9; 55; 79; 99; 79; 25; 37; 88; 61; 11; 63; 18; 20; 60; 15; 96; 77; 79; 93; 25; 14; 10; 31; 28; 37; 26; 2; 5; 38; 98; 85; 26; 51; 94; 67; 84; 77; 30; 58; 97; 30; 95; 82; 64] 14)
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for minOperations" >::: [
+        
+  "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_operations_to_make_array_values_equal_to_k/scala_tests/MySuite.scala

@@ -0,0 +1,44 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.minOperations(List(5,2,5,4,5),2), 2)
+  }
+
+  test("test2") {
+    assertEquals(Main.minOperations(List(2,1,2),2), -1)
+  }
+
+  test("test3") {
+    assertEquals(Main.minOperations(List(9,7,5,3),1), 4)
+  }
+
+  test("test4") {
+    assertEquals(Main.minOperations(List(40, 99, 29, 74, 59, 35, 87, 76, 92, 18, 23, 59, 37, 72, 59, 22, 100, 34, 34, 63, 84, 38, 96, 63, 65, 64, 15, 55, 54, 36, 6, 87, 48, 10, 61, 40, 62, 51, 64, 77, 61, 60, 90, 93, 41, 64, 39, 72, 27, 75, 71, 82, 15),46), -1)
+  }
+
+  test("test5") {
+    assertEquals(Main.minOperations(List(73, 80, 65, 6, 85, 3, 67, 52, 37, 97, 24, 59, 34, 5, 95, 10, 52, 80, 99, 93, 42, 66, 19, 95, 74, 76, 71, 66, 77, 76, 30, 34, 83, 55, 81, 97, 38, 86, 65, 24, 48, 80, 17, 54, 29, 3, 63, 4, 38, 88, 30, 2, 30, 75, 81, 8, 5, 90, 31),65), -1)
+  }
+
+  test("test6") {
+    assertEquals(Main.minOperations(List(63, 21, 26, 82, 95, 2, 100, 69, 52, 67, 67, 78, 36, 22, 17, 76, 2, 10, 65, 61, 20, 49, 27, 63, 74, 99, 56, 85, 30, 94, 56, 66, 78, 99, 10, 30, 68, 39, 34, 27, 83, 18, 23, 18, 27, 30, 26, 1, 78, 16, 16, 19, 31, 98, 30, 95, 10, 10, 20, 5, 80, 6, 39, 14, 98, 21, 9, 33, 82, 13, 33, 33, 42, 73, 29, 67, 17, 76, 19, 92, 55, 69, 56, 35, 71, 70, 39, 44, 38, 19, 100, 4, 54, 31),68), -1)
+  }
+
+  test("test7") {
+    assertEquals(Main.minOperations(List(82, 17, 35, 3, 93, 79, 33, 29, 77, 50, 47, 48, 8, 61, 78, 34, 63, 21, 82, 84, 85, 84, 58, 76, 48, 69, 55, 31, 55, 90, 28, 46, 4, 45, 71, 42, 40, 82, 37, 20),31), -1)
+  }
+
+  test("test8") {
+    assertEquals(Main.minOperations(List(89, 22, 3, 78, 1, 77, 18, 60, 12, 10, 61, 93, 14, 49, 23, 34, 92, 54, 92, 4, 68, 15, 39, 86, 16, 94, 26, 45, 8, 59, 28, 84, 75, 66, 32, 85, 11, 6, 55),55), -1)
+  }
+
+  test("test9") {
+    assertEquals(Main.minOperations(List(60, 52, 92, 54, 70, 29, 16, 30, 10, 45, 3, 31, 48, 85, 2, 91, 75, 49),49), -1)
+  }
+
+  test("test10") {
+    assertEquals(Main.minOperations(List(21, 15, 83, 9, 55, 79, 99, 79, 25, 37, 88, 61, 11, 63, 18, 20, 60, 15, 96, 77, 79, 93, 25, 14, 10, 31, 28, 37, 26, 2, 5, 38, 98, 85, 26, 51, 94, 67, 84, 77, 30, 58, 97, 30, 95, 82, 64),14), -1)
+  }
+
+}

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

minimum_operations_to_make_binary_array_elements_equal_to_one_ii/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(4, minOperations(Arrays.asList(0,1,1,0,1)));
+}
+@Test
+public void test2() {
+    assertEquals(1, minOperations(Arrays.asList(1,0,0,0)));
+}
+
+}

minimum_operations_to_make_columns_strictly_increasing/haskell_tests/Main.hs

@@ -0,0 +1,41 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+minimumOperations :: [[Int]] -> Int
+minimumOperations grid = undefined
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (minimumOperations [[3,2],[1,3],[3,4],[0,1]])," 15 (minimumOperations [[3,2],[1,3],[3,4],[0,1]]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (minimumOperations [[3,2,1],[2,1,0],[1,2,3]])," 12 (minimumOperations [[3,2,1],[2,1,0],[1,2,3]]))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (minimumOperations [[127, 732, 2076, 1498, 1120, 1701, 48, 1574, 2349, 8, 1946, 1434, 2138, 1519], [2137, 1079, 2434, 1499, 1135, 1702, 66, 1575, 2350, 1980, 2137, 2467, 2139, 1520]])," 3718 (minimumOperations [[127, 732, 2076, 1498, 1120, 1701, 48, 1574, 2349, 8, 1946, 1434, 2138, 1519], [2137, 1079, 2434, 1499, 1135, 1702, 66, 1575, 2350, 1980, 2137, 2467, 2139, 1520]]))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (minimumOperations [[1451, 1480, 2377, 391, 714, 220, 433, 2198, 559, 1443, 1286, 947, 1212, 805, 2450, 1661, 1072, 1652, 801, 316, 273, 761, 1189, 2445, 996, 151, 1875, 676, 103, 7, 1610, 1520, 2035, 439, 1284, 1935, 93, 1342, 774, 1971, 1923, 937, 1301, 2206, 985, 1301, 1509, 2022, 1803]])," 0 (minimumOperations [[1451, 1480, 2377, 391, 714, 220, 433, 2198, 559, 1443, 1286, 947, 1212, 805, 2450, 1661, 1072, 1652, 801, 316, 273, 761, 1189, 2445, 996, 151, 1875, 676, 103, 7, 1610, 1520, 2035, 439, 1284, 1935, 93, 1342, 774, 1971, 1923, 937, 1301, 2206, 985, 1301, 1509, 2022, 1803]]))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (minimumOperations [[1238, 1786, 31], [2142, 1787, 1359], [2280, 1788, 1360], [2281, 1899, 1504], [2282, 1900, 1505], [2283, 1901, 2140], [2284, 1902, 2141], [2285, 1903, 2142], [2286, 1904, 2143], [2473, 1905, 2144], [2474, 1906, 2285], [2475, 1907, 2286], [2476, 1908, 2287], [2477, 1909, 2288], [2478, 1917, 2289], [2479, 1918, 2290], [2480, 1919, 2291], [2481, 2426, 2292], [2482, 2427, 2293], [2483, 2428, 2336], [2484, 2429, 2337], [2485, 2430, 2338], [2486, 2431, 2339], [2487, 2432, 2340], [2488, 2433, 2341], [2489, 2434, 2342], [2490, 2435, 2343], [2491, 2436, 2344], [2492, 2437, 2345], [2493, 2438, 2346], [2494, 2439, 2347], [2495, 2440, 2348], [2496, 2441, 2349], [2497, 2442, 2350], [2498, 2443, 2351], [2499, 2444, 2368]])," 114619 (minimumOperations [[1238, 1786, 31], [2142, 1787, 1359], [2280, 1788, 1360], [2281, 1899, 1504], [2282, 1900, 1505], [2283, 1901, 2140], [2284, 1902, 2141], [2285, 1903, 2142], [2286, 1904, 2143], [2473, 1905, 2144], [2474, 1906, 2285], [2475, 1907, 2286], [2476, 1908, 2287], [2477, 1909, 2288], [2478, 1917, 2289], [2479, 1918, 2290], [2480, 1919, 2291], [2481, 2426, 2292], [2482, 2427, 2293], [2483, 2428, 2336], [2484, 2429, 2337], [2485, 2430, 2338], [2486, 2431, 2339], [2487, 2432, 2340], [2488, 2433, 2341], [2489, 2434, 2342], [2490, 2435, 2343], [2491, 2436, 2344], [2492, 2437, 2345], [2493, 2438, 2346], [2494, 2439, 2347], [2495, 2440, 2348], [2496, 2441, 2349], [2497, 2442, 2350], [2498, 2443, 2351], [2499, 2444, 2368]]))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (minimumOperations [[868, 1485, 2457, 395, 2382, 314, 1979, 528, 728, 1132, 1436, 1478, 1306, 963, 2033, 1976, 1427, 1549, 1320, 88, 134, 1125, 114, 2234, 1283, 1850, 1536, 2116, 2018, 1182, 903, 881, 1447, 19, 1224, 134, 47, 2091, 1467, 1340, 1450, 2472], [1091, 1486, 2458, 396, 2383, 1444, 1980, 529, 1511, 1133, 1437, 2101, 2141, 2339, 2034, 1977, 1428, 1550, 2161, 543, 1632, 2125, 2469, 2235, 1284, 1851, 1537, 2117, 2019, 2091, 1991, 1052, 2384, 455, 1640, 2081, 2366, 2092, 1468, 1341, 1595, 2473], [1120, 2266, 2459, 397, 2384, 1445, 1981, 808, 1512, 2174, 2439, 2102, 2142, 2340, 2035, 2002, 1429, 2122, 2162, 1055, 1718, 2126, 2470, 2236, 1285, 2020, 1538, 2221, 2456, 2092, 1992, 1053, 2385, 563, 1641, 2082, 2367, 2157, 1886, 1342, 1596, 2474], [2494, 2267, 2460, 398, 2385, 1446, 1982, 2296, 2075, 2175, 2440, 2103, 2143, 2341, 2036, 2003, 1430, 2128, 2163, 1056, 2465, 2127, 2471, 2237, 1286, 2021, 1539, 2400, 2457, 2093, 1993, 1802, 2386, 1120, 1642, 2083, 2368, 2158, 1887, 2046, 1597, 2475], [2495, 2313, 2461, 2131, 2386, 1674, 1983, 2297, 2076, 2176, 2441, 2104, 2144, 2342, 2037, 2004, 1899, 2304, 2164, 1569, 2466, 2128, 2472, 2238, 1456, 2022, 1680, 2401, 2458, 2094, 1994, 1803, 2387, 1121, 1643, 2084, 2369, 2159, 1888, 2224, 1598, 2476], [2496, 2314, 2462, 2132, 2387, 1675, 1984, 2298, 2077, 2177, 2450, 2105, 2145, 2343, 2038, 2005, 1900, 2305, 2277, 1570, 2467, 2129, 2473, 2239, 1457, 2023, 1681, 2402, 2459, 2095, 1995, 1804, 2388, 1122, 1661, 2085, 2370, 2483, 1889, 2225, 1599, 2477], [2497, 2315, 2463, 2449, 2388, 1676, 1985, 2299, 2417, 2178, 2451, 2106, 2146, 2344, 2039, 2006, 1901, 2306, 2278, 1571, 2468, 2417, 2474, 2240, 1703, 2024, 1682, 2403, 2460, 2143, 2381, 1993, 2389, 2314, 1662, 2086, 2371, 2484, 1890, 2401, 1600, 2478], [2498, 2316, 2464, 2450, 2389, 1677, 2090, 2300, 2418, 2179, 2452, 2107, 2147, 2345, 2040, 2007, 1902, 2307, 2279, 1572, 2469, 2418, 2475, 2241, 1704, 2204, 1683, 2404, 2461, 2144, 2382, 2020, 2390, 2315, 1663, 2087, 2372, 2485, 1891, 2402, 1601, 2479]])," 229471 (minimumOperations [[868, 1485, 2457, 395, 2382, 314, 1979, 528, 728, 1132, 1436, 1478, 1306, 963, 2033, 1976, 1427, 1549, 1320, 88, 134, 1125, 114, 2234, 1283, 1850, 1536, 2116, 2018, 1182, 903, 881, 1447, 19, 1224, 134, 47, 2091, 1467, 1340, 1450, 2472], [1091, 1486, 2458, 396, 2383, 1444, 1980, 529, 1511, 1133, 1437, 2101, 2141, 2339, 2034, 1977, 1428, 1550, 2161, 543, 1632, 2125, 2469, 2235, 1284, 1851, 1537, 2117, 2019, 2091, 1991, 1052, 2384, 455, 1640, 2081, 2366, 2092, 1468, 1341, 1595, 2473], [1120, 2266, 2459, 397, 2384, 1445, 1981, 808, 1512, 2174, 2439, 2102, 2142, 2340, 2035, 2002, 1429, 2122, 2162, 1055, 1718, 2126, 2470, 2236, 1285, 2020, 1538, 2221, 2456, 2092, 1992, 1053, 2385, 563, 1641, 2082, 2367, 2157, 1886, 1342, 1596, 2474], [2494, 2267, 2460, 398, 2385, 1446, 1982, 2296, 2075, 2175, 2440, 2103, 2143, 2341, 2036, 2003, 1430, 2128, 2163, 1056, 2465, 2127, 2471, 2237, 1286, 2021, 1539, 2400, 2457, 2093, 1993, 1802, 2386, 1120, 1642, 2083, 2368, 2158, 1887, 2046, 1597, 2475], [2495, 2313, 2461, 2131, 2386, 1674, 1983, 2297, 2076, 2176, 2441, 2104, 2144, 2342, 2037, 2004, 1899, 2304, 2164, 1569, 2466, 2128, 2472, 2238, 1456, 2022, 1680, 2401, 2458, 2094, 1994, 1803, 2387, 1121, 1643, 2084, 2369, 2159, 1888, 2224, 1598, 2476], [2496, 2314, 2462, 2132, 2387, 1675, 1984, 2298, 2077, 2177, 2450, 2105, 2145, 2343, 2038, 2005, 1900, 2305, 2277, 1570, 2467, 2129, 2473, 2239, 1457, 2023, 1681, 2402, 2459, 2095, 1995, 1804, 2388, 1122, 1661, 2085, 2370, 2483, 1889, 2225, 1599, 2477], [2497, 2315, 2463, 2449, 2388, 1676, 1985, 2299, 2417, 2178, 2451, 2106, 2146, 2344, 2039, 2006, 1901, 2306, 2278, 1571, 2468, 2417, 2474, 2240, 1703, 2024, 1682, 2403, 2460, 2143, 2381, 1993, 2389, 2314, 1662, 2086, 2371, 2484, 1890, 2401, 1600, 2478], [2498, 2316, 2464, 2450, 2389, 1677, 2090, 2300, 2418, 2179, 2452, 2107, 2147, 2345, 2040, 2007, 1902, 2307, 2279, 1572, 2469, 2418, 2475, 2241, 1704, 2204, 1683, 2404, 2461, 2144, 2382, 2020, 2390, 2315, 1663, 2087, 2372, 2485, 1891, 2402, 1601, 2479]]))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (minimumOperations [[2091, 1538, 1215, 1122, 672, 1607, 504, 2056, 2351, 1723], [2092, 2317, 1361, 1283, 673, 1608, 2252, 2239, 2352, 1724], [2097, 2318, 1362, 2316, 854, 1609, 2456, 2428, 2353, 1725], [2098, 2319, 1363, 2317, 855, 2462, 2457, 2429, 2354, 1726], [2099, 2320, 2404, 2318, 2091, 2463, 2458, 2430, 2355, 1727], [2301, 2321, 2447, 2319, 2092, 2464, 2459, 2431, 2356, 1728], [2302, 2322, 2448, 2320, 2093, 2465, 2460, 2474, 2357, 1729], [2303, 2323, 2449, 2321, 2094, 2466, 2461, 2475, 2358, 1730], [2304, 2324, 2450, 2322, 2095, 2467, 2462, 2476, 2359, 2089], [2305, 2325, 2451, 2323, 2444, 2468, 2463, 2477, 2360, 2090], [2306, 2326, 2452, 2324, 2445, 2469, 2464, 2478, 2361, 2091], [2307, 2327, 2453, 2325, 2446, 2470, 2465, 2479, 2362, 2386], [2308, 2443, 2454, 2326, 2447, 2471, 2466, 2480, 2481, 2387], [2309, 2444, 2455, 2327, 2448, 2472, 2467, 2481, 2482, 2432], [2310, 2445, 2456, 2328, 2449, 2473, 2468, 2482, 2483, 2433], [2311, 2446, 2457, 2329, 2450, 2474, 2469, 2483, 2484, 2434], [2312, 2447, 2458, 2484, 2451, 2475, 2470, 2484, 2485, 2435], [2313, 2448, 2459, 2485, 2452, 2476, 2471, 2485, 2486, 2436], [2314, 2449, 2460, 2486, 2453, 2477, 2472, 2486, 2487, 2437], [2315, 2450, 2461, 2487, 2454, 2478, 2473, 2487, 2488, 2438], [2316, 2451, 2462, 2488, 2455, 2479, 2474, 2488, 2489, 2439], [2317, 2452, 2463, 2489, 2456, 2480, 2475, 2489, 2490, 2440], [2427, 2453, 2464, 2490, 2457, 2481, 2476, 2490, 2491, 2441], [2428, 2454, 2465, 2491, 2458, 2482, 2477, 2491, 2492, 2442], [2429, 2455, 2466, 2492, 2459, 2483, 2478, 2492, 2493, 2443], [2430, 2456, 2467, 2493, 2460, 2484, 2479, 2493, 2494, 2444], [2431, 2457, 2468, 2494, 2461, 2485, 2480, 2494, 2495, 2445], [2432, 2458, 2469, 2495, 2462, 2486, 2481, 2495, 2496, 2446], [2433, 2459, 2470, 2496, 2463, 2487, 2482, 2496, 2497, 2447], [2434, 2460, 2471, 2497, 2464, 2488, 2483, 2497, 2498, 2448], [2435, 2461, 2472, 2498, 2465, 2489, 2484, 2498, 2499, 2449], [2436, 2462, 2473, 2499, 2466, 2490, 2485, 2499, 2500, 2450], [2437, 2463, 2474, 2500, 2467, 2491, 2486, 2500, 2501, 2451], [2438, 2464, 2475, 2501, 2468, 2492, 2487, 2501, 2502, 2452], [2439, 2465, 2476, 2502, 2469, 2493, 2488, 2502, 2503, 2473], [2440, 2466, 2477, 2503, 2470, 2494, 2489, 2503, 2504, 2474], [2441, 2467, 2478, 2504, 2471, 2495, 2490, 2504, 2505, 2475], [2442, 2468, 2479, 2505, 2472, 2496, 2491, 2505, 2506, 2476], [2443, 2469, 2480, 2506, 2473, 2497, 2492, 2506, 2507, 2477], [2444, 2470, 2481, 2507, 2474, 2498, 2493, 2507, 2508, 2478], [2445, 2471, 2482, 2508, 2475, 2499, 2494, 2508, 2509, 2479], [2446, 2472, 2483, 2509, 2476, 2500, 2495, 2509, 2510, 2480], [2447, 2473, 2484, 2510, 2477, 2501, 2496, 2510, 2511, 2481], [2448, 2474, 2485, 2511, 2478, 2502, 2497, 2511, 2512, 2482]])," 504941 (minimumOperations [[2091, 1538, 1215, 1122, 672, 1607, 504, 2056, 2351, 1723], [2092, 2317, 1361, 1283, 673, 1608, 2252, 2239, 2352, 1724], [2097, 2318, 1362, 2316, 854, 1609, 2456, 2428, 2353, 1725], [2098, 2319, 1363, 2317, 855, 2462, 2457, 2429, 2354, 1726], [2099, 2320, 2404, 2318, 2091, 2463, 2458, 2430, 2355, 1727], [2301, 2321, 2447, 2319, 2092, 2464, 2459, 2431, 2356, 1728], [2302, 2322, 2448, 2320, 2093, 2465, 2460, 2474, 2357, 1729], [2303, 2323, 2449, 2321, 2094, 2466, 2461, 2475, 2358, 1730], [2304, 2324, 2450, 2322, 2095, 2467, 2462, 2476, 2359, 2089], [2305, 2325, 2451, 2323, 2444, 2468, 2463, 2477, 2360, 2090], [2306, 2326, 2452, 2324, 2445, 2469, 2464, 2478, 2361, 2091], [2307, 2327, 2453, 2325, 2446, 2470, 2465, 2479, 2362, 2386], [2308, 2443, 2454, 2326, 2447, 2471, 2466, 2480, 2481, 2387], [2309, 2444, 2455, 2327, 2448, 2472, 2467, 2481, 2482, 2432], [2310, 2445, 2456, 2328, 2449, 2473, 2468, 2482, 2483, 2433], [2311, 2446, 2457, 2329, 2450, 2474, 2469, 2483, 2484, 2434], [2312, 2447, 2458, 2484, 2451, 2475, 2470, 2484, 2485, 2435], [2313, 2448, 2459, 2485, 2452, 2476, 2471, 2485, 2486, 2436], [2314, 2449, 2460, 2486, 2453, 2477, 2472, 2486, 2487, 2437], [2315, 2450, 2461, 2487, 2454, 2478, 2473, 2487, 2488, 2438], [2316, 2451, 2462, 2488, 2455, 2479, 2474, 2488, 2489, 2439], [2317, 2452, 2463, 2489, 2456, 2480, 2475, 2489, 2490, 2440], [2427, 2453, 2464, 2490, 2457, 2481, 2476, 2490, 2491, 2441], [2428, 2454, 2465, 2491, 2458, 2482, 2477, 2491, 2492, 2442], [2429, 2455, 2466, 2492, 2459, 2483, 2478, 2492, 2493, 2443], [2430, 2456, 2467, 2493, 2460, 2484, 2479, 2493, 2494, 2444], [2431, 2457, 2468, 2494, 2461, 2485, 2480, 2494, 2495, 2445], [2432, 2458, 2469, 2495, 2462, 2486, 2481, 2495, 2496, 2446], [2433, 2459, 2470, 2496, 2463, 2487, 2482, 2496, 2497, 2447], [2434, 2460, 2471, 2497, 2464, 2488, 2483, 2497, 2498, 2448], [2435, 2461, 2472, 2498, 2465, 2489, 2484, 2498, 2499, 2449], [2436, 2462, 2473, 2499, 2466, 2490, 2485, 2499, 2500, 2450], [2437, 2463, 2474, 2500, 2467, 2491, 2486, 2500, 2501, 2451], [2438, 2464, 2475, 2501, 2468, 2492, 2487, 2501, 2502, 2452], [2439, 2465, 2476, 2502, 2469, 2493, 2488, 2502, 2503, 2473], [2440, 2466, 2477, 2503, 2470, 2494, 2489, 2503, 2504, 2474], [2441, 2467, 2478, 2504, 2471, 2495, 2490, 2504, 2505, 2475], [2442, 2468, 2479, 2505, 2472, 2496, 2491, 2505, 2506, 2476], [2443, 2469, 2480, 2506, 2473, 2497, 2492, 2506, 2507, 2477], [2444, 2470, 2481, 2507, 2474, 2498, 2493, 2507, 2508, 2478], [2445, 2471, 2482, 2508, 2475, 2499, 2494, 2508, 2509, 2479], [2446, 2472, 2483, 2509, 2476, 2500, 2495, 2509, 2510, 2480], [2447, 2473, 2484, 2510, 2477, 2501, 2496, 2510, 2511, 2481], [2448, 2474, 2485, 2511, 2478, 2502, 2497, 2511, 2512, 2482]]))
+
+
+-- 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]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

minimum_operations_to_make_columns_strictly_increasing/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(15, minimumOperations(Arrays.asList(Arrays.asList(3,2),Arrays.asList(1,3),Arrays.asList(3,4),Arrays.asList(0,1))));
+}
+@Test
+public void test2() {
+    assertEquals(12, minimumOperations(Arrays.asList(Arrays.asList(3,2,1),Arrays.asList(2,1,0),Arrays.asList(1,2,3))));
+}
+
+}

minimum_operations_to_make_columns_strictly_increasing/meta.json

@@ -0,0 +1,1195 @@
+{
+    "id": 3691,
+    "name": "minimum_operations_to_make_columns_strictly_increasing",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/minimum-operations-to-make-columns-strictly-increasing/",
+    "date": "2024-12-22 00:00:00",
+    "task_description": "You are given a `m x n` matrix `grid` consisting of non-negative integers. In one operation, you can increment the value of any `grid[i][j]` by 1. Return the **minimum** number of operations needed to make all columns of `grid` **strictly increasing**. **Example 1:** **Input:** grid = [[3,2],[1,3],[3,4],[0,1]] **Output:** 15 **Explanation:** To make the `0th` column strictly increasing, we can apply 3 operations on `grid[1][0]`, 2 operations on `grid[2][0]`, and 6 operations on `grid[3][0]`. To make the `1st` column strictly increasing, we can apply 4 operations on `grid[3][1]`. **Example 2:** **Input:** grid = [[3,2,1],[2,1,0],[1,2,3]] **Output:** 12 **Explanation:** To make the `0th` column strictly increasing, we can apply 2 operations on `grid[1][0]`, and 4 operations on `grid[2][0]`. To make the `1st` column strictly increasing, we can apply 2 operations on `grid[1][1]`, and 2 operations on `grid[2][1]`. To make the `2nd` column strictly increasing, we can apply 2 operations on `grid[1][2]`. **Constraints:** `m == grid.length` `n == grid[i].length` `1 <= m, n <= 50` `0 <= grid[i][j] < 2500` ``` ```",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "grid = [[3,2],[1,3],[3,4],[0,1]]",
+            "output": "15 "
+        },
+        {
+            "label": "Example 2",
+            "input": "grid = [[3,2,1],[2,1,0],[1,2,3]]",
+            "output": "12 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                [
+                    127,
+                    732,
+                    2076,
+                    1498,
+                    1120,
+                    1701,
+                    48,
+                    1574,
+                    2349,
+                    8,
+                    1946,
+                    1434,
+                    2138,
+                    1519
+                ],
+                [
+                    2137,
+                    1079,
+                    2434,
+                    1499,
+                    1135,
+                    1702,
+                    66,
+                    1575,
+                    2350,
+                    1980,
+                    2137,
+                    2467,
+                    2139,
+                    1520
+                ]
+            ],
+            "output": 3718
+        },
+        {
+            "input": [
+                [
+                    1451,
+                    1480,
+                    2377,
+                    391,
+                    714,
+                    220,
+                    433,
+                    2198,
+                    559,
+                    1443,
+                    1286,
+                    947,
+                    1212,
+                    805,
+                    2450,
+                    1661,
+                    1072,
+                    1652,
+                    801,
+                    316,
+                    273,
+                    761,
+                    1189,
+                    2445,
+                    996,
+                    151,
+                    1875,
+                    676,
+                    103,
+                    7,
+                    1610,
+                    1520,
+                    2035,
+                    439,
+                    1284,
+                    1935,
+                    93,
+                    1342,
+                    774,
+                    1971,
+                    1923,
+                    937,
+                    1301,
+                    2206,
+                    985,
+                    1301,
+                    1509,
+                    2022,
+                    1803
+                ]
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                [
+                    1238,
+                    1786,
+                    31
+                ],
+                [
+                    2142,
+                    1787,
+                    1359
+                ],
+                [
+                    2280,
+                    1788,
+                    1360
+                ],
+                [
+                    2281,
+                    1899,
+                    1504
+                ],
+                [
+                    2282,
+                    1900,
+                    1505
+                ],
+                [
+                    2283,
+                    1901,
+                    2140
+                ],
+                [
+                    2284,
+                    1902,
+                    2141
+                ],
+                [
+                    2285,
+                    1903,
+                    2142
+                ],
+                [
+                    2286,
+                    1904,
+                    2143
+                ],
+                [
+                    2473,
+                    1905,
+                    2144
+                ],
+                [
+                    2474,
+                    1906,
+                    2285
+                ],
+                [
+                    2475,
+                    1907,
+                    2286
+                ],
+                [
+                    2476,
+                    1908,
+                    2287
+                ],
+                [
+                    2477,
+                    1909,
+                    2288
+                ],
+                [
+                    2478,
+                    1917,
+                    2289
+                ],
+                [
+                    2479,
+                    1918,
+                    2290
+                ],
+                [
+                    2480,
+                    1919,
+                    2291
+                ],
+                [
+                    2481,
+                    2426,
+                    2292
+                ],
+                [
+                    2482,
+                    2427,
+                    2293
+                ],
+                [
+                    2483,
+                    2428,
+                    2336
+                ],
+                [
+                    2484,
+                    2429,
+                    2337
+                ],
+                [
+                    2485,
+                    2430,
+                    2338
+                ],
+                [
+                    2486,
+                    2431,
+                    2339
+                ],
+                [
+                    2487,
+                    2432,
+                    2340
+                ],
+                [
+                    2488,
+                    2433,
+                    2341
+                ],
+                [
+                    2489,
+                    2434,
+                    2342
+                ],
+                [
+                    2490,
+                    2435,
+                    2343
+                ],
+                [
+                    2491,
+                    2436,
+                    2344
+                ],
+                [
+                    2492,
+                    2437,
+                    2345
+                ],
+                [
+                    2493,
+                    2438,
+                    2346
+                ],
+                [
+                    2494,
+                    2439,
+                    2347
+                ],
+                [
+                    2495,
+                    2440,
+                    2348
+                ],
+                [
+                    2496,
+                    2441,
+                    2349
+                ],
+                [
+                    2497,
+                    2442,
+                    2350
+                ],
+                [
+                    2498,
+                    2443,
+                    2351
+                ],
+                [
+                    2499,
+                    2444,
+                    2368
+                ]
+            ],
+            "output": 114619
+        },
+        {
+            "input": [
+                [
+                    868,
+                    1485,
+                    2457,
+                    395,
+                    2382,
+                    314,
+                    1979,
+                    528,
+                    728,
+                    1132,
+                    1436,
+                    1478,
+                    1306,
+                    963,
+                    2033,
+                    1976,
+                    1427,
+                    1549,
+                    1320,
+                    88,
+                    134,
+                    1125,
+                    114,
+                    2234,
+                    1283,
+                    1850,
+                    1536,
+                    2116,
+                    2018,
+                    1182,
+                    903,
+                    881,
+                    1447,
+                    19,
+                    1224,
+                    134,
+                    47,
+                    2091,
+                    1467,
+                    1340,
+                    1450,
+                    2472
+                ],
+                [
+                    1091,
+                    1486,
+                    2458,
+                    396,
+                    2383,
+                    1444,
+                    1980,
+                    529,
+                    1511,
+                    1133,
+                    1437,
+                    2101,
+                    2141,
+                    2339,
+                    2034,
+                    1977,
+                    1428,
+                    1550,
+                    2161,
+                    543,
+                    1632,
+                    2125,
+                    2469,
+                    2235,
+                    1284,
+                    1851,
+                    1537,
+                    2117,
+                    2019,
+                    2091,
+                    1991,
+                    1052,
+                    2384,
+                    455,
+                    1640,
+                    2081,
+                    2366,
+                    2092,
+                    1468,
+                    1341,
+                    1595,
+                    2473
+                ],
+                [
+                    1120,
+                    2266,
+                    2459,
+                    397,
+                    2384,
+                    1445,
+                    1981,
+                    808,
+                    1512,
+                    2174,
+                    2439,
+                    2102,
+                    2142,
+                    2340,
+                    2035,
+                    2002,
+                    1429,
+                    2122,
+                    2162,
+                    1055,
+                    1718,
+                    2126,
+                    2470,
+                    2236,
+                    1285,
+                    2020,
+                    1538,
+                    2221,
+                    2456,
+                    2092,
+                    1992,
+                    1053,
+                    2385,
+                    563,
+                    1641,
+                    2082,
+                    2367,
+                    2157,
+                    1886,
+                    1342,
+                    1596,
+                    2474
+                ],
+                [
+                    2494,
+                    2267,
+                    2460,
+                    398,
+                    2385,
+                    1446,
+                    1982,
+                    2296,
+                    2075,
+                    2175,
+                    2440,
+                    2103,
+                    2143,
+                    2341,
+                    2036,
+                    2003,
+                    1430,
+                    2128,
+                    2163,
+                    1056,
+                    2465,
+                    2127,
+                    2471,
+                    2237,
+                    1286,
+                    2021,
+                    1539,
+                    2400,
+                    2457,
+                    2093,
+                    1993,
+                    1802,
+                    2386,
+                    1120,
+                    1642,
+                    2083,
+                    2368,
+                    2158,
+                    1887,
+                    2046,
+                    1597,
+                    2475
+                ],
+                [
+                    2495,
+                    2313,
+                    2461,
+                    2131,
+                    2386,
+                    1674,
+                    1983,
+                    2297,
+                    2076,
+                    2176,
+                    2441,
+                    2104,
+                    2144,
+                    2342,
+                    2037,
+                    2004,
+                    1899,
+                    2304,
+                    2164,
+                    1569,
+                    2466,
+                    2128,
+                    2472,
+                    2238,
+                    1456,
+                    2022,
+                    1680,
+                    2401,
+                    2458,
+                    2094,
+                    1994,
+                    1803,
+                    2387,
+                    1121,
+                    1643,
+                    2084,
+                    2369,
+                    2159,
+                    1888,
+                    2224,
+                    1598,
+                    2476
+                ],
+                [
+                    2496,
+                    2314,
+                    2462,
+                    2132,
+                    2387,
+                    1675,
+                    1984,
+                    2298,
+                    2077,
+                    2177,
+                    2450,
+                    2105,
+                    2145,
+                    2343,
+                    2038,
+                    2005,
+                    1900,
+                    2305,
+                    2277,
+                    1570,
+                    2467,
+                    2129,
+                    2473,
+                    2239,
+                    1457,
+                    2023,
+                    1681,
+                    2402,
+                    2459,
+                    2095,
+                    1995,
+                    1804,
+                    2388,
+                    1122,
+                    1661,
+                    2085,
+                    2370,
+                    2483,
+                    1889,
+                    2225,
+                    1599,
+                    2477
+                ],
+                [
+                    2497,
+                    2315,
+                    2463,
+                    2449,
+                    2388,
+                    1676,
+                    1985,
+                    2299,
+                    2417,
+                    2178,
+                    2451,
+                    2106,
+                    2146,
+                    2344,
+                    2039,
+                    2006,
+                    1901,
+                    2306,
+                    2278,
+                    1571,
+                    2468,
+                    2417,
+                    2474,
+                    2240,
+                    1703,
+                    2024,
+                    1682,
+                    2403,
+                    2460,
+                    2143,
+                    2381,
+                    1993,
+                    2389,
+                    2314,
+                    1662,
+                    2086,
+                    2371,
+                    2484,
+                    1890,
+                    2401,
+                    1600,
+                    2478
+                ],
+                [
+                    2498,
+                    2316,
+                    2464,
+                    2450,
+                    2389,
+                    1677,
+                    2090,
+                    2300,
+                    2418,
+                    2179,
+                    2452,
+                    2107,
+                    2147,
+                    2345,
+                    2040,
+                    2007,
+                    1902,
+                    2307,
+                    2279,
+                    1572,
+                    2469,
+                    2418,
+                    2475,
+                    2241,
+                    1704,
+                    2204,
+                    1683,
+                    2404,
+                    2461,
+                    2144,
+                    2382,
+                    2020,
+                    2390,
+                    2315,
+                    1663,
+                    2087,
+                    2372,
+                    2485,
+                    1891,
+                    2402,
+                    1601,
+                    2479
+                ]
+            ],
+            "output": 229471
+        },
+        {
+            "input": [
+                [
+                    2091,
+                    1538,
+                    1215,
+                    1122,
+                    672,
+                    1607,
+                    504,
+                    2056,
+                    2351,
+                    1723
+                ],
+                [
+                    2092,
+                    2317,
+                    1361,
+                    1283,
+                    673,
+                    1608,
+                    2252,
+                    2239,
+                    2352,
+                    1724
+                ],
+                [
+                    2097,
+                    2318,
+                    1362,
+                    2316,
+                    854,
+                    1609,
+                    2456,
+                    2428,
+                    2353,
+                    1725
+                ],
+                [
+                    2098,
+                    2319,
+                    1363,
+                    2317,
+                    855,
+                    2462,
+                    2457,
+                    2429,
+                    2354,
+                    1726
+                ],
+                [
+                    2099,
+                    2320,
+                    2404,
+                    2318,
+                    2091,
+                    2463,
+                    2458,
+                    2430,
+                    2355,
+                    1727
+                ],
+                [
+                    2301,
+                    2321,
+                    2447,
+                    2319,
+                    2092,
+                    2464,
+                    2459,
+                    2431,
+                    2356,
+                    1728
+                ],
+                [
+                    2302,
+                    2322,
+                    2448,
+                    2320,
+                    2093,
+                    2465,
+                    2460,
+                    2474,
+                    2357,
+                    1729
+                ],
+                [
+                    2303,
+                    2323,
+                    2449,
+                    2321,
+                    2094,
+                    2466,
+                    2461,
+                    2475,
+                    2358,
+                    1730
+                ],
+                [
+                    2304,
+                    2324,
+                    2450,
+                    2322,
+                    2095,
+                    2467,
+                    2462,
+                    2476,
+                    2359,
+                    2089
+                ],
+                [
+                    2305,
+                    2325,
+                    2451,
+                    2323,
+                    2444,
+                    2468,
+                    2463,
+                    2477,
+                    2360,
+                    2090
+                ],
+                [
+                    2306,
+                    2326,
+                    2452,
+                    2324,
+                    2445,
+                    2469,
+                    2464,
+                    2478,
+                    2361,
+                    2091
+                ],
+                [
+                    2307,
+                    2327,
+                    2453,
+                    2325,
+                    2446,
+                    2470,
+                    2465,
+                    2479,
+                    2362,
+                    2386
+                ],
+                [
+                    2308,
+                    2443,
+                    2454,
+                    2326,
+                    2447,
+                    2471,
+                    2466,
+                    2480,
+                    2481,
+                    2387
+                ],
+                [
+                    2309,
+                    2444,
+                    2455,
+                    2327,
+                    2448,
+                    2472,
+                    2467,
+                    2481,
+                    2482,
+                    2432
+                ],
+                [
+                    2310,
+                    2445,
+                    2456,
+                    2328,
+                    2449,
+                    2473,
+                    2468,
+                    2482,
+                    2483,
+                    2433
+                ],
+                [
+                    2311,
+                    2446,
+                    2457,
+                    2329,
+                    2450,
+                    2474,
+                    2469,
+                    2483,
+                    2484,
+                    2434
+                ],
+                [
+                    2312,
+                    2447,
+                    2458,
+                    2484,
+                    2451,
+                    2475,
+                    2470,
+                    2484,
+                    2485,
+                    2435
+                ],
+                [
+                    2313,
+                    2448,
+                    2459,
+                    2485,
+                    2452,
+                    2476,
+                    2471,
+                    2485,
+                    2486,
+                    2436
+                ],
+                [
+                    2314,
+                    2449,
+                    2460,
+                    2486,
+                    2453,
+                    2477,
+                    2472,
+                    2486,
+                    2487,
+                    2437
+                ],
+                [
+                    2315,
+                    2450,
+                    2461,
+                    2487,
+                    2454,
+                    2478,
+                    2473,
+                    2487,
+                    2488,
+                    2438
+                ],
+                [
+                    2316,
+                    2451,
+                    2462,
+                    2488,
+                    2455,
+                    2479,
+                    2474,
+                    2488,
+                    2489,
+                    2439
+                ],
+                [
+                    2317,
+                    2452,
+                    2463,
+                    2489,
+                    2456,
+                    2480,
+                    2475,
+                    2489,
+                    2490,
+                    2440
+                ],
+                [
+                    2427,
+                    2453,
+                    2464,
+                    2490,
+                    2457,
+                    2481,
+                    2476,
+                    2490,
+                    2491,
+                    2441
+                ],
+                [
+                    2428,
+                    2454,
+                    2465,
+                    2491,
+                    2458,
+                    2482,
+                    2477,
+                    2491,
+                    2492,
+                    2442
+                ],
+                [
+                    2429,
+                    2455,
+                    2466,
+                    2492,
+                    2459,
+                    2483,
+                    2478,
+                    2492,
+                    2493,
+                    2443
+                ],
+                [
+                    2430,
+                    2456,
+                    2467,
+                    2493,
+                    2460,
+                    2484,
+                    2479,
+                    2493,
+                    2494,
+                    2444
+                ],
+                [
+                    2431,
+                    2457,
+                    2468,
+                    2494,
+                    2461,
+                    2485,
+                    2480,
+                    2494,
+                    2495,
+                    2445
+                ],
+                [
+                    2432,
+                    2458,
+                    2469,
+                    2495,
+                    2462,
+                    2486,
+                    2481,
+                    2495,
+                    2496,
+                    2446
+                ],
+                [
+                    2433,
+                    2459,
+                    2470,
+                    2496,
+                    2463,
+                    2487,
+                    2482,
+                    2496,
+                    2497,
+                    2447
+                ],
+                [
+                    2434,
+                    2460,
+                    2471,
+                    2497,
+                    2464,
+                    2488,
+                    2483,
+                    2497,
+                    2498,
+                    2448
+                ],
+                [
+                    2435,
+                    2461,
+                    2472,
+                    2498,
+                    2465,
+                    2489,
+                    2484,
+                    2498,
+                    2499,
+                    2449
+                ],
+                [
+                    2436,
+                    2462,
+                    2473,
+                    2499,
+                    2466,
+                    2490,
+                    2485,
+                    2499,
+                    2500,
+                    2450
+                ],
+                [
+                    2437,
+                    2463,
+                    2474,
+                    2500,
+                    2467,
+                    2491,
+                    2486,
+                    2500,
+                    2501,
+                    2451
+                ],
+                [
+                    2438,
+                    2464,
+                    2475,
+                    2501,
+                    2468,
+                    2492,
+                    2487,
+                    2501,
+                    2502,
+                    2452
+                ],
+                [
+                    2439,
+                    2465,
+                    2476,
+                    2502,
+                    2469,
+                    2493,
+                    2488,
+                    2502,
+                    2503,
+                    2473
+                ],
+                [
+                    2440,
+                    2466,
+                    2477,
+                    2503,
+                    2470,
+                    2494,
+                    2489,
+                    2503,
+                    2504,
+                    2474
+                ],
+                [
+                    2441,
+                    2467,
+                    2478,
+                    2504,
+                    2471,
+                    2495,
+                    2490,
+                    2504,
+                    2505,
+                    2475
+                ],
+                [
+                    2442,
+                    2468,
+                    2479,
+                    2505,
+                    2472,
+                    2496,
+                    2491,
+                    2505,
+                    2506,
+                    2476
+                ],
+                [
+                    2443,
+                    2469,
+                    2480,
+                    2506,
+                    2473,
+                    2497,
+                    2492,
+                    2506,
+                    2507,
+                    2477
+                ],
+                [
+                    2444,
+                    2470,
+                    2481,
+                    2507,
+                    2474,
+                    2498,
+                    2493,
+                    2507,
+                    2508,
+                    2478
+                ],
+                [
+                    2445,
+                    2471,
+                    2482,
+                    2508,
+                    2475,
+                    2499,
+                    2494,
+                    2508,
+                    2509,
+                    2479
+                ],
+                [
+                    2446,
+                    2472,
+                    2483,
+                    2509,
+                    2476,
+                    2500,
+                    2495,
+                    2509,
+                    2510,
+                    2480
+                ],
+                [
+                    2447,
+                    2473,
+                    2484,
+                    2510,
+                    2477,
+                    2501,
+                    2496,
+                    2510,
+                    2511,
+                    2481
+                ],
+                [
+                    2448,
+                    2474,
+                    2485,
+                    2511,
+                    2478,
+                    2502,
+                    2497,
+                    2511,
+                    2512,
+                    2482
+                ]
+            ],
+            "output": 504941
+        }
+    ],
+    "haskell_template": "minimumOperations :: [[Int]] -> Int\nminimumOperations grid ",
+    "ocaml_template": "let minimumOperations (grid: int list list) : int =  ",
+    "scala_template": "def minimumOperations(grid: List[List[Int]]): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public int minimumOperations(int[][] grid) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def minimumOperations(self, grid):\n        \"\"\"\n        :type grid: List[List[int]]\n        :rtype: int\n        \"\"\"\n        "
+}

minimum_operations_to_make_columns_strictly_increasing/ocaml_tests/main.ml

@@ -0,0 +1,42 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+    let minimumOperations (grid: int list list) : int =   failwith "Not implemented"
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 15 (minimumOperations [[3;2];[1;3];[3;4];[0;1]])
+
+let test2 _ = assert_equal 12 (minimumOperations [[3;2;1];[2;1;0];[1;2;3]])
+
+let test3 _ = assert_equal 12 (minimumOperations [[127; 732; 2076; 1498; 1120; 1701; 48; 1574; 2349; 8; 1946; 1434; 2138; 1519]; [2137; 1079; 2434; 1499; 1135; 1702; 66; 1575; 2350; 1980; 2137; 2467; 2139; 1520]])
+
+let test4 _ = assert_equal 12 (minimumOperations [[1451; 1480; 2377; 391; 714; 220; 433; 2198; 559; 1443; 1286; 947; 1212; 805; 2450; 1661; 1072; 1652; 801; 316; 273; 761; 1189; 2445; 996; 151; 1875; 676; 103; 7; 1610; 1520; 2035; 439; 1284; 1935; 93; 1342; 774; 1971; 1923; 937; 1301; 2206; 985; 1301; 1509; 2022; 1803]])
+
+let test5 _ = assert_equal 12 (minimumOperations [[1238; 1786; 31]; [2142; 1787; 1359]; [2280; 1788; 1360]; [2281; 1899; 1504]; [2282; 1900; 1505]; [2283; 1901; 2140]; [2284; 1902; 2141]; [2285; 1903; 2142]; [2286; 1904; 2143]; [2473; 1905; 2144]; [2474; 1906; 2285]; [2475; 1907; 2286]; [2476; 1908; 2287]; [2477; 1909; 2288]; [2478; 1917; 2289]; [2479; 1918; 2290]; [2480; 1919; 2291]; [2481; 2426; 2292]; [2482; 2427; 2293]; [2483; 2428; 2336]; [2484; 2429; 2337]; [2485; 2430; 2338]; [2486; 2431; 2339]; [2487; 2432; 2340]; [2488; 2433; 2341]; [2489; 2434; 2342]; [2490; 2435; 2343]; [2491; 2436; 2344]; [2492; 2437; 2345]; [2493; 2438; 2346]; [2494; 2439; 2347]; [2495; 2440; 2348]; [2496; 2441; 2349]; [2497; 2442; 2350]; [2498; 2443; 2351]; [2499; 2444; 2368]])
+
+let test6 _ = assert_equal 12 (minimumOperations [[868; 1485; 2457; 395; 2382; 314; 1979; 528; 728; 1132; 1436; 1478; 1306; 963; 2033; 1976; 1427; 1549; 1320; 88; 134; 1125; 114; 2234; 1283; 1850; 1536; 2116; 2018; 1182; 903; 881; 1447; 19; 1224; 134; 47; 2091; 1467; 1340; 1450; 2472]; [1091; 1486; 2458; 396; 2383; 1444; 1980; 529; 1511; 1133; 1437; 2101; 2141; 2339; 2034; 1977; 1428; 1550; 2161; 543; 1632; 2125; 2469; 2235; 1284; 1851; 1537; 2117; 2019; 2091; 1991; 1052; 2384; 455; 1640; 2081; 2366; 2092; 1468; 1341; 1595; 2473]; [1120; 2266; 2459; 397; 2384; 1445; 1981; 808; 1512; 2174; 2439; 2102; 2142; 2340; 2035; 2002; 1429; 2122; 2162; 1055; 1718; 2126; 2470; 2236; 1285; 2020; 1538; 2221; 2456; 2092; 1992; 1053; 2385; 563; 1641; 2082; 2367; 2157; 1886; 1342; 1596; 2474]; [2494; 2267; 2460; 398; 2385; 1446; 1982; 2296; 2075; 2175; 2440; 2103; 2143; 2341; 2036; 2003; 1430; 2128; 2163; 1056; 2465; 2127; 2471; 2237; 1286; 2021; 1539; 2400; 2457; 2093; 1993; 1802; 2386; 1120; 1642; 2083; 2368; 2158; 1887; 2046; 1597; 2475]; [2495; 2313; 2461; 2131; 2386; 1674; 1983; 2297; 2076; 2176; 2441; 2104; 2144; 2342; 2037; 2004; 1899; 2304; 2164; 1569; 2466; 2128; 2472; 2238; 1456; 2022; 1680; 2401; 2458; 2094; 1994; 1803; 2387; 1121; 1643; 2084; 2369; 2159; 1888; 2224; 1598; 2476]; [2496; 2314; 2462; 2132; 2387; 1675; 1984; 2298; 2077; 2177; 2450; 2105; 2145; 2343; 2038; 2005; 1900; 2305; 2277; 1570; 2467; 2129; 2473; 2239; 1457; 2023; 1681; 2402; 2459; 2095; 1995; 1804; 2388; 1122; 1661; 2085; 2370; 2483; 1889; 2225; 1599; 2477]; [2497; 2315; 2463; 2449; 2388; 1676; 1985; 2299; 2417; 2178; 2451; 2106; 2146; 2344; 2039; 2006; 1901; 2306; 2278; 1571; 2468; 2417; 2474; 2240; 1703; 2024; 1682; 2403; 2460; 2143; 2381; 1993; 2389; 2314; 1662; 2086; 2371; 2484; 1890; 2401; 1600; 2478]; [2498; 2316; 2464; 2450; 2389; 1677; 2090; 2300; 2418; 2179; 2452; 2107; 2147; 2345; 2040; 2007; 1902; 2307; 2279; 1572; 2469; 2418; 2475; 2241; 1704; 2204; 1683; 2404; 2461; 2144; 2382; 2020; 2390; 2315; 1663; 2087; 2372; 2485; 1891; 2402; 1601; 2479]])
+
+let test7 _ = assert_equal 12 (minimumOperations [[2091; 1538; 1215; 1122; 672; 1607; 504; 2056; 2351; 1723]; [2092; 2317; 1361; 1283; 673; 1608; 2252; 2239; 2352; 1724]; [2097; 2318; 1362; 2316; 854; 1609; 2456; 2428; 2353; 1725]; [2098; 2319; 1363; 2317; 855; 2462; 2457; 2429; 2354; 1726]; [2099; 2320; 2404; 2318; 2091; 2463; 2458; 2430; 2355; 1727]; [2301; 2321; 2447; 2319; 2092; 2464; 2459; 2431; 2356; 1728]; [2302; 2322; 2448; 2320; 2093; 2465; 2460; 2474; 2357; 1729]; [2303; 2323; 2449; 2321; 2094; 2466; 2461; 2475; 2358; 1730]; [2304; 2324; 2450; 2322; 2095; 2467; 2462; 2476; 2359; 2089]; [2305; 2325; 2451; 2323; 2444; 2468; 2463; 2477; 2360; 2090]; [2306; 2326; 2452; 2324; 2445; 2469; 2464; 2478; 2361; 2091]; [2307; 2327; 2453; 2325; 2446; 2470; 2465; 2479; 2362; 2386]; [2308; 2443; 2454; 2326; 2447; 2471; 2466; 2480; 2481; 2387]; [2309; 2444; 2455; 2327; 2448; 2472; 2467; 2481; 2482; 2432]; [2310; 2445; 2456; 2328; 2449; 2473; 2468; 2482; 2483; 2433]; [2311; 2446; 2457; 2329; 2450; 2474; 2469; 2483; 2484; 2434]; [2312; 2447; 2458; 2484; 2451; 2475; 2470; 2484; 2485; 2435]; [2313; 2448; 2459; 2485; 2452; 2476; 2471; 2485; 2486; 2436]; [2314; 2449; 2460; 2486; 2453; 2477; 2472; 2486; 2487; 2437]; [2315; 2450; 2461; 2487; 2454; 2478; 2473; 2487; 2488; 2438]; [2316; 2451; 2462; 2488; 2455; 2479; 2474; 2488; 2489; 2439]; [2317; 2452; 2463; 2489; 2456; 2480; 2475; 2489; 2490; 2440]; [2427; 2453; 2464; 2490; 2457; 2481; 2476; 2490; 2491; 2441]; [2428; 2454; 2465; 2491; 2458; 2482; 2477; 2491; 2492; 2442]; [2429; 2455; 2466; 2492; 2459; 2483; 2478; 2492; 2493; 2443]; [2430; 2456; 2467; 2493; 2460; 2484; 2479; 2493; 2494; 2444]; [2431; 2457; 2468; 2494; 2461; 2485; 2480; 2494; 2495; 2445]; [2432; 2458; 2469; 2495; 2462; 2486; 2481; 2495; 2496; 2446]; [2433; 2459; 2470; 2496; 2463; 2487; 2482; 2496; 2497; 2447]; [2434; 2460; 2471; 2497; 2464; 2488; 2483; 2497; 2498; 2448]; [2435; 2461; 2472; 2498; 2465; 2489; 2484; 2498; 2499; 2449]; [2436; 2462; 2473; 2499; 2466; 2490; 2485; 2499; 2500; 2450]; [2437; 2463; 2474; 2500; 2467; 2491; 2486; 2500; 2501; 2451]; [2438; 2464; 2475; 2501; 2468; 2492; 2487; 2501; 2502; 2452]; [2439; 2465; 2476; 2502; 2469; 2493; 2488; 2502; 2503; 2473]; [2440; 2466; 2477; 2503; 2470; 2494; 2489; 2503; 2504; 2474]; [2441; 2467; 2478; 2504; 2471; 2495; 2490; 2504; 2505; 2475]; [2442; 2468; 2479; 2505; 2472; 2496; 2491; 2505; 2506; 2476]; [2443; 2469; 2480; 2506; 2473; 2497; 2492; 2506; 2507; 2477]; [2444; 2470; 2481; 2507; 2474; 2498; 2493; 2507; 2508; 2478]; [2445; 2471; 2482; 2508; 2475; 2499; 2494; 2508; 2509; 2479]; [2446; 2472; 2483; 2509; 2476; 2500; 2495; 2509; 2510; 2480]; [2447; 2473; 2484; 2510; 2477; 2501; 2496; 2510; 2511; 2481]; [2448; 2474; 2485; 2511; 2478; 2502; 2497; 2511; 2512; 2482]])
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for minimumOperations" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+  "test3" >:: test3;
+  "test4" >:: test4;
+  "test5" >:: test5;
+  "test6" >:: test6;
+  "test7" >:: test7;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

minimum_operations_to_make_columns_strictly_increasing/scala_tests/MySuite.scala

@@ -0,0 +1,32 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.minimumOperations(List(List(3,2),List(1,3),List(3,4),List(0,1))), 15)
+  }
+
+  test("test2") {
+    assertEquals(Main.minimumOperations(List(List(3,2,1),List(2,1,0),List(1,2,3))), 12)
+  }
+
+  test("test3") {
+    assertEquals(Main.minimumOperations(List(127, 732, 2076, 1498, 1120, 1701, 48, 1574, 2349, 8, 1946, 1434, 2138, 1519),List(2137, 1079, 2434, 1499, 1135, 1702, 66, 1575, 2350, 1980, 2137, 2467, 2139, 1520)), 3718)
+  }
+
+  test("test4") {
+    assertEquals(Main.minimumOperations(List(1451, 1480, 2377, 391, 714, 220, 433, 2198, 559, 1443, 1286, 947, 1212, 805, 2450, 1661, 1072, 1652, 801, 316, 273, 761, 1189, 2445, 996, 151, 1875, 676, 103, 7, 1610, 1520, 2035, 439, 1284, 1935, 93, 1342, 774, 1971, 1923, 937, 1301, 2206, 985, 1301, 1509, 2022, 1803)), 0)
+  }
+
+  test("test5") {
+    assertEquals(Main.minimumOperations(List(1238, 1786, 31),List(2142, 1787, 1359),List(2280, 1788, 1360),List(2281, 1899, 1504),List(2282, 1900, 1505),List(2283, 1901, 2140),List(2284, 1902, 2141),List(2285, 1903, 2142),List(2286, 1904, 2143),List(2473, 1905, 2144),List(2474, 1906, 2285),List(2475, 1907, 2286),List(2476, 1908, 2287),List(2477, 1909, 2288),List(2478, 1917, 2289),List(2479, 1918, 2290),List(2480, 1919, 2291),List(2481, 2426, 2292),List(2482, 2427, 2293),List(2483, 2428, 2336),List(2484, 2429, 2337),List(2485, 2430, 2338),List(2486, 2431, 2339),List(2487, 2432, 2340),List(2488, 2433, 2341),List(2489, 2434, 2342),List(2490, 2435, 2343),List(2491, 2436, 2344),List(2492, 2437, 2345),List(2493, 2438, 2346),List(2494, 2439, 2347),List(2495, 2440, 2348),List(2496, 2441, 2349),List(2497, 2442, 2350),List(2498, 2443, 2351),List(2499, 2444, 2368)), 114619)
+  }
+
+  test("test6") {
+    assertEquals(Main.minimumOperations(List(868, 1485, 2457, 395, 2382, 314, 1979, 528, 728, 1132, 1436, 1478, 1306, 963, 2033, 1976, 1427, 1549, 1320, 88, 134, 1125, 114, 2234, 1283, 1850, 1536, 2116, 2018, 1182, 903, 881, 1447, 19, 1224, 134, 47, 2091, 1467, 1340, 1450, 2472),List(1091, 1486, 2458, 396, 2383, 1444, 1980, 529, 1511, 1133, 1437, 2101, 2141, 2339, 2034, 1977, 1428, 1550, 2161, 543, 1632, 2125, 2469, 2235, 1284, 1851, 1537, 2117, 2019, 2091, 1991, 1052, 2384, 455, 1640, 2081, 2366, 2092, 1468, 1341, 1595, 2473),List(1120, 2266, 2459, 397, 2384, 1445, 1981, 808, 1512, 2174, 2439, 2102, 2142, 2340, 2035, 2002, 1429, 2122, 2162, 1055, 1718, 2126, 2470, 2236, 1285, 2020, 1538, 2221, 2456, 2092, 1992, 1053, 2385, 563, 1641, 2082, 2367, 2157, 1886, 1342, 1596, 2474),List(2494, 2267, 2460, 398, 2385, 1446, 1982, 2296, 2075, 2175, 2440, 2103, 2143, 2341, 2036, 2003, 1430, 2128, 2163, 1056, 2465, 2127, 2471, 2237, 1286, 2021, 1539, 2400, 2457, 2093, 1993, 1802, 2386, 1120, 1642, 2083, 2368, 2158, 1887, 2046, 1597, 2475),List(2495, 2313, 2461, 2131, 2386, 1674, 1983, 2297, 2076, 2176, 2441, 2104, 2144, 2342, 2037, 2004, 1899, 2304, 2164, 1569, 2466, 2128, 2472, 2238, 1456, 2022, 1680, 2401, 2458, 2094, 1994, 1803, 2387, 1121, 1643, 2084, 2369, 2159, 1888, 2224, 1598, 2476),List(2496, 2314, 2462, 2132, 2387, 1675, 1984, 2298, 2077, 2177, 2450, 2105, 2145, 2343, 2038, 2005, 1900, 2305, 2277, 1570, 2467, 2129, 2473, 2239, 1457, 2023, 1681, 2402, 2459, 2095, 1995, 1804, 2388, 1122, 1661, 2085, 2370, 2483, 1889, 2225, 1599, 2477),List(2497, 2315, 2463, 2449, 2388, 1676, 1985, 2299, 2417, 2178, 2451, 2106, 2146, 2344, 2039, 2006, 1901, 2306, 2278, 1571, 2468, 2417, 2474, 2240, 1703, 2024, 1682, 2403, 2460, 2143, 2381, 1993, 2389, 2314, 1662, 2086, 2371, 2484, 1890, 2401, 1600, 2478),List(2498, 2316, 2464, 2450, 2389, 1677, 2090, 2300, 2418, 2179, 2452, 2107, 2147, 2345, 2040, 2007, 1902, 2307, 2279, 1572, 2469, 2418, 2475, 2241, 1704, 2204, 1683, 2404, 2461, 2144, 2382, 2020, 2390, 2315, 1663, 2087, 2372, 2485, 1891, 2402, 1601, 2479)), 229471)
+  }
+
+  test("test7") {
+    assertEquals(Main.minimumOperations(List(2091, 1538, 1215, 1122, 672, 1607, 504, 2056, 2351, 1723),List(2092, 2317, 1361, 1283, 673, 1608, 2252, 2239, 2352, 1724),List(2097, 2318, 1362, 2316, 854, 1609, 2456, 2428, 2353, 1725),List(2098, 2319, 1363, 2317, 855, 2462, 2457, 2429, 2354, 1726),List(2099, 2320, 2404, 2318, 2091, 2463, 2458, 2430, 2355, 1727),List(2301, 2321, 2447, 2319, 2092, 2464, 2459, 2431, 2356, 1728),List(2302, 2322, 2448, 2320, 2093, 2465, 2460, 2474, 2357, 1729),List(2303, 2323, 2449, 2321, 2094, 2466, 2461, 2475, 2358, 1730),List(2304, 2324, 2450, 2322, 2095, 2467, 2462, 2476, 2359, 2089),List(2305, 2325, 2451, 2323, 2444, 2468, 2463, 2477, 2360, 2090),List(2306, 2326, 2452, 2324, 2445, 2469, 2464, 2478, 2361, 2091),List(2307, 2327, 2453, 2325, 2446, 2470, 2465, 2479, 2362, 2386),List(2308, 2443, 2454, 2326, 2447, 2471, 2466, 2480, 2481, 2387),List(2309, 2444, 2455, 2327, 2448, 2472, 2467, 2481, 2482, 2432),List(2310, 2445, 2456, 2328, 2449, 2473, 2468, 2482, 2483, 2433),List(2311, 2446, 2457, 2329, 2450, 2474, 2469, 2483, 2484, 2434),List(2312, 2447, 2458, 2484, 2451, 2475, 2470, 2484, 2485, 2435),List(2313, 2448, 2459, 2485, 2452, 2476, 2471, 2485, 2486, 2436),List(2314, 2449, 2460, 2486, 2453, 2477, 2472, 2486, 2487, 2437),List(2315, 2450, 2461, 2487, 2454, 2478, 2473, 2487, 2488, 2438),List(2316, 2451, 2462, 2488, 2455, 2479, 2474, 2488, 2489, 2439),List(2317, 2452, 2463, 2489, 2456, 2480, 2475, 2489, 2490, 2440),List(2427, 2453, 2464, 2490, 2457, 2481, 2476, 2490, 2491, 2441),List(2428, 2454, 2465, 2491, 2458, 2482, 2477, 2491, 2492, 2442),List(2429, 2455, 2466, 2492, 2459, 2483, 2478, 2492, 2493, 2443),List(2430, 2456, 2467, 2493, 2460, 2484, 2479, 2493, 2494, 2444),List(2431, 2457, 2468, 2494, 2461, 2485, 2480, 2494, 2495, 2445),List(2432, 2458, 2469, 2495, 2462, 2486, 2481, 2495, 2496, 2446),List(2433, 2459, 2470, 2496, 2463, 2487, 2482, 2496, 2497, 2447),List(2434, 2460, 2471, 2497, 2464, 2488, 2483, 2497, 2498, 2448),List(2435, 2461, 2472, 2498, 2465, 2489, 2484, 2498, 2499, 2449),List(2436, 2462, 2473, 2499, 2466, 2490, 2485, 2499, 2500, 2450),List(2437, 2463, 2474, 2500, 2467, 2491, 2486, 2500, 2501, 2451),List(2438, 2464, 2475, 2501, 2468, 2492, 2487, 2501, 2502, 2452),List(2439, 2465, 2476, 2502, 2469, 2493, 2488, 2502, 2503, 2473),List(2440, 2466, 2477, 2503, 2470, 2494, 2489, 2503, 2504, 2474),List(2441, 2467, 2478, 2504, 2471, 2495, 2490, 2504, 2505, 2475),List(2442, 2468, 2479, 2505, 2472, 2496, 2491, 2505, 2506, 2476),List(2443, 2469, 2480, 2506, 2473, 2497, 2492, 2506, 2507, 2477),List(2444, 2470, 2481, 2507, 2474, 2498, 2493, 2507, 2508, 2478),List(2445, 2471, 2482, 2508, 2475, 2499, 2494, 2508, 2509, 2479),List(2446, 2472, 2483, 2509, 2476, 2500, 2495, 2509, 2510, 2480),List(2447, 2473, 2484, 2510, 2477, 2501, 2496, 2510, 2511, 2481),List(2448, 2474, 2485, 2511, 2478, 2502, 2497, 2511, 2512, 2482)), 504941)
+  }
+
+}

minimum_operations_to_make_median_of_array_equal_to_k/haskell_tests/Main.hs

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

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

minimum_operations_to_make_median_of_array_equal_to_k/meta.json

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

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

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

minimum_operations_to_make_the_array_alternating/meta.json

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

minimum_operations_to_make_the_array_alternating/ocaml_tests/main.ml

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