76beca8b91163d201b98ba1949b7709c095718eced70f58e1d134245783b2a54

.gitattributes

@@ -280,3 +280,4 @@ sliding_subarray_beauty/meta.json filter=lfs diff=lfs merge=lfs -text
 smallest_missing_non_negative_integer_after_operations/meta.json filter=lfs diff=lfs merge=lfs -text
 solving_questions_with_brainpower/meta.json filter=lfs diff=lfs merge=lfs -text
 sorted_gcd_pair_queries/meta.json filter=lfs diff=lfs merge=lfs -text
+steps_to_make_array_non_decreasing/meta.json filter=lfs diff=lfs merge=lfs -text

sorting_three_groups/meta.json

@@ -0,0 +1,647 @@
+{
+    "id": 2904,
+    "name": "sorting_three_groups",
+    "difficulty": "Medium",
+    "link": "https://leetcode.com/problems/sorting-three-groups/",
+    "date": "1691193600000",
+    "task_description": "You are given an integer array `nums`. Each element in `nums` is 1, 2 or 3. In each operation, you can remove an element from `nums`. Return the **minimum** number of operations to make `nums` **non-decreasing**. **Example 1:** **Input:** nums = [2,1,3,2,1] **Output:** 3 **Explanation:** One of the optimal solutions is to remove `nums[0]`, `nums[2]` and `nums[3]`. **Example 2:** **Input:** nums = [1,3,2,1,3,3] **Output:** 2 **Explanation:** One of the optimal solutions is to remove `nums[1]` and `nums[2]`. **Example 3:** **Input:** nums = [2,2,2,2,3,3] **Output:** 0 **Explanation:** `nums` is already non-decreasing. **Constraints:** `1 <= nums.length <= 100` `1 <= nums[i] <= 3` **Follow-up:** Can you come up with an algorithm that runs in `O(n)` time complexity?",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "nums = [2,1,3,2,1]",
+            "output": "3 "
+        },
+        {
+            "label": "Example 2",
+            "input": "nums = [1,3,2,1,3,3]",
+            "output": "2 "
+        },
+        {
+            "label": "Example 3",
+            "input": "nums = [2,2,2,2,3,3]",
+            "output": "0 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                2,
+                1,
+                3,
+                3,
+                3,
+                3,
+                3,
+                2,
+                1,
+                2,
+                1,
+                1,
+                3,
+                2,
+                3,
+                1,
+                3,
+                3,
+                1,
+                2,
+                1,
+                1,
+                1,
+                2,
+                2,
+                3,
+                1,
+                1,
+                3,
+                1,
+                3,
+                1,
+                2,
+                1,
+                1,
+                1,
+                2,
+                2,
+                2,
+                2,
+                1,
+                3,
+                3,
+                1,
+                2,
+                1,
+                2,
+                3,
+                1,
+                1,
+                2,
+                2,
+                2,
+                3,
+                1,
+                1,
+                3,
+                2,
+                2,
+                1,
+                2,
+                2,
+                3,
+                1,
+                2,
+                2
+            ],
+            "output": 35
+        },
+        {
+            "input": [
+                2,
+                3,
+                1,
+                2,
+                3,
+                3,
+                2,
+                3,
+                1,
+                1,
+                1,
+                3,
+                1,
+                3,
+                3,
+                3,
+                2,
+                1,
+                1,
+                3,
+                1,
+                1,
+                3,
+                2,
+                2,
+                1,
+                3,
+                2,
+                2,
+                2,
+                1,
+                2,
+                3,
+                2,
+                1,
+                1,
+                3,
+                3,
+                2,
+                1,
+                2,
+                3,
+                3,
+                2,
+                2,
+                3,
+                3,
+                3,
+                2,
+                3,
+                3,
+                2,
+                3,
+                2,
+                1,
+                3,
+                1
+            ],
+            "output": 30
+        },
+        {
+            "input": [
+                3,
+                2,
+                2,
+                2,
+                2,
+                1,
+                1,
+                1,
+                2,
+                3,
+                3,
+                1,
+                3,
+                3,
+                2,
+                1,
+                3,
+                1,
+                1,
+                1,
+                1,
+                2,
+                2,
+                2,
+                3,
+                2,
+                2,
+                2,
+                1,
+                1,
+                1,
+                2,
+                2,
+                2,
+                1,
+                1,
+                2,
+                3,
+                3,
+                2,
+                2,
+                3,
+                3,
+                3,
+                2,
+                2,
+                3,
+                1,
+                1,
+                3,
+                3,
+                3,
+                3,
+                1,
+                1,
+                2,
+                3,
+                3,
+                1,
+                1,
+                2,
+                1,
+                1,
+                3,
+                1,
+                2,
+                2,
+                2,
+                3,
+                3,
+                3,
+                3,
+                1,
+                3,
+                3,
+                1,
+                1,
+                2,
+                1,
+                1,
+                3,
+                2,
+                1,
+                2,
+                3
+            ],
+            "output": 45
+        },
+        {
+            "input": [
+                2,
+                1,
+                2,
+                1,
+                3,
+                1,
+                3,
+                3,
+                2,
+                2,
+                1,
+                2,
+                3,
+                3,
+                3,
+                1,
+                3,
+                3,
+                1,
+                3,
+                2,
+                2,
+                3,
+                1,
+                3,
+                1,
+                1,
+                3,
+                2,
+                3,
+                2,
+                2,
+                2,
+                2,
+                2,
+                1,
+                3,
+                2,
+                1,
+                2,
+                3,
+                3,
+                2,
+                2,
+                1,
+                3,
+                2,
+                1,
+                3,
+                1,
+                2,
+                2,
+                3,
+                3,
+                3,
+                2,
+                1,
+                2
+            ],
+            "output": 33
+        },
+        {
+            "input": [
+                2,
+                1,
+                2,
+                2,
+                3,
+                2,
+                3,
+                3,
+                2,
+                3,
+                2,
+                2,
+                3
+            ],
+            "output": 5
+        },
+        {
+            "input": [
+                1,
+                3,
+                2,
+                1,
+                1,
+                3,
+                3,
+                1,
+                1,
+                2,
+                1,
+                3,
+                2,
+                3,
+                2,
+                1,
+                3,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                2,
+                1,
+                3,
+                2,
+                1,
+                2,
+                1,
+                1,
+                1,
+                3,
+                3,
+                2,
+                3,
+                1,
+                2,
+                3,
+                2,
+                2,
+                2,
+                2,
+                1
+            ],
+            "output": 20
+        },
+        {
+            "input": [
+                2,
+                1,
+                1,
+                2,
+                1,
+                2,
+                1,
+                2,
+                3,
+                1,
+                3,
+                2,
+                2,
+                2,
+                2,
+                3,
+                3,
+                1,
+                3,
+                3,
+                2,
+                1,
+                2,
+                3,
+                3,
+                3,
+                2,
+                2,
+                1,
+                1,
+                1,
+                2,
+                1,
+                3,
+                2,
+                2,
+                3,
+                3,
+                1,
+                3,
+                1,
+                1,
+                3,
+                1,
+                2,
+                3,
+                3,
+                3,
+                2,
+                2,
+                1,
+                1,
+                3
+            ],
+            "output": 28
+        },
+        {
+            "input": [
+                1,
+                2,
+                3,
+                1,
+                3,
+                3,
+                2,
+                2,
+                1,
+                2,
+                1,
+                2,
+                2,
+                2,
+                3,
+                2,
+                1,
+                2,
+                3,
+                3,
+                3,
+                3,
+                2,
+                1,
+                2,
+                2,
+                3,
+                2,
+                3,
+                1,
+                2,
+                3,
+                2,
+                3,
+                3,
+                1,
+                3,
+                2,
+                1,
+                1,
+                1,
+                3,
+                3,
+                2,
+                2,
+                3,
+                2,
+                3,
+                3,
+                2,
+                3,
+                3,
+                2,
+                3,
+                2,
+                3,
+                2,
+                1,
+                1,
+                2,
+                3,
+                3,
+                1,
+                1,
+                1,
+                3,
+                3,
+                2,
+                1,
+                3,
+                1,
+                2,
+                1,
+                3,
+                3,
+                3,
+                3,
+                1,
+                1,
+                3,
+                1,
+                2,
+                1,
+                2,
+                2,
+                1,
+                3,
+                1
+            ],
+            "output": 48
+        },
+        {
+            "input": [
+                1,
+                1,
+                2,
+                1,
+                1,
+                3,
+                2,
+                1,
+                1,
+                1,
+                2,
+                1,
+                2,
+                1,
+                3,
+                1,
+                3,
+                1,
+                2,
+                1,
+                1,
+                1,
+                1,
+                1,
+                3,
+                2,
+                3,
+                3,
+                2,
+                1,
+                1,
+                2,
+                2,
+                2,
+                2,
+                2,
+                3,
+                2,
+                3,
+                3,
+                2,
+                2,
+                1,
+                2,
+                1,
+                3,
+                2,
+                2,
+                3,
+                2,
+                3,
+                1,
+                2,
+                3,
+                2,
+                3,
+                1,
+                2,
+                2,
+                3,
+                1,
+                1,
+                1,
+                3,
+                2,
+                1,
+                1,
+                3,
+                1,
+                2,
+                1,
+                3,
+                1,
+                3,
+                3,
+                2,
+                3,
+                2,
+                1,
+                1,
+                2,
+                1,
+                2
+            ],
+            "output": 42
+        },
+        {
+            "input": [
+                1,
+                2,
+                2,
+                3,
+                2,
+                2,
+                1,
+                2,
+                2,
+                2,
+                2,
+                3,
+                1,
+                2,
+                3,
+                2,
+                2
+            ],
+            "output": 5
+        }
+    ],
+    "haskell_template": "minimumOperations :: [Int] -> Int\nminimumOperations nums ",
+    "ocaml_template": "let minimumOperations (nums: int list) : int =  ",
+    "scala_template": "def minimumOperations(nums: List[Int]): Int = { \n    \n}",
+    "java_template": "public static int minimumOperations(List<Integer> nums) {\n\n}",
+    "python_template": "class Solution(object):\n    def minimumOperations(self, nums):\n        \"\"\"\n        :type nums: List[int]\n        :rtype: int\n        \"\"\"\n        "
+}

sorting_three_groups/ocaml_tests/main.ml

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

sorting_three_groups/scala_tests/MySuite.scala

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

special_array_i/haskell_tests/Main.hs

@@ -0,0 +1,44 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+isArraySpecial :: [Int] -> Bool
+isArraySpecial nums = undefined
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (isArraySpecial [1])," True (isArraySpecial [1]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (isArraySpecial [2,1,4])," True (isArraySpecial [2,1,4]))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (isArraySpecial [4,3,1,6])," False (isArraySpecial [4,3,1,6]))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (isArraySpecial [46, 83, 12, 71, 62, 39, 54, 19, 88, 95, 72, 95, 6, 85, 16, 33, 22, 33, 42, 7, 50, 7, 50, 17, 34, 53, 32, 49, 62, 13, 2, 77, 10, 13])," True (isArraySpecial [46, 83, 12, 71, 62, 39, 54, 19, 88, 95, 72, 95, 6, 85, 16, 33, 22, 33, 42, 7, 50, 7, 50, 17, 34, 53, 32, 49, 62, 13, 2, 77, 10, 13]))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (isArraySpecial [52, 45, 36, 81, 80, 39, 46, 19, 38, 59, 14, 5, 96, 59, 62, 35, 42, 89, 88, 91, 56, 73, 4])," True (isArraySpecial [52, 45, 36, 81, 80, 39, 46, 19, 38, 59, 14, 5, 96, 59, 62, 35, 42, 89, 88, 91, 56, 73, 4]))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (isArraySpecial [78, 61, 30, 7, 6, 99, 12, 31, 100, 11, 12, 29, 90, 51, 68])," True (isArraySpecial [78, 61, 30, 7, 6, 99, 12, 31, 100, 11, 12, 29, 90, 51, 68]))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (isArraySpecial [10, 51, 68, 35, 64, 33, 4, 17, 18, 71, 78, 79, 40, 91, 70, 37, 46, 59, 100, 55, 96, 41, 22, 27, 94, 49, 14, 71, 70, 9, 12, 21, 50, 95, 60, 7, 2, 7, 58, 23, 96, 25, 62, 73, 12, 47, 78, 53, 16, 79, 62, 13, 70, 35, 62, 7, 10, 79, 12, 25, 28, 3, 78, 41, 54, 89, 90, 43, 20, 85, 8, 41, 68, 81, 14, 69, 100, 23, 36, 39, 90, 17, 64, 11, 82, 91, 50])," True (isArraySpecial [10, 51, 68, 35, 64, 33, 4, 17, 18, 71, 78, 79, 40, 91, 70, 37, 46, 59, 100, 55, 96, 41, 22, 27, 94, 49, 14, 71, 70, 9, 12, 21, 50, 95, 60, 7, 2, 7, 58, 23, 96, 25, 62, 73, 12, 47, 78, 53, 16, 79, 62, 13, 70, 35, 62, 7, 10, 79, 12, 25, 28, 3, 78, 41, 54, 89, 90, 43, 20, 85, 8, 41, 68, 81, 14, 69, 100, 23, 36, 39, 90, 17, 64, 11, 82, 91, 50]))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (isArraySpecial [32, 45, 8, 79, 60, 17, 62, 71, 36, 95, 72, 57, 48, 49, 8, 81, 86, 65, 74, 35, 94, 23, 26, 37, 74, 67, 4, 37, 58, 71, 80, 45, 64, 7, 98, 95, 98, 35, 36, 25, 74, 57, 64, 13, 22, 71, 80, 17, 90, 41, 42, 23, 70, 81, 74, 13, 84, 71, 54, 9, 90, 39, 100, 81, 70, 31, 44, 15])," True (isArraySpecial [32, 45, 8, 79, 60, 17, 62, 71, 36, 95, 72, 57, 48, 49, 8, 81, 86, 65, 74, 35, 94, 23, 26, 37, 74, 67, 4, 37, 58, 71, 80, 45, 64, 7, 98, 95, 98, 35, 36, 25, 74, 57, 64, 13, 22, 71, 80, 17, 90, 41, 42, 23, 70, 81, 74, 13, 84, 71, 54, 9, 90, 39, 100, 81, 70, 31, 44, 15]))
+
+
+-- 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]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

special_array_i/java_tests/Main.java

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

special_array_i/meta.json

@@ -0,0 +1,284 @@
+{
+    "id": 3429,
+    "name": "special_array_i",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/special-array-i/",
+    "date": "2024-05-12 00:00:00",
+    "task_description": "An array is considered **special** if the _parity_ of every pair of adjacent elements is different. In other words, one element in each pair **must** be even, and the other **must** be odd. You are given an array of integers `nums`. Return `true` if `nums` is a **special** array, otherwise, return `false`. **Example 1:** **Input:** nums = [1] **Output:** true **Explanation:** There is only one element. So the answer is `true`. **Example 2:** **Input:** nums = [2,1,4] **Output:** true **Explanation:** There is only two pairs: `(2,1)` and `(1,4)`, and both of them contain numbers with different parity. So the answer is `true`. **Example 3:** **Input:** nums = [4,3,1,6] **Output:** false **Explanation:** `nums[1]` and `nums[2]` are both odd. So the answer is `false`. **Constraints:** `1 <= nums.length <= 100` `1 <= nums[i] <= 100`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "nums = [1]",
+            "output": "true "
+        },
+        {
+            "label": "Example 2",
+            "input": "nums = [2,1,4]",
+            "output": "true "
+        },
+        {
+            "label": "Example 3",
+            "input": "nums = [4,3,1,6]",
+            "output": "false "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                46,
+                83,
+                12,
+                71,
+                62,
+                39,
+                54,
+                19,
+                88,
+                95,
+                72,
+                95,
+                6,
+                85,
+                16,
+                33,
+                22,
+                33,
+                42,
+                7,
+                50,
+                7,
+                50,
+                17,
+                34,
+                53,
+                32,
+                49,
+                62,
+                13,
+                2,
+                77,
+                10,
+                13
+            ],
+            "output": true
+        },
+        {
+            "input": [
+                52,
+                45,
+                36,
+                81,
+                80,
+                39,
+                46,
+                19,
+                38,
+                59,
+                14,
+                5,
+                96,
+                59,
+                62,
+                35,
+                42,
+                89,
+                88,
+                91,
+                56,
+                73,
+                4
+            ],
+            "output": true
+        },
+        {
+            "input": [
+                78,
+                61,
+                30,
+                7,
+                6,
+                99,
+                12,
+                31,
+                100,
+                11,
+                12,
+                29,
+                90,
+                51,
+                68
+            ],
+            "output": true
+        },
+        {
+            "input": [
+                10,
+                51,
+                68,
+                35,
+                64,
+                33,
+                4,
+                17,
+                18,
+                71,
+                78,
+                79,
+                40,
+                91,
+                70,
+                37,
+                46,
+                59,
+                100,
+                55,
+                96,
+                41,
+                22,
+                27,
+                94,
+                49,
+                14,
+                71,
+                70,
+                9,
+                12,
+                21,
+                50,
+                95,
+                60,
+                7,
+                2,
+                7,
+                58,
+                23,
+                96,
+                25,
+                62,
+                73,
+                12,
+                47,
+                78,
+                53,
+                16,
+                79,
+                62,
+                13,
+                70,
+                35,
+                62,
+                7,
+                10,
+                79,
+                12,
+                25,
+                28,
+                3,
+                78,
+                41,
+                54,
+                89,
+                90,
+                43,
+                20,
+                85,
+                8,
+                41,
+                68,
+                81,
+                14,
+                69,
+                100,
+                23,
+                36,
+                39,
+                90,
+                17,
+                64,
+                11,
+                82,
+                91,
+                50
+            ],
+            "output": true
+        },
+        {
+            "input": [
+                32,
+                45,
+                8,
+                79,
+                60,
+                17,
+                62,
+                71,
+                36,
+                95,
+                72,
+                57,
+                48,
+                49,
+                8,
+                81,
+                86,
+                65,
+                74,
+                35,
+                94,
+                23,
+                26,
+                37,
+                74,
+                67,
+                4,
+                37,
+                58,
+                71,
+                80,
+                45,
+                64,
+                7,
+                98,
+                95,
+                98,
+                35,
+                36,
+                25,
+                74,
+                57,
+                64,
+                13,
+                22,
+                71,
+                80,
+                17,
+                90,
+                41,
+                42,
+                23,
+                70,
+                81,
+                74,
+                13,
+                84,
+                71,
+                54,
+                9,
+                90,
+                39,
+                100,
+                81,
+                70,
+                31,
+                44,
+                15
+            ],
+            "output": true
+        }
+    ],
+    "haskell_template": "isArraySpecial :: [Int] -> Bool\nisArraySpecial nums ",
+    "ocaml_template": "let isArraySpecial (nums: int list) : bool =  ",
+    "scala_template": "def isArraySpecial(nums: List[Int]): Boolean = { \n    \n}",
+    "java_template": "class Solution {\n    public boolean isArraySpecial(int[] nums) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def isArraySpecial(self, nums):\n        \"\"\"\n        :type nums: List[int]\n        :rtype: bool\n        \"\"\"\n        "
+}

special_array_i/ocaml_tests/main.ml

@@ -0,0 +1,45 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+    let isArraySpecial (nums: int list) : bool =   failwith "Not implemented"
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal true (isArraySpecial [1])
+
+let test2 _ = assert_equal true (isArraySpecial [2;1;4])
+
+let test3 _ = assert_equal false (isArraySpecial [4;3;1;6])
+
+let test4 _ = assert_equal false (isArraySpecial [46; 83; 12; 71; 62; 39; 54; 19; 88; 95; 72; 95; 6; 85; 16; 33; 22; 33; 42; 7; 50; 7; 50; 17; 34; 53; 32; 49; 62; 13; 2; 77; 10; 13])
+
+let test5 _ = assert_equal false (isArraySpecial [52; 45; 36; 81; 80; 39; 46; 19; 38; 59; 14; 5; 96; 59; 62; 35; 42; 89; 88; 91; 56; 73; 4])
+
+let test6 _ = assert_equal false (isArraySpecial [78; 61; 30; 7; 6; 99; 12; 31; 100; 11; 12; 29; 90; 51; 68])
+
+let test7 _ = assert_equal false (isArraySpecial [10; 51; 68; 35; 64; 33; 4; 17; 18; 71; 78; 79; 40; 91; 70; 37; 46; 59; 100; 55; 96; 41; 22; 27; 94; 49; 14; 71; 70; 9; 12; 21; 50; 95; 60; 7; 2; 7; 58; 23; 96; 25; 62; 73; 12; 47; 78; 53; 16; 79; 62; 13; 70; 35; 62; 7; 10; 79; 12; 25; 28; 3; 78; 41; 54; 89; 90; 43; 20; 85; 8; 41; 68; 81; 14; 69; 100; 23; 36; 39; 90; 17; 64; 11; 82; 91; 50])
+
+let test8 _ = assert_equal false (isArraySpecial [32; 45; 8; 79; 60; 17; 62; 71; 36; 95; 72; 57; 48; 49; 8; 81; 86; 65; 74; 35; 94; 23; 26; 37; 74; 67; 4; 37; 58; 71; 80; 45; 64; 7; 98; 95; 98; 35; 36; 25; 74; 57; 64; 13; 22; 71; 80; 17; 90; 41; 42; 23; 70; 81; 74; 13; 84; 71; 54; 9; 90; 39; 100; 81; 70; 31; 44; 15])
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for isArraySpecial" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+  "test3" >:: test3;
+  "test4" >:: test4;
+  "test5" >:: test5;
+  "test6" >:: test6;
+  "test7" >:: test7;
+  "test8" >:: test8;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

special_array_i/scala_tests/MySuite.scala

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

special_array_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(new ArrayList<>(Arrays.asList(false)), isArraySpecial(new ArrayList<>(Arrays.asList(3,4,1,2,6)), new ArrayList<>(Arrays.asList(new ArrayList<>(Arrays.asList(0,4))))));
+}
+@Test
+public void test2() {
+    assertEquals(new ArrayList<>(Arrays.asList(false,true)), isArraySpecial(new ArrayList<>(Arrays.asList(4,3,1,6)), new ArrayList<>(Arrays.asList(new ArrayList<>(Arrays.asList(0,2)),new ArrayList<>(Arrays.asList(2,3))))));
+}
+
+}

special_permutations/haskell_tests/Main.hs

@@ -0,0 +1,41 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+specialPerm :: [Int] -> Int
+specialPerm nums = undefined
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (specialPerm [2,3,6])," 2 (specialPerm [2,3,6]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (specialPerm [1,4,3])," 2 (specialPerm [1,4,3]))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (specialPerm [584117688, 128132521, 483733809, 538103732, 157980701, 84500114, 369758978, 417335206, 834992633])," 0 (specialPerm [584117688, 128132521, 483733809, 538103732, 157980701, 84500114, 369758978, 417335206, 834992633]))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (specialPerm [716189780, 829231105, 799685662, 706127727, 642091233, 653562772, 19107990, 817847028, 452438656, 309420299, 224255714, 378823621, 893604088, 555231725])," 0 (specialPerm [716189780, 829231105, 799685662, 706127727, 642091233, 653562772, 19107990, 817847028, 452438656, 309420299, 224255714, 378823621, 893604088, 555231725]))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (specialPerm [915827588, 281855433, 282404443, 237318432, 258066764, 83688214, 236117470, 134376301, 125033736, 406824599, 806597217, 175838204, 448108347])," 0 (specialPerm [915827588, 281855433, 282404443, 237318432, 258066764, 83688214, 236117470, 134376301, 125033736, 406824599, 806597217, 175838204, 448108347]))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (specialPerm [726633986, 400995617, 693097314, 440474407, 63494536, 993852230, 881042725, 924564810])," 0 (specialPerm [726633986, 400995617, 693097314, 440474407, 63494536, 993852230, 881042725, 924564810]))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (specialPerm [744707562, 793994140, 180416571, 473700883, 587397301, 367020656, 905392500, 925682568, 353345376, 696934710, 546914520, 207602398, 366110622, 970835618])," 0 (specialPerm [744707562, 793994140, 180416571, 473700883, 587397301, 367020656, 905392500, 925682568, 353345376, 696934710, 546914520, 207602398, 366110622, 970835618]))
+
+
+-- 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

special_permutations/java_tests/Main.java

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

special_permutations/meta.json

@@ -0,0 +1,110 @@
+{
+    "id": 2848,
+    "name": "special_permutations",
+    "difficulty": "Medium",
+    "link": "https://leetcode.com/problems/special-permutations/",
+    "date": "2023-06-11 00:00:00",
+    "task_description": "You are given a **0-indexed** integer array `nums` containing `n` **distinct** positive integers. A permutation of `nums` is called special if: For all indexes `0 <= i < n - 1`, either `nums[i] % nums[i+1] == 0` or `nums[i+1] % nums[i] == 0`. Return _the total number of special permutations. _As the answer could be large, return it **modulo **`109 + 7`. **Example 1:** ``` **Input:** nums = [2,3,6] **Output:** 2 **Explanation:** [3,6,2] and [2,6,3] are the two special permutations of nums. ``` **Example 2:** ``` **Input:** nums = [1,4,3] **Output:** 2 **Explanation:** [3,1,4] and [4,1,3] are the two special permutations of nums. ``` **Constraints:** `2 <= nums.length <= 14` `1 <= nums[i] <= 109`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "nums = [2,3,6]",
+            "output": "2 "
+        },
+        {
+            "label": "Example 2",
+            "input": "nums = [1,4,3]",
+            "output": "2 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                584117688,
+                128132521,
+                483733809,
+                538103732,
+                157980701,
+                84500114,
+                369758978,
+                417335206,
+                834992633
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                716189780,
+                829231105,
+                799685662,
+                706127727,
+                642091233,
+                653562772,
+                19107990,
+                817847028,
+                452438656,
+                309420299,
+                224255714,
+                378823621,
+                893604088,
+                555231725
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                915827588,
+                281855433,
+                282404443,
+                237318432,
+                258066764,
+                83688214,
+                236117470,
+                134376301,
+                125033736,
+                406824599,
+                806597217,
+                175838204,
+                448108347
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                726633986,
+                400995617,
+                693097314,
+                440474407,
+                63494536,
+                993852230,
+                881042725,
+                924564810
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                744707562,
+                793994140,
+                180416571,
+                473700883,
+                587397301,
+                367020656,
+                905392500,
+                925682568,
+                353345376,
+                696934710,
+                546914520,
+                207602398,
+                366110622,
+                970835618
+            ],
+            "output": 0
+        }
+    ],
+    "haskell_template": "specialPerm :: [Int] -> Int\nspecialPerm nums ",
+    "ocaml_template": "let specialPerm (nums: int list) : int =  ",
+    "scala_template": "def specialPerm(nums: List[Int]): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public int specialPerm(int[] nums) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def specialPerm(self, nums):\n        \"\"\"\n        :type nums: List[int]\n        :rtype: int\n        \"\"\"\n        "
+}

special_permutations/ocaml_tests/main.ml

@@ -0,0 +1,42 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+    let specialPerm (nums: int list) : int =   failwith "Not implemented"
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 2 (specialPerm [2;3;6])
+
+let test2 _ = assert_equal 2 (specialPerm [1;4;3])
+
+let test3 _ = assert_equal 2 (specialPerm [584117688; 128132521; 483733809; 538103732; 157980701; 84500114; 369758978; 417335206; 834992633])
+
+let test4 _ = assert_equal 2 (specialPerm [716189780; 829231105; 799685662; 706127727; 642091233; 653562772; 19107990; 817847028; 452438656; 309420299; 224255714; 378823621; 893604088; 555231725])
+
+let test5 _ = assert_equal 2 (specialPerm [915827588; 281855433; 282404443; 237318432; 258066764; 83688214; 236117470; 134376301; 125033736; 406824599; 806597217; 175838204; 448108347])
+
+let test6 _ = assert_equal 2 (specialPerm [726633986; 400995617; 693097314; 440474407; 63494536; 993852230; 881042725; 924564810])
+
+let test7 _ = assert_equal 2 (specialPerm [744707562; 793994140; 180416571; 473700883; 587397301; 367020656; 905392500; 925682568; 353345376; 696934710; 546914520; 207602398; 366110622; 970835618])
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for specialPerm" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+  "test3" >:: test3;
+  "test4" >:: test4;
+  "test5" >:: test5;
+  "test6" >:: test6;
+  "test7" >:: test7;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

special_permutations/scala_tests/MySuite.scala

@@ -0,0 +1,32 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.specialPerm(List(2,3,6)), 2)
+  }
+
+  test("test2") {
+    assertEquals(Main.specialPerm(List(1,4,3)), 2)
+  }
+
+  test("test3") {
+    assertEquals(Main.specialPerm(584117688,128132521,483733809,538103732,157980701,84500114,369758978,417335206,834992633), 0)
+  }
+
+  test("test4") {
+    assertEquals(Main.specialPerm(716189780,829231105,799685662,706127727,642091233,653562772,19107990,817847028,452438656,309420299,224255714,378823621,893604088,555231725), 0)
+  }
+
+  test("test5") {
+    assertEquals(Main.specialPerm(915827588,281855433,282404443,237318432,258066764,83688214,236117470,134376301,125033736,406824599,806597217,175838204,448108347), 0)
+  }
+
+  test("test6") {
+    assertEquals(Main.specialPerm(726633986,400995617,693097314,440474407,63494536,993852230,881042725,924564810), 0)
+  }
+
+  test("test7") {
+    assertEquals(Main.specialPerm(744707562,793994140,180416571,473700883,587397301,367020656,905392500,925682568,353345376,696934710,546914520,207602398,366110622,970835618), 0)
+  }
+
+}

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

split_the_array/haskell_tests/Main.hs

@@ -0,0 +1,41 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+isPossibleToSplit :: [Int] -> Bool
+isPossibleToSplit nums = undefined
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (isPossibleToSplit [1,1,2,2,3,4])," True (isPossibleToSplit [1,1,2,2,3,4]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (isPossibleToSplit [1,1,1,1])," False (isPossibleToSplit [1,1,1,1]))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (isPossibleToSplit [79, 98, 70, 52, 79, 93, 39, 1, 73, 8, 33, 89, 99, 78, 78, 42])," True (isPossibleToSplit [79, 98, 70, 52, 79, 93, 39, 1, 73, 8, 33, 89, 99, 78, 78, 42]))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (isPossibleToSplit [28, 33, 20, 86, 85, 55, 87, 90, 18, 57, 11, 11, 87, 62, 23, 74, 67, 22, 81, 31, 1, 68, 87, 26, 12, 78, 66, 88, 26, 3, 58, 99, 14, 78, 72, 6, 64, 98])," False (isPossibleToSplit [28, 33, 20, 86, 85, 55, 87, 90, 18, 57, 11, 11, 87, 62, 23, 74, 67, 22, 81, 31, 1, 68, 87, 26, 12, 78, 66, 88, 26, 3, 58, 99, 14, 78, 72, 6, 64, 98]))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (isPossibleToSplit [100, 87, 98, 2, 31, 68, 54, 5, 71, 39, 95, 53, 90, 26, 77, 13, 73, 6, 89, 55, 14, 18, 46, 9, 66, 17, 69, 89, 76, 64, 49, 90, 97, 58, 5, 5, 9, 1, 35, 76, 77, 82, 49, 8])," False (isPossibleToSplit [100, 87, 98, 2, 31, 68, 54, 5, 71, 39, 95, 53, 90, 26, 77, 13, 73, 6, 89, 55, 14, 18, 46, 9, 66, 17, 69, 89, 76, 64, 49, 90, 97, 58, 5, 5, 9, 1, 35, 76, 77, 82, 49, 8]))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (isPossibleToSplit [71, 63, 77, 63, 91, 18, 89, 39, 41, 49, 64, 58, 26, 99, 14, 40, 69, 44, 85, 58, 26, 48, 92, 45, 48, 77, 46, 27, 21, 25, 17, 10, 4, 72, 43, 43, 7, 48, 6, 79, 34, 56, 21, 1, 57, 89, 78, 48, 93, 49, 88, 65, 12, 74, 33, 9, 18, 73, 53, 43, 29, 3, 22, 58, 25, 46, 72, 86, 76, 5, 85, 11, 14, 14, 41, 97, 9, 54, 41, 53, 57, 33, 43, 44])," False (isPossibleToSplit [71, 63, 77, 63, 91, 18, 89, 39, 41, 49, 64, 58, 26, 99, 14, 40, 69, 44, 85, 58, 26, 48, 92, 45, 48, 77, 46, 27, 21, 25, 17, 10, 4, 72, 43, 43, 7, 48, 6, 79, 34, 56, 21, 1, 57, 89, 78, 48, 93, 49, 88, 65, 12, 74, 33, 9, 18, 73, 53, 43, 29, 3, 22, 58, 25, 46, 72, 86, 76, 5, 85, 11, 14, 14, 41, 97, 9, 54, 41, 53, 57, 33, 43, 44]))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (isPossibleToSplit [64, 53, 60, 80, 73, 94, 64, 27, 85, 2, 67, 46, 39, 55, 11, 75, 96, 19, 98, 40, 87, 33, 51, 66, 7, 72, 25, 13, 89, 3, 99, 15, 39, 55, 38, 96, 23, 83, 22, 22, 48, 26, 19, 33, 76, 86, 56, 32, 96, 23, 15, 100, 49, 43, 81, 38, 80, 25, 43, 39, 51, 43, 78, 45, 54, 77, 66, 75, 71, 5, 47, 18, 28, 86, 68, 78, 71, 70, 46, 12, 27, 36, 23, 76, 37, 77, 69, 56, 3, 35, 80, 40, 56, 62, 51, 44])," False (isPossibleToSplit [64, 53, 60, 80, 73, 94, 64, 27, 85, 2, 67, 46, 39, 55, 11, 75, 96, 19, 98, 40, 87, 33, 51, 66, 7, 72, 25, 13, 89, 3, 99, 15, 39, 55, 38, 96, 23, 83, 22, 22, 48, 26, 19, 33, 76, 86, 56, 32, 96, 23, 15, 100, 49, 43, 81, 38, 80, 25, 43, 39, 51, 43, 78, 45, 54, 77, 66, 75, 71, 5, 47, 18, 28, 86, 68, 78, 71, 70, 46, 12, 27, 36, 23, 76, 37, 77, 69, 56, 3, 35, 80, 40, 56, 62, 51, 44]))
+
+
+-- 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

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

split_the_array/meta.json

@@ -0,0 +1,330 @@
+{
+    "id": 3324,
+    "name": "split_the_array",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/split-the-array/",
+    "date": "2024-02-18 00:00:00",
+    "task_description": "You are given an integer array `nums` of **even** length. You have to split the array into two parts `nums1` and `nums2` such that: `nums1.length == nums2.length == nums.length / 2`. `nums1` should contain **distinct **elements. `nums2` should also contain **distinct** elements. Return `true`_ if it is possible to split the array, and _`false` _otherwise__._ **Example 1:** ``` **Input:** nums = [1,1,2,2,3,4] **Output:** true **Explanation:** One of the possible ways to split nums is nums1 = [1,2,3] and nums2 = [1,2,4]. ``` **Example 2:** ``` **Input:** nums = [1,1,1,1] **Output:** false **Explanation:** The only possible way to split nums is nums1 = [1,1] and nums2 = [1,1]. Both nums1 and nums2 do not contain distinct elements. Therefore, we return false. ``` **Constraints:** `1 <= nums.length <= 100` `nums.length % 2 == 0 ` `1 <= nums[i] <= 100`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "nums = [1,1,2,2,3,4]",
+            "output": "true "
+        },
+        {
+            "label": "Example 2",
+            "input": "nums = [1,1,1,1]",
+            "output": "false "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                79,
+                98,
+                70,
+                52,
+                79,
+                93,
+                39,
+                1,
+                73,
+                8,
+                33,
+                89,
+                99,
+                78,
+                78,
+                42
+            ],
+            "output": true
+        },
+        {
+            "input": [
+                28,
+                33,
+                20,
+                86,
+                85,
+                55,
+                87,
+                90,
+                18,
+                57,
+                11,
+                11,
+                87,
+                62,
+                23,
+                74,
+                67,
+                22,
+                81,
+                31,
+                1,
+                68,
+                87,
+                26,
+                12,
+                78,
+                66,
+                88,
+                26,
+                3,
+                58,
+                99,
+                14,
+                78,
+                72,
+                6,
+                64,
+                98
+            ],
+            "output": false
+        },
+        {
+            "input": [
+                100,
+                87,
+                98,
+                2,
+                31,
+                68,
+                54,
+                5,
+                71,
+                39,
+                95,
+                53,
+                90,
+                26,
+                77,
+                13,
+                73,
+                6,
+                89,
+                55,
+                14,
+                18,
+                46,
+                9,
+                66,
+                17,
+                69,
+                89,
+                76,
+                64,
+                49,
+                90,
+                97,
+                58,
+                5,
+                5,
+                9,
+                1,
+                35,
+                76,
+                77,
+                82,
+                49,
+                8
+            ],
+            "output": false
+        },
+        {
+            "input": [
+                71,
+                63,
+                77,
+                63,
+                91,
+                18,
+                89,
+                39,
+                41,
+                49,
+                64,
+                58,
+                26,
+                99,
+                14,
+                40,
+                69,
+                44,
+                85,
+                58,
+                26,
+                48,
+                92,
+                45,
+                48,
+                77,
+                46,
+                27,
+                21,
+                25,
+                17,
+                10,
+                4,
+                72,
+                43,
+                43,
+                7,
+                48,
+                6,
+                79,
+                34,
+                56,
+                21,
+                1,
+                57,
+                89,
+                78,
+                48,
+                93,
+                49,
+                88,
+                65,
+                12,
+                74,
+                33,
+                9,
+                18,
+                73,
+                53,
+                43,
+                29,
+                3,
+                22,
+                58,
+                25,
+                46,
+                72,
+                86,
+                76,
+                5,
+                85,
+                11,
+                14,
+                14,
+                41,
+                97,
+                9,
+                54,
+                41,
+                53,
+                57,
+                33,
+                43,
+                44
+            ],
+            "output": false
+        },
+        {
+            "input": [
+                64,
+                53,
+                60,
+                80,
+                73,
+                94,
+                64,
+                27,
+                85,
+                2,
+                67,
+                46,
+                39,
+                55,
+                11,
+                75,
+                96,
+                19,
+                98,
+                40,
+                87,
+                33,
+                51,
+                66,
+                7,
+                72,
+                25,
+                13,
+                89,
+                3,
+                99,
+                15,
+                39,
+                55,
+                38,
+                96,
+                23,
+                83,
+                22,
+                22,
+                48,
+                26,
+                19,
+                33,
+                76,
+                86,
+                56,
+                32,
+                96,
+                23,
+                15,
+                100,
+                49,
+                43,
+                81,
+                38,
+                80,
+                25,
+                43,
+                39,
+                51,
+                43,
+                78,
+                45,
+                54,
+                77,
+                66,
+                75,
+                71,
+                5,
+                47,
+                18,
+                28,
+                86,
+                68,
+                78,
+                71,
+                70,
+                46,
+                12,
+                27,
+                36,
+                23,
+                76,
+                37,
+                77,
+                69,
+                56,
+                3,
+                35,
+                80,
+                40,
+                56,
+                62,
+                51,
+                44
+            ],
+            "output": false
+        }
+    ],
+    "haskell_template": "isPossibleToSplit :: [Int] -> Bool\nisPossibleToSplit nums ",
+    "ocaml_template": "let isPossibleToSplit (nums: int list) : bool =  ",
+    "scala_template": "def isPossibleToSplit(nums: List[Int]): Boolean = { \n    \n}",
+    "java_template": "class Solution {\n    public boolean isPossibleToSplit(int[] nums) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def isPossibleToSplit(self, nums):\n        \"\"\"\n        :type nums: List[int]\n        :rtype: bool\n        \"\"\"\n        "
+}

split_the_array/ocaml_tests/main.ml

@@ -0,0 +1,42 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+    let isPossibleToSplit (nums: int list) : bool =   failwith "Not implemented"
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal true (isPossibleToSplit [1;1;2;2;3;4])
+
+let test2 _ = assert_equal false (isPossibleToSplit [1;1;1;1])
+
+let test3 _ = assert_equal false (isPossibleToSplit [79; 98; 70; 52; 79; 93; 39; 1; 73; 8; 33; 89; 99; 78; 78; 42])
+
+let test4 _ = assert_equal false (isPossibleToSplit [28; 33; 20; 86; 85; 55; 87; 90; 18; 57; 11; 11; 87; 62; 23; 74; 67; 22; 81; 31; 1; 68; 87; 26; 12; 78; 66; 88; 26; 3; 58; 99; 14; 78; 72; 6; 64; 98])
+
+let test5 _ = assert_equal false (isPossibleToSplit [100; 87; 98; 2; 31; 68; 54; 5; 71; 39; 95; 53; 90; 26; 77; 13; 73; 6; 89; 55; 14; 18; 46; 9; 66; 17; 69; 89; 76; 64; 49; 90; 97; 58; 5; 5; 9; 1; 35; 76; 77; 82; 49; 8])
+
+let test6 _ = assert_equal false (isPossibleToSplit [71; 63; 77; 63; 91; 18; 89; 39; 41; 49; 64; 58; 26; 99; 14; 40; 69; 44; 85; 58; 26; 48; 92; 45; 48; 77; 46; 27; 21; 25; 17; 10; 4; 72; 43; 43; 7; 48; 6; 79; 34; 56; 21; 1; 57; 89; 78; 48; 93; 49; 88; 65; 12; 74; 33; 9; 18; 73; 53; 43; 29; 3; 22; 58; 25; 46; 72; 86; 76; 5; 85; 11; 14; 14; 41; 97; 9; 54; 41; 53; 57; 33; 43; 44])
+
+let test7 _ = assert_equal false (isPossibleToSplit [64; 53; 60; 80; 73; 94; 64; 27; 85; 2; 67; 46; 39; 55; 11; 75; 96; 19; 98; 40; 87; 33; 51; 66; 7; 72; 25; 13; 89; 3; 99; 15; 39; 55; 38; 96; 23; 83; 22; 22; 48; 26; 19; 33; 76; 86; 56; 32; 96; 23; 15; 100; 49; 43; 81; 38; 80; 25; 43; 39; 51; 43; 78; 45; 54; 77; 66; 75; 71; 5; 47; 18; 28; 86; 68; 78; 71; 70; 46; 12; 27; 36; 23; 76; 37; 77; 69; 56; 3; 35; 80; 40; 56; 62; 51; 44])
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for isPossibleToSplit" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+  "test3" >:: test3;
+  "test4" >:: test4;
+  "test5" >:: test5;
+  "test6" >:: test6;
+  "test7" >:: test7;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

split_the_array/scala_tests/MySuite.scala

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

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

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

split_the_array_to_make_coprime_products/ocaml_tests/main.ml

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

split_the_array_to_make_coprime_products/scala_tests/MySuite.scala

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

steps_to_make_array_non_decreasing/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, totalSteps(new ArrayList<>(Arrays.asList(5,3,4,4,7,3,6,11,8,5,11))));
+}
+@Test
+public void test2() {
+    assertEquals(0, totalSteps(new ArrayList<>(Arrays.asList(4,5,7,7,13))));
+}
+
+}

steps_to_make_array_non_decreasing/meta.json

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

string_compression_iii/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("abcde", compressedString("abcde"));
+}
+@Test
+public void test2() {
+    assertEquals("aaaaaaaaaaaaaabb", compressedString("aaaaaaaaaaaaaabb"));
+}
+
+}

string_transformation/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, numberOfWays("abcd", "cdab", 2));
+}
+@Test
+public void test2() {
+    assertEquals(2, numberOfWays("ababab", "ababab", 1));
+}
+
+}

strong_password_checker_ii/haskell_tests/Main.hs

@@ -0,0 +1,44 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+strongPasswordCheckerII :: String -> Bool
+strongPasswordCheckerII password = undefined
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (strongPasswordCheckerII \"IloveLe3tcode! \")," True (strongPasswordCheckerII "IloveLe3tcode!"))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (strongPasswordCheckerII \"Me+You--IsMyDream \")," False (strongPasswordCheckerII "Me+You--IsMyDream"))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (strongPasswordCheckerII \"1aB! \")," False (strongPasswordCheckerII "1aB!"))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (strongPasswordCheckerII  \" k n U $ 3 l r n  \")," True (strongPasswordCheckerII " k n U $ 3 l r n "))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (strongPasswordCheckerII  \" 2 O W ^ k X r 1  \")," True (strongPasswordCheckerII " 2 O W ^ k X r 1 "))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (strongPasswordCheckerII  \" J & h 5 I 2 k @  \")," True (strongPasswordCheckerII " J & h 5 I 2 k @ "))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (strongPasswordCheckerII  \" W h * 2 r ) @ G  \")," True (strongPasswordCheckerII " W h * 2 r ) @ G "))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (strongPasswordCheckerII  \" W b y & f 5 K f  \")," True (strongPasswordCheckerII " W b y & f 5 K f "))
+
+
+-- 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]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

strong_password_checker_ii/java_tests/Main.java

@@ -0,0 +1,24 @@
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+import java.util.List;
+import java.util.Arrays;
+public class Main {
+    //Program start
+
+    //Program end
+
+    @Test
+public void test1() {
+    assertEquals(true, strongPasswordCheckerII("IloveLe3tcode!"));
+}
+@Test
+public void test2() {
+    assertEquals(false, strongPasswordCheckerII("Me+You--IsMyDream"));
+}
+@Test
+public void test3() {
+    assertEquals(false, strongPasswordCheckerII("1aB!"));
+}
+
+}

strong_password_checker_ii/meta.json

@@ -0,0 +1,52 @@
+{
+    "id": 2391,
+    "name": "strong_password_checker_ii",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/strong-password-checker-ii/",
+    "date": "2022-05-28 00:00:00",
+    "task_description": "A password is said to be **strong** if it satisfies all the following criteria: It has at least `8` characters. It contains at least **one lowercase** letter. It contains at least **one uppercase** letter. It contains at least **one digit**. It contains at least **one special character**. The special characters are the characters in the following string: `\"!@#$%^&*()-+\"`. It does **not** contain `2` of the same character in adjacent positions (i.e., `\"aab\"` violates this condition, but `\"aba\"` does not). Given a string `password`, return `true`_ if it is a **strong** password_. Otherwise, return `false`. **Example 1:** ``` **Input:** password = \"IloveLe3tcode!\" **Output:** true **Explanation:** The password meets all the requirements. Therefore, we return true. ``` **Example 2:** ``` **Input:** password = \"Me+You--IsMyDream\" **Output:** false **Explanation:** The password does not contain a digit and also contains 2 of the same character in adjacent positions. Therefore, we return false. ``` **Example 3:** ``` **Input:** password = \"1aB!\" **Output:** false **Explanation:** The password does not meet the length requirement. Therefore, we return false. ``` **Constraints:** `1 <= password.length <= 100` `password` consists of letters, digits, and special characters: `\"!@#$%^&*()-+\"`.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "password = \"IloveLe3tcode!\"",
+            "output": "true "
+        },
+        {
+            "label": "Example 2",
+            "input": "password = \"Me+You--IsMyDream\"",
+            "output": "false "
+        },
+        {
+            "label": "Example 3",
+            "input": "password = \"1aB!\"",
+            "output": "false "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": "knU$3lrn",
+            "output": true
+        },
+        {
+            "input": "2OW^kXr1",
+            "output": true
+        },
+        {
+            "input": "J&h5I2k@",
+            "output": true
+        },
+        {
+            "input": "Wh*2r)@G",
+            "output": true
+        },
+        {
+            "input": "Wby&f5Kf",
+            "output": true
+        }
+    ],
+    "haskell_template": "strongPasswordCheckerII :: String -> Bool\nstrongPasswordCheckerII password ",
+    "ocaml_template": "let strongPasswordCheckerII (password: string) : bool =  ",
+    "scala_template": "def strongPasswordCheckerII(password: String): Boolean = { \n    \n}",
+    "java_template": "class Solution {\n    public boolean strongPasswordCheckerII(String password) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def strongPasswordCheckerII(self, password):\n        \"\"\"\n        :type password: str\n        :rtype: bool\n        \"\"\"\n        "
+}

strong_password_checker_ii/ocaml_tests/main.ml

@@ -0,0 +1,45 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+    let strongPasswordCheckerII (password: string) : bool =   failwith "Not implemented"
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal true (strongPasswordCheckerII "IloveLe3tcode!")
+
+let test2 _ = assert_equal false (strongPasswordCheckerII "Me+You--IsMyDream")
+
+let test3 _ = assert_equal false (strongPasswordCheckerII "1aB!")
+
+let test4 _ = assert_equal false (strongPasswordCheckerII " k n U $ 3 l r n ")
+
+let test5 _ = assert_equal false (strongPasswordCheckerII " 2 O W ^ k X r 1 ")
+
+let test6 _ = assert_equal false (strongPasswordCheckerII " J & h 5 I 2 k @ ")
+
+let test7 _ = assert_equal false (strongPasswordCheckerII " W h * 2 r ) @ G ")
+
+let test8 _ = assert_equal false (strongPasswordCheckerII " W b y & f 5 K f ")
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for strongPasswordCheckerII" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+  "test3" >:: test3;
+  "test4" >:: test4;
+  "test5" >:: test5;
+  "test6" >:: test6;
+  "test7" >:: test7;
+  "test8" >:: test8;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end