98518f6232b8c97162c9e2cf01e2d99952b5e61ffddb28be94c91646ab5c88f1

.gitattributes

@@ -107,3 +107,8 @@ destroy_sequential_targets/meta.json filter=lfs diff=lfs merge=lfs -text
 difference_between_maximum_and_minimum_price_sum/haskell_tests/Main.hs filter=lfs diff=lfs merge=lfs -text
 difference_between_maximum_and_minimum_price_sum/meta.json filter=lfs diff=lfs merge=lfs -text
 difference_between_ones_and_zeros_in_row_and_column/meta.json filter=lfs diff=lfs merge=lfs -text
+distribute_elements_into_two_arrays_ii/haskell_tests/Main.hs filter=lfs diff=lfs merge=lfs -text
+distribute_elements_into_two_arrays_ii/meta.json filter=lfs diff=lfs merge=lfs -text
+divide_an_array_into_subarrays_with_minimum_cost_ii/meta.json filter=lfs diff=lfs merge=lfs -text
+divide_array_into_arrays_with_max_difference/meta.json filter=lfs diff=lfs merge=lfs -text
+divide_intervals_into_minimum_number_of_groups/meta.json filter=lfs diff=lfs merge=lfs -text

distribute_candies_among_children_ii/meta.json

@@ -0,0 +1,97 @@
+{
+    "id": 3201,
+    "name": "distribute_candies_among_children_ii",
+    "difficulty": "Medium",
+    "link": "https://leetcode.com/problems/distribute-candies-among-children-ii/",
+    "date": "2023-10-28 00:00:00",
+    "task_description": "You are given two positive integers `n` and `limit`. Return _the **total number** of ways to distribute _`n` _candies among _`3`_ children such that no child gets more than _`limit`_ candies._ **Example 1:** ``` **Input:** n = 5, limit = 2 **Output:** 3 **Explanation:** There are 3 ways to distribute 5 candies such that no child gets more than 2 candies: (1, 2, 2), (2, 1, 2) and (2, 2, 1). ``` **Example 2:** ``` **Input:** n = 3, limit = 3 **Output:** 10 **Explanation:** There are 10 ways to distribute 3 candies such that no child gets more than 3 candies: (0, 0, 3), (0, 1, 2), (0, 2, 1), (0, 3, 0), (1, 0, 2), (1, 1, 1), (1, 2, 0), (2, 0, 1), (2, 1, 0) and (3, 0, 0). ``` **Constraints:** `1 <= n <= 106` `1 <= limit <= 106`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "n = 5, limit = 2",
+            "output": "3 "
+        },
+        {
+            "label": "Example 2",
+            "input": "n = 3, limit = 3",
+            "output": "10 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                416583,
+                740667
+            ],
+            "output": 86771322820
+        },
+        {
+            "input": [
+                311342,
+                773767
+            ],
+            "output": 48467387496
+        },
+        {
+            "input": [
+                859142,
+                962517
+            ],
+            "output": 369063776796
+        },
+        {
+            "input": [
+                858966,
+                544227
+            ],
+            "output": 220321153738
+        },
+        {
+            "input": [
+                703049,
+                772005
+            ],
+            "output": 247140002775
+        },
+        {
+            "input": [
+                395236,
+                233626
+            ],
+            "output": 38929410138
+        },
+        {
+            "input": [
+                340360,
+                977359
+            ],
+            "output": 57922975341
+        },
+        {
+            "input": [
+                981290,
+                431034
+            ],
+            "output": 48613829391
+        },
+        {
+            "input": [
+                287304,
+                167006
+            ],
+            "output": 19564631512
+        },
+        {
+            "input": [
+                626517,
+                266609
+            ],
+            "output": 15018438016
+        }
+    ],
+    "haskell_template": "distributeCandies :: Int -> Int -> Int\ndistributeCandies n limit ",
+    "ocaml_template": "let distributeCandies (n: int) (limit: int) : int =  ",
+    "scala_template": "def distributeCandies(n: Int,limit: Int): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public long distributeCandies(int n, int limit) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def distributeCandies(self, n, limit):\n        \"\"\"\n        :type n: int\n        :type limit: int\n        :rtype: int\n        \"\"\"\n        "
+}

distribute_candies_among_children_ii/ocaml_tests/main.ml

@@ -0,0 +1,50 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 3 (distributeCandies 5 2)
+
+let test2 _ = assert_equal 10 (distributeCandies 3 3)
+
+let test3 _ = assert_equal 86771322820 (distributeCandies 416583 740667)
+
+let test4 _ = assert_equal 48467387496 (distributeCandies 311342 773767)
+
+let test5 _ = assert_equal 369063776796 (distributeCandies 859142 962517)
+
+let test6 _ = assert_equal 220321153738 (distributeCandies 858966 544227)
+
+let test7 _ = assert_equal 247140002775 (distributeCandies 703049 772005)
+
+let test8 _ = assert_equal 38929410138 (distributeCandies 395236 233626)
+
+let test9 _ = assert_equal 57922975341 (distributeCandies 340360 977359)
+
+let test10 _ = assert_equal 48613829391 (distributeCandies 981290 431034)
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for distributeCandies" >::: [
+        
+  "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

distribute_candies_among_children_ii/scala_tests/MySuite.scala

@@ -0,0 +1,44 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.distributeCandies(5,2), 3)
+  }
+
+  test("test2") {
+    assertEquals(Main.distributeCandies(3,3), 10)
+  }
+
+  test("test3") {
+    assertEquals(Main.distributeCandies(416583,740667), BigInt("86771322820"))
+  }
+
+  test("test4") {
+    assertEquals(Main.distributeCandies(311342,773767), BigInt("48467387496"))
+  }
+
+  test("test5") {
+    assertEquals(Main.distributeCandies(859142,962517), BigInt("369063776796"))
+  }
+
+  test("test6") {
+    assertEquals(Main.distributeCandies(858966,544227), BigInt("220321153738"))
+  }
+
+  test("test7") {
+    assertEquals(Main.distributeCandies(703049,772005), BigInt("247140002775"))
+  }
+
+  test("test8") {
+    assertEquals(Main.distributeCandies(395236,233626), BigInt("38929410138"))
+  }
+
+  test("test9") {
+    assertEquals(Main.distributeCandies(340360,977359), BigInt("57922975341"))
+  }
+
+  test("test10") {
+    assertEquals(Main.distributeCandies(981290,431034), BigInt("48613829391"))
+  }
+
+}

distribute_elements_into_two_arrays_i/haskell_tests/Main.hs

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

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

distribute_elements_into_two_arrays_i/meta.json

@@ -0,0 +1,361 @@
+{
+    "id": 3347,
+    "name": "distribute_elements_into_two_arrays_i",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/distribute-elements-into-two-arrays-i/",
+    "date": "2024-02-25 00:00:00",
+    "task_description": "You are given a **1-indexed** array of **distinct** integers `nums` of length `n`. You need to distribute all the elements of `nums` between two arrays `arr1` and `arr2` using `n` operations. In the first operation, append `nums[1]` to `arr1`. In the second operation, append `nums[2]` to `arr2`. Afterwards, in the `ith` operation: If the last element of `arr1` is** greater** than the last element of `arr2`, append `nums[i]` to `arr1`. Otherwise, append `nums[i]` to `arr2`. The array `result` is formed by concatenating the arrays `arr1` and `arr2`. For example, if `arr1 == [1,2,3]` and `arr2 == [4,5,6]`, then `result = [1,2,3,4,5,6]`. Return _the array_ `result`. **Example 1:** ``` **Input:** nums = [2,1,3] **Output:** [2,3,1] **Explanation:** After the first 2 operations, arr1 = [2] and arr2 = [1]. In the 3rd operation, as the last element of arr1 is greater than the last element of arr2 (2 > 1), append nums[3] to arr1. After 3 operations, arr1 = [2,3] and arr2 = [1]. Hence, the array result formed by concatenation is [2,3,1]. ``` **Example 2:** ``` **Input:** nums = [5,4,3,8] **Output:** [5,3,4,8] **Explanation:** After the first 2 operations, arr1 = [5] and arr2 = [4]. In the 3rd operation, as the last element of arr1 is greater than the last element of arr2 (5 > 4), append nums[3] to arr1, hence arr1 becomes [5,3]. In the 4th operation, as the last element of arr2 is greater than the last element of arr1 (4 > 3), append nums[4] to arr2, hence arr2 becomes [4,8]. After 4 operations, arr1 = [5,3] and arr2 = [4,8]. Hence, the array result formed by concatenation is [5,3,4,8]. ``` **Constraints:** `3 <= n <= 50` `1 <= nums[i] <= 100` All elements in `nums` are distinct.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "nums = [2,1,3]",
+            "output": "[2,3,1] "
+        },
+        {
+            "label": "Example 2",
+            "input": "nums = [5,4,3,8]",
+            "output": "[5,3,4,8] "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                5,
+                6,
+                13,
+                73,
+                52,
+                17,
+                66,
+                58,
+                80,
+                14,
+                41,
+                57,
+                99,
+                98,
+                30,
+                32,
+                23,
+                55,
+                59,
+                91,
+                76,
+                34,
+                83,
+                81,
+                77,
+                20,
+                33,
+                24,
+                22,
+                85,
+                21,
+                35,
+                40,
+                88
+            ],
+            "output": [
+                5,
+                6,
+                13,
+                73,
+                52,
+                17,
+                66,
+                58,
+                80,
+                14,
+                41,
+                57,
+                99,
+                98,
+                30,
+                32,
+                23,
+                55,
+                59,
+                91,
+                76,
+                34,
+                83,
+                81,
+                77,
+                20,
+                33,
+                24,
+                22,
+                85,
+                21,
+                35,
+                40,
+                88
+            ]
+        },
+        {
+            "input": [
+                35,
+                42,
+                84,
+                82,
+                9,
+                79,
+                31,
+                94,
+                18,
+                19,
+                59,
+                76,
+                22,
+                41,
+                78,
+                12,
+                16,
+                64,
+                1,
+                73,
+                29,
+                91,
+                2,
+                93,
+                23,
+                92,
+                67,
+                83,
+                50,
+                71,
+                27,
+                74,
+                44,
+                60,
+                38,
+                7,
+                54,
+                55,
+                10
+            ],
+            "output": [
+                35,
+                79,
+                31,
+                94,
+                18,
+                19,
+                59,
+                76,
+                22,
+                41,
+                78,
+                12,
+                16,
+                64,
+                1,
+                42,
+                84,
+                82,
+                9,
+                73,
+                29,
+                91,
+                2,
+                93,
+                23,
+                92,
+                67,
+                83,
+                50,
+                71,
+                27,
+                74,
+                44,
+                60,
+                38,
+                7,
+                54,
+                55,
+                10
+            ]
+        },
+        {
+            "input": [
+                7,
+                57,
+                4,
+                94,
+                60,
+                80,
+                77,
+                100,
+                19,
+                13,
+                99,
+                90,
+                89,
+                68,
+                21,
+                31,
+                45,
+                41,
+                95,
+                12,
+                66,
+                17,
+                11,
+                85,
+                76,
+                63,
+                50
+            ],
+            "output": [
+                7,
+                94,
+                60,
+                80,
+                77,
+                100,
+                19,
+                13,
+                99,
+                90,
+                89,
+                68,
+                21,
+                31,
+                45,
+                41,
+                95,
+                12,
+                66,
+                17,
+                11,
+                85,
+                76,
+                63,
+                50,
+                57,
+                4
+            ]
+        },
+        {
+            "input": [
+                51,
+                60,
+                82,
+                66,
+                86,
+                8,
+                59,
+                77,
+                44,
+                3,
+                22,
+                12,
+                40,
+                52,
+                28,
+                32,
+                24,
+                33,
+                50,
+                20,
+                90,
+                43,
+                27,
+                14,
+                17,
+                78,
+                1,
+                67,
+                64,
+                2,
+                74,
+                81,
+                97,
+                96,
+                84,
+                35,
+                65,
+                88,
+                56
+            ],
+            "output": [
+                51,
+                59,
+                77,
+                44,
+                3,
+                67,
+                64,
+                2,
+                74,
+                81,
+                97,
+                96,
+                84,
+                35,
+                65,
+                88,
+                56,
+                60,
+                82,
+                66,
+                86,
+                8,
+                22,
+                12,
+                40,
+                52,
+                28,
+                32,
+                24,
+                33,
+                50,
+                20,
+                90,
+                43,
+                27,
+                14,
+                17,
+                78,
+                1
+            ]
+        },
+        {
+            "input": [
+                84,
+                27,
+                72,
+                1,
+                62,
+                76,
+                18,
+                24,
+                94,
+                59,
+                63,
+                25,
+                31
+            ],
+            "output": [
+                84,
+                72,
+                1,
+                27,
+                62,
+                76,
+                18,
+                24,
+                94,
+                59,
+                63,
+                25,
+                31
+            ]
+        }
+    ],
+    "haskell_template": "resultArray :: [Int] -> [Int]\nresultArray nums ",
+    "ocaml_template": "let resultArray (nums: int list) : int list =  ",
+    "scala_template": "def resultArray(nums: List[Int]): List[Int] = { \n    \n}",
+    "java_template": "class Solution {\n    public int[] resultArray(int[] nums) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def resultArray(self, nums):\n        \"\"\"\n        :type nums: List[int]\n        :rtype: List[int]\n        \"\"\"\n        "
+}

distribute_elements_into_two_arrays_i/ocaml_tests/main.ml

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

distribute_elements_into_two_arrays_i/scala_tests/MySuite.scala

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

distribute_elements_into_two_arrays_ii/haskell_tests/Main.hs

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

distribute_elements_into_two_arrays_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(Arrays.asList(2,3,1,3), resultArray(Arrays.asList(2,1,3,3)));
+}
+@Test
+public void test2() {
+    assertEquals(Arrays.asList(5,3,1,2,14), resultArray(Arrays.asList(5,14,3,1,2)));
+}
+@Test
+public void test3() {
+    assertEquals(Arrays.asList(3,3,3,3), resultArray(Arrays.asList(3,3,3,3)));
+}
+
+}

distribute_elements_into_two_arrays_ii/meta.json

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

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

distribute_money_to_maximum_children/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(1, distMoney(20, 3));
+}
+@Test
+public void test2() {
+    assertEquals(2, distMoney(16, 2));
+}
+
+}

distribute_money_to_maximum_children/meta.json

@@ -0,0 +1,97 @@
+{
+    "id": 2663,
+    "name": "distribute_money_to_maximum_children",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/distribute-money-to-maximum-children/",
+    "date": "1677888000000",
+    "task_description": "You are given an integer `money` denoting the amount of money (in dollars) that you have and another integer `children` denoting the number of children that you must distribute the money to. You have to distribute the money according to the following rules: All money must be distributed. Everyone must receive at least `1` dollar. Nobody receives `4` dollars. Return _the **maximum** number of children who may receive **exactly** _`8` _dollars if you distribute the money according to the aforementioned rules_. If there is no way to distribute the money, return `-1`. **Example 1:** ``` **Input:** money = 20, children = 3 **Output:** 1 **Explanation:** The maximum number of children with 8 dollars will be 1. One of the ways to distribute the money is: - 8 dollars to the first child. - 9 dollars to the second child. - 3 dollars to the third child. It can be proven that no distribution exists such that number of children getting 8 dollars is greater than 1. ``` **Example 2:** ``` **Input:** money = 16, children = 2 **Output:** 2 **Explanation:** Each child can be given 8 dollars. ``` **Constraints:** `1 <= money <= 200` `2 <= children <= 30`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "money = 20, children = 3",
+            "output": "1 "
+        },
+        {
+            "label": "Example 2",
+            "input": "money = 16, children = 2",
+            "output": "2 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                161,
+                4
+            ],
+            "output": 3
+        },
+        {
+            "input": [
+                181,
+                2
+            ],
+            "output": 1
+        },
+        {
+            "input": [
+                83,
+                6
+            ],
+            "output": 5
+        },
+        {
+            "input": [
+                134,
+                26
+            ],
+            "output": 15
+        },
+        {
+            "input": [
+                189,
+                25
+            ],
+            "output": 23
+        },
+        {
+            "input": [
+                95,
+                29
+            ],
+            "output": 9
+        },
+        {
+            "input": [
+                145,
+                6
+            ],
+            "output": 5
+        },
+        {
+            "input": [
+                161,
+                14
+            ],
+            "output": 13
+        },
+        {
+            "input": [
+                35,
+                13
+            ],
+            "output": 3
+        },
+        {
+            "input": [
+                135,
+                22
+            ],
+            "output": 16
+        }
+    ],
+    "haskell_template": "distMoney :: Int -> Int -> Int\ndistMoney money children ",
+    "ocaml_template": "let distMoney (money: int) (children: int) : int =  ",
+    "scala_template": "def distMoney(money: Int,children: Int): Int = { \n    \n}",
+    "java_template": "public static int distMoney(int money, int children) {\n\n}",
+    "python_template": "class Solution(object):\n    def distMoney(self, money, children):\n        \"\"\"\n        :type money: int\n        :type children: int\n        :rtype: int\n        \"\"\"\n        "
+}

distribute_money_to_maximum_children/ocaml_tests/main.ml

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

distribute_money_to_maximum_children/scala_tests/MySuite.scala

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

divide_a_string_into_groups_of_size_k/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 (divideString \"abcdefghi \" 3  \"x \")," ["abc","def","ghi"] (divideString "abcdefghi" 3 "x"))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (divideString \"abcdefghij \" 3  \"x \")," ["abc","def","ghi","jxx"] (divideString "abcdefghij" 3 "x"))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

divide_a_string_into_groups_of_size_k/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("abc","def","ghi")), divideString("abcdefghi", 3, "x"));
+}
+@Test
+public void test2() {
+    assertEquals(new ArrayList<>(Arrays.asList("abc","def","ghi","jxx")), divideString("abcdefghij", 3, "x"));
+}
+
+}

divide_a_string_into_groups_of_size_k/meta.json

@@ -0,0 +1,133 @@
+{
+    "id": 2260,
+    "name": "divide_a_string_into_groups_of_size_k",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/divide-a-string-into-groups-of-size-k/",
+    "date": "1641686400000",
+    "task_description": "A string `s` can be partitioned into groups of size `k` using the following procedure: The first group consists of the first `k` characters of the string, the second group consists of the next `k` characters of the string, and so on. Each element can be a part of **exactly one** group. For the last group, if the string **does not** have `k` characters remaining, a character `fill` is used to complete the group. Note that the partition is done so that after removing the `fill` character from the last group (if it exists) and concatenating all the groups in order, the resultant string should be `s`. Given the string `s`, the size of each group `k` and the character `fill`, return _a string array denoting the **composition of every group** _`s`_ has been divided into, using the above procedure_. **Example 1:** ``` **Input:** s = \"abcdefghi\", k = 3, fill = \"x\" **Output:** [\"abc\",\"def\",\"ghi\"] **Explanation:** The first 3 characters \"abc\" form the first group. The next 3 characters \"def\" form the second group. The last 3 characters \"ghi\" form the third group. Since all groups can be completely filled by characters from the string, we do not need to use fill. Thus, the groups formed are \"abc\", \"def\", and \"ghi\". ``` **Example 2:** ``` **Input:** s = \"abcdefghij\", k = 3, fill = \"x\" **Output:** [\"abc\",\"def\",\"ghi\",\"jxx\"] **Explanation:** Similar to the previous example, we are forming the first three groups \"abc\", \"def\", and \"ghi\". For the last group, we can only use the character 'j' from the string. To complete this group, we add 'x' twice. Thus, the 4 groups formed are \"abc\", \"def\", \"ghi\", and \"jxx\". ``` **Constraints:** `1 <= s.length <= 100` `s` consists of lowercase English letters only. `1 <= k <= 100` `fill` is a lowercase English letter.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "s = \"abcdefghi\", k = 3, fill = \"x\"",
+            "output": "[\"abc\",\"def\",\"ghi\"] "
+        },
+        {
+            "label": "Example 2",
+            "input": "s = \"abcdefghij\", k = 3, fill = \"x\"",
+            "output": "[\"abc\",\"def\",\"ghi\",\"jxx\"] "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                "\"fkgqjigbdgsxuotdyypqjvtetzctaroenbifhdazlskbmgvbmysvrikfjfcenmtycilvy\"",
+                16,
+                "\"i\""
+            ],
+            "output": [
+                "fkgqjigbdgsxuotd",
+                "yypqjvtetzctaroe",
+                "nbifhdazlskbmgvb",
+                "mysvrikfjfcenmty",
+                "cilvyiiiiiiiiiii"
+            ]
+        },
+        {
+            "input": [
+                "\"bddueajpkunbhnqbfguoywrfhvxnigmr\"",
+                36,
+                "\"i\""
+            ],
+            "output": [
+                "bddueajpkunbhnqbfguoywrfhvxnigmriiii"
+            ]
+        },
+        {
+            "input": [
+                "\"mwylwwhnkvakdjcnefbdugvdnhvm\"",
+                43,
+                "\"e\""
+            ],
+            "output": [
+                "mwylwwhnkvakdjcnefbdugvdnhvmeeeeeeeeeeeeeee"
+            ]
+        },
+        {
+            "input": [
+                "\"indjae\"",
+                66,
+                "\"z\""
+            ],
+            "output": [
+                "indjaezzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz"
+            ]
+        },
+        {
+            "input": [
+                "\"pwlwkkpahjrnsicbuzfvqojzfjugyhatmlfedfltxyiiegevqgusagrhxpbpcvceutxcowatrwmnmcrxbvgqptditpqmvye\"",
+                48,
+                "\"a\""
+            ],
+            "output": [
+                "pwlwkkpahjrnsicbuzfvqojzfjugyhatmlfedfltxyiiegev",
+                "qgusagrhxpbpcvceutxcowatrwmnmcrxbvgqptditpqmvyea"
+            ]
+        },
+        {
+            "input": [
+                "\"putzcpowmxhaxfewximch\"",
+                94,
+                "\"w\""
+            ],
+            "output": [
+                "putzcpowmxhaxfewximchwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww"
+            ]
+        },
+        {
+            "input": [
+                "\"yrjkthlycdnnknaysjksdcdzzuqidqeqm\"",
+                100,
+                "\"g\""
+            ],
+            "output": [
+                "yrjkthlycdnnknaysjksdcdzzuqidqeqmggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg"
+            ]
+        },
+        {
+            "input": [
+                "zbxigcaqprjaffizikgyugjqaikgidkqoijfbachctdrdxq",
+                43,
+                "o"
+            ],
+            "output": [
+                "zbxigcaqprjaffizikgyugjqaikgidkqoijfbachctd",
+                "rdxqooooooooooooooooooooooooooooooooooooooo"
+            ]
+        },
+        {
+            "input": [
+                "trvaizmlfnranrshpfnvj",
+                35,
+                "r"
+            ],
+            "output": [
+                "trvaizmlfnranrshpfnvjrrrrrrrrrrrrrr"
+            ]
+        },
+        {
+            "input": [
+                "mkrnoghwppgbtnuarxtjxvxlblqnbdujdzgefbftktcukkb",
+                55,
+                "p"
+            ],
+            "output": [
+                "mkrnoghwppgbtnuarxtjxvxlblqnbdujdzgefbftktcukkbpppppppp"
+            ]
+        }
+    ],
+    "haskell_template": "divideString :: String -> Int -> String -> [String]\ndivideString s k fill ",
+    "ocaml_template": "let divideString (s: string) (k: int) (fill: string) : string list =  ",
+    "scala_template": "def divideString(s: String,k: Int,fill: String): List[String] = { \n    \n}",
+    "java_template": "public static List<String> divideString(String s, int k, String fill) {\n\n}",
+    "python_template": "class Solution(object):\n    def divideString(self, s, k, fill):\n        \"\"\"\n        :type s: str\n        :type k: int\n        :type fill: str\n        :rtype: List[str]\n        \"\"\"\n        "
+}

divide_a_string_into_groups_of_size_k/ocaml_tests/main.ml

@@ -0,0 +1,26 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal ["abc";"def";"ghi"] (divideString "abcdefghi" 3 "x")
+
+let test2 _ = assert_equal ["abc";"def";"ghi";"jxx"] (divideString "abcdefghij" 3 "x")
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for divideString" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

divide_a_string_into_groups_of_size_k/scala_tests/MySuite.scala

@@ -0,0 +1,12 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.divideString("abcdefghi",3,"x"), List("abc","def","ghi"))
+  }
+
+  test("test2") {
+    assertEquals(Main.divideString("abcdefghij",3,"x"), List("abc","def","ghi","jxx"))
+  }
+
+}

divide_an_array_into_subarrays_with_minimum_cost_i/haskell_tests/Main.hs

@@ -0,0 +1,44 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+minimumCost :: [Int] -> Int
+minimumCost nums = undefined
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (minimumCost [1,2,3,12])," 6 (minimumCost [1,2,3,12]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (minimumCost [5,4,3])," 12 (minimumCost [5,4,3]))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (minimumCost [10,3,1,1])," 12 (minimumCost [10,3,1,1]))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (minimumCost [34, 1, 2, 5, 15, 18, 22, 32, 49])," 37 (minimumCost [34, 1, 2, 5, 15, 18, 22, 32, 49]))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (minimumCost [4, 4, 5, 7, 7, 23, 29, 12, 17, 24, 20, 15, 24, 25, 20, 31, 23, 16, 18, 22, 27, 17, 16, 11, 18, 8, 19, 32, 35, 36, 48, 42, 46, 49, 37, 44, 47, 37, 45, 50, 35, 33, 34, 41, 46, 48, 49])," 13 (minimumCost [4, 4, 5, 7, 7, 23, 29, 12, 17, 24, 20, 15, 24, 25, 20, 31, 23, 16, 18, 22, 27, 17, 16, 11, 18, 8, 19, 32, 35, 36, 48, 42, 46, 49, 37, 44, 47, 37, 45, 50, 35, 33, 34, 41, 46, 48, 49]))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (minimumCost [48, 1, 4, 8, 8, 12, 15, 16, 17, 17, 17, 18, 20, 22, 25, 22, 27, 26, 30, 30, 39, 46, 34, 31, 42, 44])," 53 (minimumCost [48, 1, 4, 8, 8, 12, 15, 16, 17, 17, 17, 18, 20, 22, 25, 22, 27, 26, 30, 30, 39, 46, 34, 31, 42, 44]))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (minimumCost [50, 5, 5, 9, 28, 12, 18, 13, 29, 33, 35, 35, 38, 38, 49, 50, 40, 47])," 60 (minimumCost [50, 5, 5, 9, 28, 12, 18, 13, 29, 33, 35, 35, 38, 38, 49, 50, 40, 47]))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (minimumCost [29, 1, 4, 5, 5, 40, 41, 20, 25, 7, 32, 35, 38, 32, 47, 34, 22, 47, 43, 43, 10, 21, 20, 29])," 34 (minimumCost [29, 1, 4, 5, 5, 40, 41, 20, 25, 7, 32, 35, 38, 32, 47, 34, 22, 47, 43, 43, 10, 21, 20, 29]))
+
+
+-- 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

divide_an_array_into_subarrays_with_minimum_cost_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(6, minimumCost(Arrays.asList(1,2,3,12)));
+}
+@Test
+public void test2() {
+    assertEquals(12, minimumCost(Arrays.asList(5,4,3)));
+}
+@Test
+public void test3() {
+    assertEquals(12, minimumCost(Arrays.asList(10,3,1,1)));
+}
+
+}

divide_an_array_into_subarrays_with_minimum_cost_i/meta.json

@@ -0,0 +1,181 @@
+{
+    "id": 3263,
+    "name": "divide_an_array_into_subarrays_with_minimum_cost_i",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/divide-an-array-into-subarrays-with-minimum-cost-i/",
+    "date": "2024-01-06 00:00:00",
+    "task_description": "You are given an array of integers `nums` of length `n`. The **cost** of an array is the value of its **first** element. For example, the cost of `[1,2,3]` is `1` while the cost of `[3,4,1]` is `3`. You need to divide `nums` into `3` **disjoint contiguous **subarrays. Return _the **minimum** possible **sum** of the cost of these subarrays_. **Example 1:** ``` **Input:** nums = [1,2,3,12] **Output:** 6 **Explanation:** The best possible way to form 3 subarrays is: [1], [2], and [3,12] at a total cost of 1 + 2 + 3 = 6. The other possible ways to form 3 subarrays are: - [1], [2,3], and [12] at a total cost of 1 + 2 + 12 = 15. - [1,2], [3], and [12] at a total cost of 1 + 3 + 12 = 16. ``` **Example 2:** ``` **Input:** nums = [5,4,3] **Output:** 12 **Explanation:** The best possible way to form 3 subarrays is: [5], [4], and [3] at a total cost of 5 + 4 + 3 = 12. It can be shown that 12 is the minimum cost achievable. ``` **Example 3:** ``` **Input:** nums = [10,3,1,1] **Output:** 12 **Explanation:** The best possible way to form 3 subarrays is: [10,3], [1], and [1] at a total cost of 10 + 1 + 1 = 12. It can be shown that 12 is the minimum cost achievable. ``` **Constraints:** `3 <= n <= 50` `1 <= nums[i] <= 50`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "nums = [1,2,3,12]",
+            "output": "6 "
+        },
+        {
+            "label": "Example 2",
+            "input": "nums = [5,4,3]",
+            "output": "12 "
+        },
+        {
+            "label": "Example 3",
+            "input": "nums = [10,3,1,1]",
+            "output": "12 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                34,
+                1,
+                2,
+                5,
+                15,
+                18,
+                22,
+                32,
+                49
+            ],
+            "output": 37
+        },
+        {
+            "input": [
+                4,
+                4,
+                5,
+                7,
+                7,
+                23,
+                29,
+                12,
+                17,
+                24,
+                20,
+                15,
+                24,
+                25,
+                20,
+                31,
+                23,
+                16,
+                18,
+                22,
+                27,
+                17,
+                16,
+                11,
+                18,
+                8,
+                19,
+                32,
+                35,
+                36,
+                48,
+                42,
+                46,
+                49,
+                37,
+                44,
+                47,
+                37,
+                45,
+                50,
+                35,
+                33,
+                34,
+                41,
+                46,
+                48,
+                49
+            ],
+            "output": 13
+        },
+        {
+            "input": [
+                48,
+                1,
+                4,
+                8,
+                8,
+                12,
+                15,
+                16,
+                17,
+                17,
+                17,
+                18,
+                20,
+                22,
+                25,
+                22,
+                27,
+                26,
+                30,
+                30,
+                39,
+                46,
+                34,
+                31,
+                42,
+                44
+            ],
+            "output": 53
+        },
+        {
+            "input": [
+                50,
+                5,
+                5,
+                9,
+                28,
+                12,
+                18,
+                13,
+                29,
+                33,
+                35,
+                35,
+                38,
+                38,
+                49,
+                50,
+                40,
+                47
+            ],
+            "output": 60
+        },
+        {
+            "input": [
+                29,
+                1,
+                4,
+                5,
+                5,
+                40,
+                41,
+                20,
+                25,
+                7,
+                32,
+                35,
+                38,
+                32,
+                47,
+                34,
+                22,
+                47,
+                43,
+                43,
+                10,
+                21,
+                20,
+                29
+            ],
+            "output": 34
+        }
+    ],
+    "haskell_template": "minimumCost :: [Int] -> Int\nminimumCost nums ",
+    "ocaml_template": "let minimumCost (nums: int list) : int =  ",
+    "scala_template": "def minimumCost(nums: List[Int]): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public int minimumCost(int[] nums) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def minimumCost(self, nums):\n        \"\"\"\n        :type nums: List[int]\n        :rtype: int\n        \"\"\"\n        "
+}

divide_an_array_into_subarrays_with_minimum_cost_i/ocaml_tests/main.ml

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

divide_an_array_into_subarrays_with_minimum_cost_i/scala_tests/MySuite.scala

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

divide_an_array_into_subarrays_with_minimum_cost_ii/java_tests/Main.java

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

divide_an_array_into_subarrays_with_minimum_cost_ii/meta.json

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

divide_array_into_arrays_with_max_difference/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(new ArrayList<>(Arrays.asList(new ArrayList<>(Arrays.asList(1,1,3)),new ArrayList<>(Arrays.asList(3,4,5)),new ArrayList<>(Arrays.asList(7,8,9)))), divideArray(new ArrayList<>(Arrays.asList(1,3,4,8,7,9,3,5,1)), 2));
+}
+@Test
+public void test2() {
+    assertEquals(new ArrayList<>(), divideArray(new ArrayList<>(Arrays.asList(2,4,2,2,5,2)), 2));
+}
+@Test
+public void test3() {
+    assertEquals(new ArrayList<>(Arrays.asList(new ArrayList<>(Arrays.asList(2,2,12)),new ArrayList<>(Arrays.asList(4,8,5)),new ArrayList<>(Arrays.asList(5,9,7)),new ArrayList<>(Arrays.asList(7,8,5)),new ArrayList<>(Arrays.asList(5,9,10)),new ArrayList<>(Arrays.asList(11,12,2)))), divideArray(new ArrayList<>(Arrays.asList(4,2,9,8,2,12,7,12,10,5,8,5,5,7,9,2,5,11)), 14));
+}
+
+}

divide_array_into_arrays_with_max_difference/meta.json

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

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

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

divide_array_into_equal_pairs/ocaml_tests/main.ml

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

divide_array_into_equal_pairs/scala_tests/MySuite.scala

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

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

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