e772cc7a8a95bda60bf7cb1bb77defcf817c3f9d50800e835dc9b9b3aacafce0

.gitattributes

@@ -275,3 +275,6 @@ replace_non_coprime_numbers_in_array/meta.json filter=lfs diff=lfs merge=lfs -te
 robot_collisions/meta.json filter=lfs diff=lfs merge=lfs -text
 shifting_letters_ii/meta.json filter=lfs diff=lfs merge=lfs -text
 shortest_impossible_sequence_of_rolls/meta.json filter=lfs diff=lfs merge=lfs -text
+shortest_subarray_with_or_at_least_k_ii/meta.json filter=lfs diff=lfs merge=lfs -text
+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

shortest_string_that_contains_three_strings/meta.json

@@ -0,0 +1,107 @@
+{
+    "id": 2877,
+    "name": "shortest_string_that_contains_three_strings",
+    "difficulty": "Medium",
+    "link": "https://leetcode.com/problems/shortest-string-that-contains-three-strings/",
+    "date": "1690070400000",
+    "task_description": "Given three strings `a`, `b`, and `c`, your task is to find a string that has the** minimum** length and contains all three strings as **substrings**. If there are multiple such strings, return the_ _**lexicographically_ _smallest **one. Return _a string denoting the answer to the problem._ **Notes** A string `a` is **lexicographically smaller** than a string `b` (of the same length) if in the first position where `a` and `b` differ, string `a` has a letter that appears **earlier **in the alphabet than the corresponding letter in `b`. A **substring** is a contiguous sequence of characters within a string. **Example 1:** ``` **Input:** a = \"abc\", b = \"bca\", c = \"aaa\" **Output:** \"aaabca\" **Explanation:** We show that \"aaabca\" contains all the given strings: a = ans[2...4], b = ans[3..5], c = ans[0..2]. It can be shown that the length of the resulting string would be at least 6 and \"aaabca\" is the lexicographically smallest one. ``` **Example 2:** ``` **Input:** a = \"ab\", b = \"ba\", c = \"aba\" **Output:** \"aba\" **Explanation: **We show that the string \"aba\" contains all the given strings: a = ans[0..1], b = ans[1..2], c = ans[0..2]. Since the length of c is 3, the length of the resulting string would be at least 3. It can be shown that \"aba\" is the lexicographically smallest one. ``` **Constraints:** `1 <= a.length, b.length, c.length <= 100` `a`, `b`, `c` consist only of lowercase English letters.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "a = \"abc\", b = \"bca\", c = \"aaa\"",
+            "output": "\"aaabca\" "
+        },
+        {
+            "label": "Example 2",
+            "input": "a = \"ab\", b = \"ba\", c = \"aba\"",
+            "output": "\"aba\" "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                "\"wrgzetkwycvrgbirwclrwsblkfecsertsvaqgbrwpfprbwzbocsgodxwllwdrknyxitc\"",
+                "\"welaunojcdczlkxwsvcnqdrkaetpnjzfynwflvzgtmxmvgjrfpv\"",
+                "\"donsfsswccihyitepvoegeqpuugpomgvxidpvrjgtamybibwdgnynixcgvoorvqzxsivn\""
+            ],
+            "output": "donsfsswccihyitepvoegeqpuugpomgvxidpvrjgtamybibwdgnynixcgvoorvqzxsivnwelaunojcdczlkxwsvcnqdrkaetpnjzfynwflvzgtmxmvgjrfpvwrgzetkwycvrgbirwclrwsblkfecsertsvaqgbrwpfprbwzbocsgodxwllwdrknyxitc"
+        },
+        {
+            "input": [
+                "\"asigvexrzpfmorvvvnscwqnpniqezvxiv\"",
+                "\"tfqajcelaqupacpizucsjqfxxi\"",
+                "\"ssrbvodscludzisopjkmygcgpynvwnzrsasgxrmukqgofpswxahqljtiee\""
+            ],
+            "output": "asigvexrzpfmorvvvnscwqnpniqezvxivssrbvodscludzisopjkmygcgpynvwnzrsasgxrmukqgofpswxahqljtieetfqajcelaqupacpizucsjqfxxi"
+        },
+        {
+            "input": [
+                "\"xuavyormuebkvvoubjhaupmqvhdwwkmnrycauhrxsnqvtroiwvwevqgdqao\"",
+                "\"hldznvfqomsmncuaigxonrywewxfhlxhlctekjdgdymhoqabqgcalqwgeyitgyoxsdasddvntg\"",
+                "\"qvhqhuvovfxosgzkolzftbhmqbzjvnjwxbbduiqawwvwjrzscudvbzzpooiyubpcfmakcdajgqmpkjmryimhsiuenlaebux\""
+            ],
+            "output": "hldznvfqomsmncuaigxonrywewxfhlxhlctekjdgdymhoqabqgcalqwgeyitgyoxsdasddvntgqvhqhuvovfxosgzkolzftbhmqbzjvnjwxbbduiqawwvwjrzscudvbzzpooiyubpcfmakcdajgqmpkjmryimhsiuenlaebuxuavyormuebkvvoubjhaupmqvhdwwkmnrycauhrxsnqvtroiwvwevqgdqao"
+        },
+        {
+            "input": [
+                "\"chawduquqsxdvkazntomogvtnwaye\"",
+                "\"vpydaguxlrmdrnifusdxvuqtlgovvukxzvpkkltrcrsygaubqxqadahxizbmhsobvqorhsxgfuyong\"",
+                "\"epnvrgokwfpqzfjeewjrfoedkcbnpohpwzjoyzyxthspbsqkiemgcvhpdwgulkwcvjgsdwwgtzujnebillgxwrqticxzrjeqdy\""
+            ],
+            "output": "chawduquqsxdvkazntomogvtnwayepnvrgokwfpqzfjeewjrfoedkcbnpohpwzjoyzyxthspbsqkiemgcvhpdwgulkwcvjgsdwwgtzujnebillgxwrqticxzrjeqdyvpydaguxlrmdrnifusdxvuqtlgovvukxzvpkkltrcrsygaubqxqadahxizbmhsobvqorhsxgfuyong"
+        },
+        {
+            "input": [
+                "\"mvzsexjyjlpdnijvmooi\"",
+                "\"qwalgakythuyisqnohqaecwjmkzfexoxkbanfochftvebyoswpsptegvwfyeevjmrfgt\"",
+                "\"tutpewbuzyuuqmxpfrqnwrhunvwptjvmvcrqbbhapeycevowctorbipzivgzvcg\""
+            ],
+            "output": "mvzsexjyjlpdnijvmooiqwalgakythuyisqnohqaecwjmkzfexoxkbanfochftvebyoswpsptegvwfyeevjmrfgtutpewbuzyuuqmxpfrqnwrhunvwptjvmvcrqbbhapeycevowctorbipzivgzvcg"
+        },
+        {
+            "input": [
+                "\"vtzfav\"",
+                "\"rmyuzojrsmarrperkdnboojzmzwuunbfkhuypwhpouxsrtbpdy\"",
+                "\"xzeqjrphbdfgwdctrbzmggxshcteroifystaecbkqozdpfcjivawqqknokfueljqwrpsujtwjiqefj\""
+            ],
+            "output": "rmyuzojrsmarrperkdnboojzmzwuunbfkhuypwhpouxsrtbpdyvtzfavxzeqjrphbdfgwdctrbzmggxshcteroifystaecbkqozdpfcjivawqqknokfueljqwrpsujtwjiqefj"
+        },
+        {
+            "input": [
+                "\"lwxsqaxhnspgnmiyhchuyutervllkafqlpwhkfheqshbslcqxtlnnsbgfvslmybcxpogbwrrgwaufscnobbaqtyrjzyhfonrzwyj\"",
+                "\"qelfibnsshwxrezdrvcyokwbbmiejorrghbvxgvtbhlmglgmxxdomdbhiaolpcwrmrwhsjhrdxvsylugpy\"",
+                "\"sdzjnhkgtumlhnpdpwnpnajwwgqpdknxihjprfztlalpaktu\""
+            ],
+            "output": "lwxsqaxhnspgnmiyhchuyutervllkafqlpwhkfheqshbslcqxtlnnsbgfvslmybcxpogbwrrgwaufscnobbaqtyrjzyhfonrzwyjqelfibnsshwxrezdrvcyokwbbmiejorrghbvxgvtbhlmglgmxxdomdbhiaolpcwrmrwhsjhrdxvsylugpysdzjnhkgtumlhnpdpwnpnajwwgqpdknxihjprfztlalpaktu"
+        },
+        {
+            "input": [
+                "jetiayntmsvinhnausvipvm",
+                "uodgvemykvyxrnwnuqffyrnezfvnlopnvmpdasoddjwievdtzjgoaroylmdmbfkncuvhqfckgknbeyyrbavfwyzeodqsg",
+                "pitawhxiwobktcxzvaokqejexhcvptrpowgkizcrbufvtozijkknfyreffmftomnssm"
+            ],
+            "output": "jetiayntmsvinhnausvipvmpitawhxiwobktcxzvaokqejexhcvptrpowgkizcrbufvtozijkknfyreffmftomnssmuodgvemykvyxrnwnuqffyrnezfvnlopnvmpdasoddjwievdtzjgoaroylmdmbfkncuvhqfckgknbeyyrbavfwyzeodqsg"
+        },
+        {
+            "input": [
+                "rsbtxhhveiwkzbtholezcathmxfvjjylqj",
+                "kfkrjxwlmdjryosfwvihpqeirbqhhbaxrkzdsyutdvdfsoljfxmtghglwlhozzulyvhtbrpwhszksjxqkxkqoyqxqnt",
+                "twidpgqgspgudpoxibzzwyvqiwfkujjoeazxjdydurfjqfafgsnvxymrekwlmwcosakcbhsxpmkkmdovpssrfjfwlraeoxi"
+            ],
+            "output": "kfkrjxwlmdjryosfwvihpqeirbqhhbaxrkzdsyutdvdfsoljfxmtghglwlhozzulyvhtbrpwhszksjxqkxkqoyqxqntwidpgqgspgudpoxibzzwyvqiwfkujjoeazxjdydurfjqfafgsnvxymrekwlmwcosakcbhsxpmkkmdovpssrfjfwlraeoxirsbtxhhveiwkzbtholezcathmxfvjjylqj"
+        },
+        {
+            "input": [
+                "foycvolzkbafijihpaffpmbohpxekfwmrmjkqlyuinxdnxmvbnmgdjwzploaanuyvphvstsjypeejzmfsuqjafloycjwggqae",
+                "physhjizrulnpjnhawppmbodqnfsndfatunrydrsnhplisxtfeaxepmtoomvbvbxgcbvucygplkql",
+                "fqudtkzpoweczosdltursuiwzxapsoyitaltdgbadqphessrhnwxipcijtb"
+            ],
+            "output": "foycvolzkbafijihpaffpmbohpxekfwmrmjkqlyuinxdnxmvbnmgdjwzploaanuyvphvstsjypeejzmfsuqjafloycjwggqaefqudtkzpoweczosdltursuiwzxapsoyitaltdgbadqphessrhnwxipcijtbphyshjizrulnpjnhawppmbodqnfsndfatunrydrsnhplisxtfeaxepmtoomvbvbxgcbvucygplkql"
+        }
+    ],
+    "haskell_template": "minimumString :: String -> String -> String -> String\nminimumString a b c ",
+    "ocaml_template": "let minimumString (a: string) (b: string) (c: string) : string =  ",
+    "scala_template": "def minimumString(a: String,b: String,c: String): String = { \n    \n}",
+    "java_template": "public static String minimumString(String a, String b, String c) {\n\n}",
+    "python_template": "class Solution(object):\n    def minimumString(self, a, b, c):\n        \"\"\"\n        :type a: str\n        :type b: str\n        :type c: str\n        :rtype: str\n        \"\"\"\n        "
+}

shortest_string_that_contains_three_strings/ocaml_tests/main.ml

@@ -0,0 +1,26 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal "aaabca" (minimumString "abc" "bca" "aaa")
+
+let test2 _ = assert_equal "aba" (minimumString "ab" "ba" "aba")
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for minimumString" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

shortest_string_that_contains_three_strings/scala_tests/MySuite.scala

@@ -0,0 +1,12 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.minimumString("abc","bca","aaa"), "aaabca")
+  }
+
+  test("test2") {
+    assertEquals(Main.minimumString("ab","ba","aba"), "aba")
+  }
+
+}

shortest_subarray_with_or_at_least_k_i/haskell_tests/Main.hs

@@ -0,0 +1,45 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (minimumSubarrayLength [1,2,3] 2)," 1 (minimumSubarrayLength [1,2,3] 2))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (minimumSubarrayLength [2,1,8] 10)," 3 (minimumSubarrayLength [2,1,8] 10))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (minimumSubarrayLength [1,2] 0)," 1 (minimumSubarrayLength [1,2] 0))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (minimumSubarrayLength [22, 31, 32, 30, 43, 26, 31, 22, 18, 22, 35, 8, 24, 12] 47)," 2 (minimumSubarrayLength [22, 31, 32, 30, 43, 26, 31, 22, 18, 22, 35, 8, 24, 12] 47))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (minimumSubarrayLength [4, 39, 7, 38, 9, 15, 31, 20, 4, 2, 36, 41, 27, 38, 42] 60)," 2 (minimumSubarrayLength [4, 39, 7, 38, 9, 15, 31, 20, 4, 2, 36, 41, 27, 38, 42] 60))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (minimumSubarrayLength [1, 21, 41, 7, 42, 24, 16, 22, 16, 1, 8, 3, 8, 32, 21, 11, 4, 22, 35, 27, 24] 33)," 1 (minimumSubarrayLength [1, 21, 41, 7, 42, 24, 16, 22, 16, 1, 8, 3, 8, 32, 21, 11, 4, 22, 35, 27, 24] 33))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (minimumSubarrayLength [15, 40, 37, 16, 33, 6, 49, 25, 32, 48, 34, 23, 9, 46, 9, 45, 32, 34, 42, 16, 14, 3, 50, 5, 22, 17, 50] 44)," 1 (minimumSubarrayLength [15, 40, 37, 16, 33, 6, 49, 25, 32, 48, 34, 23, 9, 46, 9, 45, 32, 34, 42, 16, 14, 3, 50, 5, 22, 17, 50] 44))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (minimumSubarrayLength [8, 30, 41, 14, 5, 17, 17, 4, 46, 0, 48, 22, 44, 26, 48, 10, 22, 44, 14, 29, 9, 30] 13)," 1 (minimumSubarrayLength [8, 30, 41, 14, 5, 17, 17, 4, 46, 0, 48, 22, 44, 26, 48, 10, 22, 44, 14, 29, 9, 30] 13))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (minimumSubarrayLength [19, 45, 49, 7, 49, 42, 44, 14, 23, 11, 49, 35, 43, 22, 29, 48, 42, 19, 17, 26, 24, 42, 43, 16, 30, 44, 18, 25, 32, 12, 12, 18, 19, 15, 9, 4] 55)," 2 (minimumSubarrayLength [19, 45, 49, 7, 49, 42, 44, 14, 23, 11, 49, 35, 43, 22, 29, 48, 42, 19, 17, 26, 24, 42, 43, 16, 30, 44, 18, 25, 32, 12, 12, 18, 19, 15, 9, 4] 55))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1, TestLabel "Test2" test2, TestLabel "Test3" test3, TestLabel "Test4" test4, TestLabel "Test5" test5, TestLabel "Test6" test6, TestLabel "Test7" test7, TestLabel "Test8" test8, TestLabel "Test9" test9]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

shortest_subarray_with_or_at_least_k_i/java_tests/Main.java

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

shortest_subarray_with_or_at_least_k_i/meta.json

@@ -0,0 +1,308 @@
+{
+    "id": 3381,
+    "name": "shortest_subarray_with_or_at_least_k_i",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/shortest-subarray-with-or-at-least-k-i/",
+    "date": "2024-03-16 00:00:00",
+    "task_description": "You are given an array `nums` of **non-negative** integers and an integer `k`. An array is called **special** if the bitwise `OR` of all of its elements is **at least** `k`. Return _the length of the **shortest** **special** **non-empty** subarray of_ `nums`, _or return_ `-1` _if no special subarray exists_. **Example 1:** **Input:** nums = [1,2,3], k = 2 **Output:** 1 **Explanation:** The subarray `[3]` has `OR` value of `3`. Hence, we return `1`. Note that `[2]` is also a special subarray. **Example 2:** **Input:** nums = [2,1,8], k = 10 **Output:** 3 **Explanation:** The subarray `[2,1,8]` has `OR` value of `11`. Hence, we return `3`. **Example 3:** **Input:** nums = [1,2], k = 0 **Output:** 1 **Explanation:** The subarray `[1]` has `OR` value of `1`. Hence, we return `1`. **Constraints:** `1 <= nums.length <= 50` `0 <= nums[i] <= 50` `0 <= k < 64`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "nums = [1,2,3], k = 2",
+            "output": "1 "
+        },
+        {
+            "label": "Example 2",
+            "input": "nums = [2,1,8], k = 10",
+            "output": "3 "
+        },
+        {
+            "label": "Example 3",
+            "input": "nums = [1,2], k = 0",
+            "output": "1 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                [
+                    22,
+                    31,
+                    32,
+                    30,
+                    43,
+                    26,
+                    31,
+                    22,
+                    18,
+                    22,
+                    35,
+                    8,
+                    24,
+                    12
+                ],
+                47
+            ],
+            "output": 2
+        },
+        {
+            "input": [
+                [
+                    4,
+                    39,
+                    7,
+                    38,
+                    9,
+                    15,
+                    31,
+                    20,
+                    4,
+                    2,
+                    36,
+                    41,
+                    27,
+                    38,
+                    42
+                ],
+                60
+            ],
+            "output": 2
+        },
+        {
+            "input": [
+                [
+                    1,
+                    21,
+                    41,
+                    7,
+                    42,
+                    24,
+                    16,
+                    22,
+                    16,
+                    1,
+                    8,
+                    3,
+                    8,
+                    32,
+                    21,
+                    11,
+                    4,
+                    22,
+                    35,
+                    27,
+                    24
+                ],
+                33
+            ],
+            "output": 1
+        },
+        {
+            "input": [
+                [
+                    15,
+                    40,
+                    37,
+                    16,
+                    33,
+                    6,
+                    49,
+                    25,
+                    32,
+                    48,
+                    34,
+                    23,
+                    9,
+                    46,
+                    9,
+                    45,
+                    32,
+                    34,
+                    42,
+                    16,
+                    14,
+                    3,
+                    50,
+                    5,
+                    22,
+                    17,
+                    50
+                ],
+                44
+            ],
+            "output": 1
+        },
+        {
+            "input": [
+                [
+                    8,
+                    30,
+                    41,
+                    14,
+                    5,
+                    17,
+                    17,
+                    4,
+                    46,
+                    0,
+                    48,
+                    22,
+                    44,
+                    26,
+                    48,
+                    10,
+                    22,
+                    44,
+                    14,
+                    29,
+                    9,
+                    30
+                ],
+                13
+            ],
+            "output": 1
+        },
+        {
+            "input": [
+                [
+                    19,
+                    45,
+                    49,
+                    7,
+                    49,
+                    42,
+                    44,
+                    14,
+                    23,
+                    11,
+                    49,
+                    35,
+                    43,
+                    22,
+                    29,
+                    48,
+                    42,
+                    19,
+                    17,
+                    26,
+                    24,
+                    42,
+                    43,
+                    16,
+                    30,
+                    44,
+                    18,
+                    25,
+                    32,
+                    12,
+                    12,
+                    18,
+                    19,
+                    15,
+                    9,
+                    4
+                ],
+                55
+            ],
+            "output": 2
+        },
+        {
+            "input": [
+                [
+                    40,
+                    17,
+                    33,
+                    21,
+                    29,
+                    36,
+                    7,
+                    6,
+                    22,
+                    42,
+                    31
+                ],
+                46
+            ],
+            "output": 2
+        },
+        {
+            "input": [
+                [
+                    2,
+                    31,
+                    49,
+                    26,
+                    46,
+                    15,
+                    16,
+                    46,
+                    7,
+                    27,
+                    32,
+                    2,
+                    48,
+                    45,
+                    9,
+                    46,
+                    30,
+                    10,
+                    18
+                ],
+                55
+            ],
+            "output": 2
+        },
+        {
+            "input": [
+                [
+                    33,
+                    43,
+                    49,
+                    18,
+                    21,
+                    40
+                ],
+                49
+            ],
+            "output": 1
+        },
+        {
+            "input": [
+                [
+                    1,
+                    12,
+                    9,
+                    0,
+                    21,
+                    29,
+                    21,
+                    4,
+                    2,
+                    15,
+                    16,
+                    2,
+                    15,
+                    13,
+                    49,
+                    17,
+                    18,
+                    32,
+                    50,
+                    49,
+                    26,
+                    28,
+                    10,
+                    20,
+                    12
+                ],
+                20
+            ],
+            "output": 1
+        }
+    ],
+    "haskell_template": "minimumSubarrayLength :: [Int] -> Int -> Int\nminimumSubarrayLength nums k ",
+    "ocaml_template": "let minimumSubarrayLength (nums: int list) (k: int) : int =  ",
+    "scala_template": "def minimumSubarrayLength(nums: List[Int],k: Int): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public int minimumSubarrayLength(int[] nums, int k) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def minimumSubarrayLength(self, nums, k):\n        \"\"\"\n        :type nums: List[int]\n        :type k: int\n        :rtype: int\n        \"\"\"\n        "
+}

shortest_subarray_with_or_at_least_k_i/ocaml_tests/main.ml

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

shortest_subarray_with_or_at_least_k_i/scala_tests/MySuite.scala

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

shortest_subarray_with_or_at_least_k_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(1, minimumSubarrayLength(new ArrayList<>(Arrays.asList(1,2,3)), 2));
+}
+@Test
+public void test2() {
+    assertEquals(3, minimumSubarrayLength(new ArrayList<>(Arrays.asList(2,1,8)), 10));
+}
+@Test
+public void test3() {
+    assertEquals(1, minimumSubarrayLength(new ArrayList<>(Arrays.asList(1,2)), 0));
+}
+
+}

shortest_subarray_with_or_at_least_k_ii/meta.json

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

shortest_uncommon_substring_in_an_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(Arrays.asList("ab","","ba",""), shortestSubstrings(Arrays.asList("cab","ad","bad","c")));
+}
+@Test
+public void test2() {
+    assertEquals(Arrays.asList("","","abcd"), shortestSubstrings(Arrays.asList("abc","bcd","abcd")));
+}
+
+}

sliding_subarray_beauty/haskell_tests/Main.hs

@@ -0,0 +1,27 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (getSubarrayBeauty [1,-1,-3,-2,3] 3 2)," [-1,-2,-2] (getSubarrayBeauty [1,-1,-3,-2,3] 3 2))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (getSubarrayBeauty [-1,-2,-3,-4,-5] 2 2)," [-1,-2,-3,-4] (getSubarrayBeauty [-1,-2,-3,-4,-5] 2 2))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (getSubarrayBeauty [-3,1,2,-3,0,-3] 2 1)," [-3,0,-3,-3,-3] (getSubarrayBeauty [-3,1,2,-3,0,-3] 2 1))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1, TestLabel "Test2" test2]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

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

sliding_subarray_beauty/meta.json

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

sliding_subarray_beauty/ocaml_tests/main.ml

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

sliding_subarray_beauty/scala_tests/MySuite.scala

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

smallest_divisible_digit_product_i/haskell_tests/Main.hs

@@ -0,0 +1,45 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (smallestNumber 10 2)," 10 (smallestNumber 10 2))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (smallestNumber 15 3)," 16 (smallestNumber 15 3))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (smallestNumber 80 10)," 80 (smallestNumber 80 10))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (smallestNumber 95 10)," 100 (smallestNumber 95 10))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (smallestNumber 79 5)," 80 (smallestNumber 79 5))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (smallestNumber 61 1)," 61 (smallestNumber 61 1))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (smallestNumber 79 2)," 80 (smallestNumber 79 2))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (smallestNumber 96 10)," 100 (smallestNumber 96 10))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (smallestNumber 97 2)," 98 (smallestNumber 97 2))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1, TestLabel "Test2" test2, TestLabel "Test3" test3, TestLabel "Test4" test4, TestLabel "Test5" test5, TestLabel "Test6" test6, TestLabel "Test7" test7, TestLabel "Test8" test8, TestLabel "Test9" test9]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

smallest_divisible_digit_product_i/java_tests/Main.java

@@ -0,0 +1,21 @@
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+import java.util.List;
+import java.util.Arrays;
+import java.util.ArrayList;
+public class Main {
+    //Program start
+    
+    //Program end
+
+    @Test
+public void test1() {
+    assertEquals(10, smallestNumber(10, 2));
+}
+@Test
+public void test2() {
+    assertEquals(16, smallestNumber(15, 3));
+}
+
+}

smallest_divisible_digit_product_i/meta.json

@@ -0,0 +1,97 @@
+{
+    "id": 3626,
+    "name": "smallest_divisible_digit_product_i",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/smallest-divisible-digit-product-i/",
+    "date": "2024-10-26 00:00:00",
+    "task_description": "You are given two integers `n` and `t`. Return the **smallest** number greater than or equal to `n` such that the **product of its digits** is divisible by `t`. **Example 1:** **Input:** n = 10, t = 2 **Output:** 10 **Explanation:** The digit product of 10 is 0, which is divisible by 2, making it the smallest number greater than or equal to 10 that satisfies the condition. **Example 2:** **Input:** n = 15, t = 3 **Output:** 16 **Explanation:** The digit product of 16 is 6, which is divisible by 3, making it the smallest number greater than or equal to 15 that satisfies the condition. **Constraints:** `1 <= n <= 100` `1 <= t <= 10`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "n = 10, t = 2",
+            "output": "10 "
+        },
+        {
+            "label": "Example 2",
+            "input": "n = 15, t = 3",
+            "output": "16 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                80,
+                10
+            ],
+            "output": 80
+        },
+        {
+            "input": [
+                95,
+                10
+            ],
+            "output": 100
+        },
+        {
+            "input": [
+                79,
+                5
+            ],
+            "output": 80
+        },
+        {
+            "input": [
+                61,
+                1
+            ],
+            "output": 61
+        },
+        {
+            "input": [
+                79,
+                2
+            ],
+            "output": 80
+        },
+        {
+            "input": [
+                96,
+                10
+            ],
+            "output": 100
+        },
+        {
+            "input": [
+                97,
+                2
+            ],
+            "output": 98
+        },
+        {
+            "input": [
+                9,
+                5
+            ],
+            "output": 10
+        },
+        {
+            "input": [
+                92,
+                7
+            ],
+            "output": 97
+        },
+        {
+            "input": [
+                41,
+                4
+            ],
+            "output": 41
+        }
+    ],
+    "haskell_template": "smallestNumber :: Int -> Int -> Int\nsmallestNumber n t ",
+    "ocaml_template": "let smallestNumber (n: int) (t: int) : int =  ",
+    "scala_template": "def smallestNumber(n: Int,t: Int): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public int smallestNumber(int n, int t) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def smallestNumber(self, n, t):\n        \"\"\"\n        :type n: int\n        :type t: int\n        :rtype: int\n        \"\"\"\n        "
+}

smallest_divisible_digit_product_i/ocaml_tests/main.ml

@@ -0,0 +1,50 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 10 (smallestNumber 10 2)
+
+let test2 _ = assert_equal 16 (smallestNumber 15 3)
+
+let test3 _ = assert_equal 80 (smallestNumber 80 10)
+
+let test4 _ = assert_equal 100 (smallestNumber 95 10)
+
+let test5 _ = assert_equal 80 (smallestNumber 79 5)
+
+let test6 _ = assert_equal 61 (smallestNumber 61 1)
+
+let test7 _ = assert_equal 80 (smallestNumber 79 2)
+
+let test8 _ = assert_equal 100 (smallestNumber 96 10)
+
+let test9 _ = assert_equal 98 (smallestNumber 97 2)
+
+let test10 _ = assert_equal 10 (smallestNumber 9 5)
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for smallestNumber" >::: [
+        
+  "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

smallest_divisible_digit_product_i/scala_tests/MySuite.scala

@@ -0,0 +1,44 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.smallestNumber(10,2), 10)
+  }
+
+  test("test2") {
+    assertEquals(Main.smallestNumber(15,3), 16)
+  }
+
+  test("test3") {
+    assertEquals(Main.smallestNumber(80,10), 80)
+  }
+
+  test("test4") {
+    assertEquals(Main.smallestNumber(95,10), 100)
+  }
+
+  test("test5") {
+    assertEquals(Main.smallestNumber(79,5), 80)
+  }
+
+  test("test6") {
+    assertEquals(Main.smallestNumber(61,1), 61)
+  }
+
+  test("test7") {
+    assertEquals(Main.smallestNumber(79,2), 80)
+  }
+
+  test("test8") {
+    assertEquals(Main.smallestNumber(96,10), 100)
+  }
+
+  test("test9") {
+    assertEquals(Main.smallestNumber(97,2), 98)
+  }
+
+  test("test10") {
+    assertEquals(Main.smallestNumber(9,5), 10)
+  }
+
+}

smallest_divisible_digit_product_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("256", smallestNumber("1234", 256));
+}
+@Test
+public void test2() {
+    assertEquals("50", smallestNumber("12355", 50));
+}
+@Test
+public void test3() {
+    assertEquals("26", smallestNumber("11111", 26));
+}
+
+}

smallest_missing_integer_greater_than_sequential_prefix_sum/haskell_tests/Main.hs

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

smallest_missing_integer_greater_than_sequential_prefix_sum/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(6, missingInteger(Arrays.asList(1,2,3,2,5)));
+}
+@Test
+public void test2() {
+    assertEquals(15, missingInteger(Arrays.asList(3,4,5,1,12,14,13)));
+}
+
+}

smallest_missing_integer_greater_than_sequential_prefix_sum/meta.json

@@ -0,0 +1,144 @@
+{
+    "id": 3236,
+    "name": "smallest_missing_integer_greater_than_sequential_prefix_sum",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/smallest-missing-integer-greater-than-sequential-prefix-sum/",
+    "date": "2023-12-23 00:00:00",
+    "task_description": "You are given a **0-indexed** array of integers `nums`. A prefix `nums[0..i]` is **sequential** if, for all `1 <= j <= i`, `nums[j] = nums[j - 1] + 1`. In particular, the prefix consisting only of `nums[0]` is **sequential**. Return _the **smallest** integer_ `x` _missing from_ `nums` _such that_ `x` _is greater than or equal to the sum of the **longest** sequential prefix._ **Example 1:** ``` **Input:** nums = [1,2,3,2,5] **Output:** 6 **Explanation:** The longest sequential prefix of nums is [1,2,3] with a sum of 6. 6 is not in the array, therefore 6 is the smallest missing integer greater than or equal to the sum of the longest sequential prefix. ``` **Example 2:** ``` **Input:** nums = [3,4,5,1,12,14,13] **Output:** 15 **Explanation:** The longest sequential prefix of nums is [3,4,5] with a sum of 12. 12, 13, and 14 belong to the array while 15 does not. Therefore 15 is the smallest missing integer greater than or equal to the sum of the longest sequential prefix. ``` **Constraints:** `1 <= nums.length <= 50` `1 <= nums[i] <= 50`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "nums = [1,2,3,2,5]",
+            "output": "6 "
+        },
+        {
+            "label": "Example 2",
+            "input": "nums = [3,4,5,1,12,14,13]",
+            "output": "15 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                7,
+                17,
+                38
+            ],
+            "output": 8
+        },
+        {
+            "input": [
+                7,
+                24,
+                7,
+                41,
+                18,
+                11,
+                16,
+                1,
+                26,
+                41
+            ],
+            "output": 8
+        },
+        {
+            "input": [
+                12,
+                10,
+                39,
+                28,
+                40,
+                38,
+                33,
+                8,
+                31,
+                14,
+                32,
+                23,
+                48,
+                14,
+                19,
+                43,
+                18
+            ],
+            "output": 13
+        },
+        {
+            "input": [
+                11,
+                30,
+                12,
+                12,
+                30,
+                15,
+                13,
+                4,
+                44,
+                20,
+                1,
+                17,
+                28,
+                40,
+                24,
+                9,
+                22,
+                7,
+                23,
+                20,
+                12,
+                37,
+                13,
+                4,
+                47,
+                41,
+                23,
+                1,
+                1,
+                13,
+                9,
+                26,
+                27,
+                21,
+                39,
+                30,
+                42,
+                46,
+                34,
+                50,
+                3,
+                23
+            ],
+            "output": 14
+        },
+        {
+            "input": [
+                26,
+                36,
+                4,
+                9,
+                48,
+                36,
+                27,
+                27,
+                48,
+                7,
+                34,
+                37,
+                14,
+                44,
+                16,
+                17,
+                7,
+                26,
+                16,
+                35
+            ],
+            "output": 28
+        }
+    ],
+    "haskell_template": "missingInteger :: [Int] -> Int\nmissingInteger nums ",
+    "ocaml_template": "let missingInteger (nums: int list) : int =  ",
+    "scala_template": "def missingInteger(nums: List[Int]): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public int missingInteger(int[] nums) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def missingInteger(self, nums):\n        \"\"\"\n        :type nums: List[int]\n        :rtype: int\n        \"\"\"\n        "
+}

smallest_missing_integer_greater_than_sequential_prefix_sum/ocaml_tests/main.ml

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

smallest_missing_integer_greater_than_sequential_prefix_sum/scala_tests/MySuite.scala

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

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

smallest_missing_non_negative_integer_after_operations/java_tests/Main.java

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

smallest_missing_non_negative_integer_after_operations/meta.json

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

smallest_missing_non_negative_integer_after_operations/ocaml_tests/main.ml

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

smallest_missing_non_negative_integer_after_operations/scala_tests/MySuite.scala

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

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

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

smallest_subarrays_with_maximum_bitwise_or/ocaml_tests/main.ml

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

smallest_subarrays_with_maximum_bitwise_or/scala_tests/MySuite.scala

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

smallest_substring_with_identical_characters_i/haskell_tests/Main.hs

@@ -0,0 +1,45 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (minLength \"000001 \" 1)," 2 (minLength "000001" 1))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (minLength \"0000 \" 2)," 1 (minLength "0000" 2))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (minLength  \"111011101011001101110101111010001001010111111001010111011001110100010010101010101000111110010110000010000101010100111111001101100101110010100011111000111001100101001101100101111001011010110000001110111011001010101101110110100000010100001100011110111010011110101001010010010100011011110000101010010010101101000001110110100011111101011101000010001011101110000001110101110111110111011000111001101010110101001111101000111010101001101100010011111011010101011011110001011011000100011111111100100000111110010100010100000101000111100100001010000100011011001011100001100011010111001011010101001001101001111110000001010011100001000000100011011111110001011000101000001011111100111111010011100010111001110010000100100000011111000111000110001001101010001100111100000001010111000110011101010110010010100100000100 \" 791)," 1 (minLength "111011101011001101110101111010001001010111111001010111011001110100010010101010101000111110010110000010000101010100111111001101100101110010100011111000111001100101001101100101111001011010110000001110111011001010101101110110100000010100001100011110111010011110101001010010010100011011110000101010010010101101000001110110100011111101011101000010001011101110000001110101110111110111011000111001101010110101001111101000111010101001101100010011111011010101011011110001011011000100011111111100100000111110010100010100000101000111100100001010000100011011001011100001100011010111001011010101001001101001111110000001010011100001000000100011011111110001011000101000001011111100111111010011100010111001110010000100100000011111000111000110001001101010001100111100000001010111000110011101010110010010100100000100" 791))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (minLength  \"010001010100011010001010001011011101000001011110000100101001010000100001010111110101011001000100110011111111011101101100101110001111100011110101011011000001101001111110000010001100011110100011011111010101100010000010100000 \" 168)," 1 (minLength "010001010100011010001010001011011101000001011110000100101001010000100001010111110101011001000100110011111111011101101100101110001111100011110101011011000001101001111110000010001100011110100011011111010101100010000010100000" 168))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (minLength  \"0001001111010111010011001101110100000111011111110001001110111111100110011000110001111000000110100111100110010101000101001001100100001000001100010011001110000010110111001101100101011011100010101110011010100010110010100111111111010001011001101000011000100010110001111100100111011111000000001101101101110000111010000010010011001111101111111011110011010101101101011001100111110111011001000101000101011101000101001001000010110111101011100001100000001110010110000100101010110100110100010011101011111000001001111010110111010101001101110100111110000101000000011111101100000110001010000001100001100110000111000 \" 255)," 2 (minLength "0001001111010111010011001101110100000111011111110001001110111111100110011000110001111000000110100111100110010101000101001001100100001000001100010011001110000010110111001101100101011011100010101110011010100010110010100111111111010001011001101000011000100010110001111100100111011111000000001101101101110000111010000010010011001111101111111011110011010101101101011001100111110111011001000101000101011101000101001001000010110111101011100001100000001110010110000100101010110100110100010011101011111000001001111010110111010101001101110100111110000101000000011111101100000110001010000001100001100110000111000" 255))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (minLength  \"110101001110100001010000010010111100110001011110010111011111111101010010101000010100001000010100100101110100111001010110010000001111011110111101111001110010111111001111100100110110100000101111111001101111110101011000001011110100100010001001010101001000001001001010000001110000010110000000000101111101010011110000011001100011111101000010010011100010100001001001001000010011100010110011100010011101100111100000010110010001111101011011000100111011010000011100000101111100101101100111001111001010101011111010001110000111011101001011010100010000110000011010101010001001110101 \" 527)," 1 (minLength "110101001110100001010000010010111100110001011110010111011111111101010010101000010100001000010100100101110100111001010110010000001111011110111101111001110010111111001111100100110110100000101111111001101111110101011000001011110100100010001001010101001000001001001010000001110000010110000000000101111101010011110000011001100011111101000010010011100010100001001001001000010011100010110011100010011101100111100000010110010001111101011011000100111011010000011100000101111100101101100111001111001010101011111010001110000111011101001011010100010000110000011010101010001001110101" 527))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (minLength  \"010000110000101101001100001101010000100000110100000010010111001111001001100010111100001001101111101101101011011110100010110101001111000001111010110100001101111001110100110000010001010101101110001110000101111000111111110001100110011011100001010000010000100010010010110111100100110101111011110011111100100111010010011000000001001110101000100110110110110011011111100111000010010100000010000101001111001111110100101010001111110001001100001010110000111000010000010001110101111010011000111101110001111010011001001100011011110110101100100010010011011110010100100101010010101100001011010001011011001100000011100100010111101101111111000000010110001010001010011011100000101011110000101011001100100001111100010001011010110000000000010110011 \" 604)," 1 (minLength "010000110000101101001100001101010000100000110100000010010111001111001001100010111100001001101111101101101011011110100010110101001111000001111010110100001101111001110100110000010001010101101110001110000101111000111111110001100110011011100001010000010000100010010010110111100100110101111011110011111100100111010010011000000001001110101000100110110110110011011111100111000010010100000010000101001111001111110100101010001111110001001100001010110000111000010000010001110101111010011000111101110001111010011001001100011011110110101100100010010011011110010100100101010010101100001011010001011011001100000011100100010111101101111111000000010110001010001010011011100000101011110000101011001100100001111100010001011010110000000000010110011" 604))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (minLength  \"00101110001110010110011011100000010001001101001001000100111111001010110011000001110000001100011011100111101010110011111001100111110000011101011110010111010101010010001100111101000001001001111010010111001010101110010000010101100100011010000010110100010111111011110110101110110011010011011100001011101000110111100001110111101001111100100011001011000111100001101111110111000001011100010011111010110100010100000100111000100101101100010110100110110100011101010000111100010001010010110110001101010010001111010010101010111000000001111001101 \" 487)," 1 (minLength "00101110001110010110011011100000010001001101001001000100111111001010110011000001110000001100011011100111101010110011111001100111110000011101011110010111010101010010001100111101000001001001111010010111001010101110010000010101100100011010000010110100010111111011110110101110110011010011011100001011101000110111100001110111101001111100100011001011000111100001101111110111000001011100010011111010110100010100000100111000100101101100010110100110110100011101010000111100010001010010110110001101010010001111010010101010111000000001111001101" 487))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (minLength  \"1101 \" 1)," 1 (minLength "1101" 1))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1, TestLabel "Test2" test2, TestLabel "Test3" test3, TestLabel "Test4" test4, TestLabel "Test5" test5, TestLabel "Test6" test6, TestLabel "Test7" test7, TestLabel "Test8" test8, TestLabel "Test9" test9]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

smallest_substring_with_identical_characters_i/java_tests/Main.java

@@ -0,0 +1,21 @@
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+import java.util.List;
+import java.util.Arrays;
+import java.util.ArrayList;
+public class Main {
+    //Program start
+    
+    //Program end
+
+    @Test
+public void test1() {
+    assertEquals(2, minLength("000001", 1));
+}
+@Test
+public void test2() {
+    assertEquals(1, minLength("0000", 2));
+}
+
+}