be8f1cce3a0f463240b62b24b9d4ef97b4400e560d24a55825db07a8bcbca50d

.gitattributes

@@ -288,3 +288,6 @@ sum_of_distances/meta.json filter=lfs diff=lfs merge=lfs -text
 sum_of_matrix_after_queries/meta.json filter=lfs diff=lfs merge=lfs -text
 task_scheduler_ii/meta.json filter=lfs diff=lfs merge=lfs -text
 total_cost_to_hire_k_workers/meta.json filter=lfs diff=lfs merge=lfs -text
+zero_array_transformation_i/haskell_tests/Main.hs filter=lfs diff=lfs merge=lfs -text
+zero_array_transformation_i/meta.json filter=lfs diff=lfs merge=lfs -text
+zero_array_transformation_i/ocaml_tests/main.ml filter=lfs diff=lfs merge=lfs -text

unique_3_digit_even_numbers/ocaml_tests/main.ml

@@ -0,0 +1,48 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+    let totalNumbers (digits: int list) : int =   failwith "Not implemented"
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 12 (totalNumbers [1;2;3;4])
+
+let test2 _ = assert_equal 2 (totalNumbers [0;2;2])
+
+let test3 _ = assert_equal 1 (totalNumbers [6;6;6])
+
+let test4 _ = assert_equal 0 (totalNumbers [1;3;5])
+
+let test5 _ = assert_equal 0 (totalNumbers [7; 9; 2; 1])
+
+let test6 _ = assert_equal 0 (totalNumbers [1; 7; 4; 7; 8; 4; 7; 2; 2])
+
+let test7 _ = assert_equal 0 (totalNumbers [1; 3; 1])
+
+let test8 _ = assert_equal 0 (totalNumbers [4; 8; 0; 3; 0; 1; 7])
+
+let test9 _ = assert_equal 0 (totalNumbers [3; 3; 1; 8; 8; 5; 4; 5])
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for totalNumbers" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+  "test3" >:: test3;
+  "test4" >:: test4;
+  "test5" >:: test5;
+  "test6" >:: test6;
+  "test7" >:: test7;
+  "test8" >:: test8;
+  "test9" >:: test9;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

unique_3_digit_even_numbers/scala_tests/MySuite.scala

@@ -0,0 +1,40 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.totalNumbers(List(1,2,3,4)), 12)
+  }
+
+  test("test2") {
+    assertEquals(Main.totalNumbers(List(0,2,2)), 2)
+  }
+
+  test("test3") {
+    assertEquals(Main.totalNumbers(List(6,6,6)), 1)
+  }
+
+  test("test4") {
+    assertEquals(Main.totalNumbers(List(1,3,5)), 0)
+  }
+
+  test("test5") {
+    assertEquals(Main.totalNumbers(7,9,2,1), 6)
+  }
+
+  test("test6") {
+    assertEquals(Main.totalNumbers(1,7,4,7,8,4,7,2,2), 59)
+  }
+
+  test("test7") {
+    assertEquals(Main.totalNumbers(1,3,1), 0)
+  }
+
+  test("test8") {
+    assertEquals(Main.totalNumbers(4,8,0,3,0,1,7), 57)
+  }
+
+  test("test9") {
+    assertEquals(Main.totalNumbers(3,3,1,8,8,5,4,5), 37)
+  }
+
+}

using_a_robot_to_print_the_lexicographically_smallest_string/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 (robotWithString \"zza \")," "azz" (robotWithString "zza"))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (robotWithString \"bac \")," "abc" (robotWithString "bac"))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (robotWithString \"bdda \")," "addb" (robotWithString "bdda"))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1, TestLabel "Test2" test2]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

using_a_robot_to_print_the_lexicographically_smallest_string/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("zza", robotWithString("zza"));
+}
+@Test
+public void test2() {
+    assertEquals("bac", robotWithString("bac"));
+}
+@Test
+public void test3() {
+    assertEquals("bdda", robotWithString("bdda"));
+}
+
+}

using_a_robot_to_print_the_lexicographically_smallest_string/ocaml_tests/main.ml

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

using_a_robot_to_print_the_lexicographically_smallest_string/scala_tests/MySuite.scala

@@ -0,0 +1,16 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.robotWithString("zza"), "azz")
+  }
+
+  test("test2") {
+    assertEquals(Main.robotWithString("bac"), "abc")
+  }
+
+  test("test3") {
+    assertEquals(Main.robotWithString("bdda"), "addb")
+  }
+
+}

valid_word/haskell_tests/Main.hs

@@ -0,0 +1,47 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+isValid :: String -> Bool
+isValid word = undefined
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (isValid \"234Adas \")," True (isValid "234Adas"))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (isValid \"b3 \")," False (isValid "b3"))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (isValid \"a3$e \")," False (isValid "a3$e"))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (isValid  \"Gj#UP \")," False (isValid "Gj#UP"))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (isValid  \"ifhka@1pjwpS@Om7 \")," False (isValid "ifhka@1pjwpS@Om7"))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (isValid  \"btCM6QrVaYtHIZ#1Ueg \")," False (isValid "btCM6QrVaYtHIZ#1Ueg"))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (isValid  \"t@6YzUK600NKB9afj \")," False (isValid "t@6YzUK600NKB9afj"))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (isValid  \"cBo \")," True (isValid "cBo"))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (isValid  \"2LevwlR \")," True (isValid "2LevwlR"))
+
+
+-- 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

valid_word/java_tests/Main.java

@@ -0,0 +1,24 @@
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+import java.util.List;
+import java.util.Arrays;
+public class Main {
+    //Program start
+
+    //Program end
+
+    @Test
+public void test1() {
+    assertEquals(true, isValid("234Adas"));
+}
+@Test
+public void test2() {
+    assertEquals(false, isValid("b3"));
+}
+@Test
+public void test3() {
+    assertEquals(false, isValid("a3$e"));
+}
+
+}

valid_word/meta.json

@@ -0,0 +1,72 @@
+{
+    "id": 3396,
+    "name": "valid_word",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/valid-word/",
+    "date": "2024-04-28 00:00:00",
+    "task_description": "A word is considered **valid** if: It contains a **minimum** of 3 characters. It contains only digits (0-9), and English letters (uppercase and lowercase). It includes **at least** one **vowel**. It includes **at least** one **consonant**. You are given a string `word`. Return `true` if `word` is valid, otherwise, return `false`. **Notes:** `'a'`, `'e'`, `'i'`, `'o'`, `'u'`, and their uppercases are **vowels**. A **consonant** is an English letter that is not a vowel. **Example 1:** **Input:** word = \"234Adas\" **Output:** true **Explanation:** This word satisfies the conditions. **Example 2:** **Input:** word = \"b3\" **Output:** false **Explanation:** The length of this word is fewer than 3, and does not have a vowel. **Example 3:** **Input:** word = \"a3$e\" **Output:** false **Explanation:** This word contains a `'$'` character and does not have a consonant. **Constraints:** `1 <= word.length <= 20` `word` consists of English uppercase and lowercase letters, digits, `'@'`, `'#'`, and `'$'`.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "word = \"234Adas\"",
+            "output": "true "
+        },
+        {
+            "label": "Example 2",
+            "input": "word = \"b3\"",
+            "output": "false "
+        },
+        {
+            "label": "Example 3",
+            "input": "word = \"a3$e\"",
+            "output": "false "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": "Gj#UP",
+            "output": false
+        },
+        {
+            "input": "ifhka@1pjwpS@Om7",
+            "output": false
+        },
+        {
+            "input": "btCM6QrVaYtHIZ#1Ueg",
+            "output": false
+        },
+        {
+            "input": "t@6YzUK600NKB9afj",
+            "output": false
+        },
+        {
+            "input": "cBo",
+            "output": true
+        },
+        {
+            "input": "2LevwlR",
+            "output": true
+        },
+        {
+            "input": "J28oLv3MqiGs",
+            "output": true
+        },
+        {
+            "input": "28oazDB37nk",
+            "output": true
+        },
+        {
+            "input": "zAXWzgNJmdk1BZitNF",
+            "output": true
+        },
+        {
+            "input": "mXCmEg7YQV",
+            "output": true
+        }
+    ],
+    "haskell_template": "isValid :: String -> Bool\nisValid word ",
+    "ocaml_template": "let isValid (word: string) : bool =  ",
+    "scala_template": "def isValid(word: String): Boolean = { \n    \n}",
+    "java_template": "class Solution {\n    public boolean isValid(String word) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def isValid(self, word):\n        \"\"\"\n        :type word: str\n        :rtype: bool\n        \"\"\"\n        "
+}

valid_word/ocaml_tests/main.ml

@@ -0,0 +1,51 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+    let isValid (word: string) : bool =   failwith "Not implemented"
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal true (isValid "234Adas")
+
+let test2 _ = assert_equal false (isValid "b3")
+
+let test3 _ = assert_equal false (isValid "a3$e")
+
+let test4 _ = assert_equal false (isValid "Gj#UP")
+
+let test5 _ = assert_equal false (isValid "ifhka@1pjwpS@Om7")
+
+let test6 _ = assert_equal false (isValid "btCM6QrVaYtHIZ#1Ueg")
+
+let test7 _ = assert_equal false (isValid "t@6YzUK600NKB9afj")
+
+let test8 _ = assert_equal false (isValid "cBo")
+
+let test9 _ = assert_equal false (isValid "2LevwlR")
+
+let test10 _ = assert_equal false (isValid "J28oLv3MqiGs")
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for isValid" >::: [
+        
+  "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

valid_word/scala_tests/MySuite.scala

@@ -0,0 +1,44 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.isValid("234Adas"), true)
+  }
+
+  test("test2") {
+    assertEquals(Main.isValid("b3"), false)
+  }
+
+  test("test3") {
+    assertEquals(Main.isValid("a3$e"), false)
+  }
+
+  test("test4") {
+    assertEquals(Main.isValid(",G,j,#,U,P,"), false)
+  }
+
+  test("test5") {
+    assertEquals(Main.isValid(",i,f,h,k,a,@,1,p,j,w,p,S,@,O,m,7,"), false)
+  }
+
+  test("test6") {
+    assertEquals(Main.isValid(",b,t,C,M,6,Q,r,V,a,Y,t,H,I,Z,#,1,U,e,g,"), false)
+  }
+
+  test("test7") {
+    assertEquals(Main.isValid(",t,@,6,Y,z,U,K,6,0,0,N,K,B,9,a,f,j,"), false)
+  }
+
+  test("test8") {
+    assertEquals(Main.isValid(",c,B,o,"), true)
+  }
+
+  test("test9") {
+    assertEquals(Main.isValid(",2,L,e,v,w,l,R,"), true)
+  }
+
+  test("test10") {
+    assertEquals(Main.isValid(",J,2,8,o,L,v,3,M,q,i,G,s,"), true)
+  }
+
+}

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

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

visit_array_positions_to_maximize_score/meta.json

@@ -0,0 +1,659 @@
+{
+    "id": 2893,
+    "name": "visit_array_positions_to_maximize_score",
+    "difficulty": "Medium",
+    "link": "https://leetcode.com/problems/visit-array-positions-to-maximize-score/",
+    "date": "1688774400000",
+    "task_description": "You are given a **0-indexed** integer array `nums` and a positive integer `x`. You are **initially** at position `0` in the array and you can visit other positions according to the following rules: If you are currently in position `i`, then you can move to **any** position `j` such that `i < j`. For each position `i` that you visit, you get a score of `nums[i]`. If you move from a position `i` to a position `j` and the **parities** of `nums[i]` and `nums[j]` differ, then you lose a score of `x`. Return _the **maximum** total score you can get_. **Note** that initially you have `nums[0]` points. **Example 1:** ``` **Input:** nums = [2,3,6,1,9,2], x = 5 **Output:** 13 **Explanation:** We can visit the following positions in the array: 0 -> 2 -> 3 -> 4. The corresponding values are 2, 6, 1 and 9. Since the integers 6 and 1 have different parities, the move 2 -> 3 will make you lose a score of x = 5. The total score will be: 2 + 6 + 1 + 9 - 5 = 13. ``` **Example 2:** ``` **Input:** nums = [2,4,6,8], x = 3 **Output:** 20 **Explanation:** All the integers in the array have the same parities, so we can visit all of them without losing any score. The total score is: 2 + 4 + 6 + 8 = 20. ``` **Constraints:** `2 <= nums.length <= 105` `1 <= nums[i], x <= 106`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "nums = [2,3,6,1,9,2], x = 5",
+            "output": "13 "
+        },
+        {
+            "label": "Example 2",
+            "input": "nums = [2,4,6,8], x = 3",
+            "output": "20 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                [
+                    485218,
+                    309709,
+                    630635,
+                    337575,
+                    471891,
+                    609441,
+                    615815,
+                    700447,
+                    85332,
+                    519324,
+                    528124,
+                    561172,
+                    823184,
+                    309613,
+                    247626,
+                    531839,
+                    398557,
+                    283267,
+                    361606,
+                    917018,
+                    709132,
+                    991857,
+                    104164,
+                    122268,
+                    896020,
+                    318965,
+                    216425,
+                    363123,
+                    840228,
+                    806757,
+                    88360,
+                    81391,
+                    741015,
+                    968506,
+                    903142,
+                    14202,
+                    85318,
+                    995900,
+                    558618,
+                    490698,
+                    880065,
+                    457288,
+                    39493,
+                    884068,
+                    907319,
+                    728076,
+                    451136,
+                    143959,
+                    540174,
+                    991389,
+                    955279,
+                    274109,
+                    530754,
+                    427419,
+                    101773,
+                    448682,
+                    910600,
+                    810696,
+                    691453,
+                    472803,
+                    523554,
+                    232254,
+                    438324,
+                    993193,
+                    239326,
+                    692257,
+                    568214,
+                    582839,
+                    902547,
+                    243549,
+                    977298
+                ],
+                419077
+            ],
+            "output": 27825662
+        },
+        {
+            "input": [
+                [
+                    999845,
+                    2727,
+                    218611,
+                    750198,
+                    372616,
+                    729785,
+                    849413,
+                    429990,
+                    20157,
+                    224326,
+                    445369,
+                    673265,
+                    960760,
+                    827163,
+                    369368,
+                    926400,
+                    598331,
+                    395407
+                ],
+                651414
+            ],
+            "output": 5886610
+        },
+        {
+            "input": [
+                [
+                    219144,
+                    945121,
+                    887315,
+                    297758,
+                    623865,
+                    913917,
+                    524280,
+                    157517,
+                    903857,
+                    128775,
+                    289544,
+                    376299,
+                    955582,
+                    844420,
+                    221271,
+                    962458,
+                    796074,
+                    56465,
+                    889268,
+                    576081,
+                    437467,
+                    81345,
+                    781023,
+                    278337,
+                    415576,
+                    106657,
+                    333536,
+                    548645,
+                    227782,
+                    391678,
+                    771871,
+                    622340,
+                    677081,
+                    911901,
+                    788465,
+                    61421,
+                    118470,
+                    841196,
+                    838997,
+                    341705,
+                    90761,
+                    292833,
+                    74132,
+                    829956,
+                    332018,
+                    678339,
+                    553831,
+                    27312,
+                    89956,
+                    224392,
+                    104987,
+                    781044,
+                    709330,
+                    648746,
+                    658527,
+                    976838,
+                    322790,
+                    630509,
+                    393252,
+                    126193,
+                    439008,
+                    532437,
+                    230698,
+                    381287,
+                    438206,
+                    550730,
+                    907340,
+                    969114,
+                    829997,
+                    643930,
+                    975756,
+                    294425,
+                    326400,
+                    888218,
+                    515725,
+                    866033,
+                    589559,
+                    933915,
+                    262851,
+                    32953,
+                    129198,
+                    355494,
+                    383292,
+                    61609,
+                    898331,
+                    628020,
+                    873425,
+                    208283,
+                    575006
+                ],
+                921560
+            ],
+            "output": 29602252
+        },
+        {
+            "input": [
+                [
+                    746704,
+                    926919,
+                    205461,
+                    995257,
+                    951303,
+                    292435,
+                    564947,
+                    452281,
+                    204849,
+                    829104,
+                    362162,
+                    915433,
+                    979427,
+                    648430,
+                    947824,
+                    448045,
+                    593267,
+                    982565,
+                    374609,
+                    20137
+                ],
+                900744
+            ],
+            "output": 8752895
+        },
+        {
+            "input": [
+                [
+                    781654,
+                    255447,
+                    639135,
+                    399879,
+                    767941,
+                    721564,
+                    853751,
+                    747520,
+                    167382,
+                    167744,
+                    844103,
+                    810361,
+                    640293,
+                    285855,
+                    261994,
+                    129024,
+                    123924,
+                    605824,
+                    423896,
+                    498604,
+                    94835,
+                    363030,
+                    335047,
+                    665941,
+                    681323,
+                    231700,
+                    683192,
+                    466306,
+                    774215,
+                    825836,
+                    199305,
+                    131800,
+                    641686,
+                    45246,
+                    941560,
+                    149818,
+                    970658,
+                    528783,
+                    752140,
+                    36586,
+                    690676,
+                    444633,
+                    114322,
+                    769610,
+                    480383,
+                    357653,
+                    878714,
+                    862545,
+                    587603,
+                    390833,
+                    424260,
+                    774443,
+                    532315,
+                    495134,
+                    936402,
+                    802485,
+                    200011,
+                    606441,
+                    991906,
+                    714087,
+                    345030,
+                    190419,
+                    220400,
+                    831122,
+                    966703,
+                    25757,
+                    320689,
+                    569711,
+                    727786,
+                    591251,
+                    569215,
+                    241025,
+                    864395,
+                    574094,
+                    5931,
+                    782641,
+                    700077,
+                    145453,
+                    540879,
+                    996494,
+                    708118,
+                    920587,
+                    239931,
+                    976193,
+                    927956,
+                    973898,
+                    682152,
+                    283105,
+                    271072,
+                    472866,
+                    807411,
+                    412593,
+                    997169,
+                    143853,
+                    404359,
+                    454747,
+                    293645,
+                    312539,
+                    893102,
+                    55803,
+                    912966,
+                    771802,
+                    86698
+                ],
+                924773
+            ],
+            "output": 35406375
+        },
+        {
+            "input": [
+                [
+                    685303,
+                    903254,
+                    747974,
+                    951339,
+                    29705,
+                    591691,
+                    273845,
+                    130605,
+                    395612,
+                    552015,
+                    409728,
+                    426037,
+                    702740,
+                    727255,
+                    884505,
+                    97837,
+                    276232,
+                    544458,
+                    765408,
+                    456056
+                ],
+                162921
+            ],
+            "output": 9085310
+        },
+        {
+            "input": [
+                [
+                    720279,
+                    491077,
+                    929262,
+                    811102,
+                    538120,
+                    58664,
+                    812857,
+                    732118,
+                    965490,
+                    109361,
+                    32443,
+                    757105,
+                    177974,
+                    317446,
+                    265306,
+                    895620,
+                    847590,
+                    623176,
+                    824538,
+                    925917,
+                    398383,
+                    534637,
+                    990857,
+                    696326,
+                    49096,
+                    870648,
+                    203364,
+                    41089,
+                    132684,
+                    963777,
+                    363413,
+                    68694,
+                    857471,
+                    128173,
+                    765580,
+                    490160,
+                    449068,
+                    306771,
+                    566246,
+                    420078,
+                    539418,
+                    54655,
+                    916593,
+                    910922,
+                    743206,
+                    553866,
+                    848733,
+                    236627,
+                    261150,
+                    924700,
+                    878973,
+                    186981,
+                    565462,
+                    525,
+                    611685,
+                    521951,
+                    678702,
+                    993405,
+                    942796,
+                    210511,
+                    127747,
+                    366006,
+                    713828,
+                    892370,
+                    135016,
+                    450209,
+                    761673,
+                    232611,
+                    499677,
+                    940790,
+                    227214,
+                    819458,
+                    252108,
+                    762853,
+                    364644,
+                    720568,
+                    720584,
+                    141822,
+                    125417,
+                    40518,
+                    293733,
+                    499619,
+                    943839,
+                    404157,
+                    607741,
+                    494348,
+                    192297,
+                    982460,
+                    935069,
+                    26877
+                ],
+                480881
+            ],
+            "output": 34987568
+        },
+        {
+            "input": [
+                [
+                    462670,
+                    796177,
+                    569994,
+                    642212,
+                    931330,
+                    440076,
+                    343158,
+                    745909,
+                    35500,
+                    794874,
+                    20521,
+                    939985,
+                    641783,
+                    562861,
+                    304358,
+                    926052,
+                    384102,
+                    688206,
+                    929371,
+                    953925,
+                    48197,
+                    176656,
+                    57208,
+                    411891,
+                    270350,
+                    270381,
+                    716642,
+                    147171,
+                    466179,
+                    593626,
+                    9977,
+                    59015,
+                    805242,
+                    643200,
+                    920753,
+                    151065,
+                    546606,
+                    799583,
+                    434133,
+                    293901,
+                    260916,
+                    572502,
+                    762552,
+                    633035,
+                    129989,
+                    350251,
+                    984499,
+                    514240,
+                    275326,
+                    123348,
+                    442797,
+                    699144,
+                    869460,
+                    476632,
+                    696178,
+                    518067,
+                    832087,
+                    872870,
+                    188732,
+                    990938,
+                    663217,
+                    29636,
+                    796004,
+                    964155,
+                    318754,
+                    34748,
+                    771617,
+                    557144,
+                    999561,
+                    814347,
+                    871317,
+                    438929,
+                    717510,
+                    981,
+                    842827,
+                    599623,
+                    342621,
+                    838682,
+                    167817,
+                    290618,
+                    753749,
+                    419958,
+                    82758,
+                    535127,
+                    984470,
+                    132978,
+                    998733,
+                    535645,
+                    836354,
+                    998251,
+                    734529,
+                    742406,
+                    359529,
+                    450334,
+                    692664,
+                    292495,
+                    901948,
+                    962035,
+                    298841
+                ],
+                751120
+            ],
+            "output": 34041581
+        },
+        {
+            "input": [
+                [
+                    206967,
+                    84782,
+                    802976,
+                    761732,
+                    666544,
+                    270193,
+                    461535,
+                    915356,
+                    273148,
+                    148439,
+                    521369,
+                    65830,
+                    218719
+                ],
+                316667
+            ],
+            "output": 4065092
+        },
+        {
+            "input": [
+                [
+                    665458,
+                    844254,
+                    688328,
+                    194703,
+                    659042,
+                    568523,
+                    806280,
+                    520965,
+                    921443,
+                    831861,
+                    448737,
+                    646179,
+                    7889,
+                    218683,
+                    854168,
+                    906592,
+                    66680,
+                    507722,
+                    245058,
+                    123216,
+                    535940,
+                    38543,
+                    359563,
+                    406925,
+                    963735,
+                    627967,
+                    739074,
+                    220999,
+                    100262
+                ],
+                495738
+            ],
+            "output": 11751612
+        }
+    ],
+    "haskell_template": "maxScore :: [Int] -> Int -> Int\nmaxScore nums x ",
+    "ocaml_template": "let maxScore (nums: int list) (x: int) : int =  ",
+    "scala_template": "def maxScore(nums: List[Int],x: Int): Int = { \n    \n}",
+    "java_template": "public static int maxScore(List<Integer> nums, int x) {\n\n}",
+    "python_template": "class Solution(object):\n    def maxScore(self, nums, x):\n        \"\"\"\n        :type nums: List[int]\n        :type x: int\n        :rtype: int\n        \"\"\"\n        "
+}

visit_array_positions_to_maximize_score/ocaml_tests/main.ml

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

visit_array_positions_to_maximize_score/scala_tests/MySuite.scala

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

vowels_game_in_a_string/java_tests/Main.java

@@ -0,0 +1,20 @@
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+import java.util.List;
+import java.util.Arrays;
+public class Main {
+    //Program start
+
+    //Program end
+
+    @Test
+public void test1() {
+    assertEquals(true, doesAliceWin("leetcoder"));
+}
+@Test
+public void test2() {
+    assertEquals(false, doesAliceWin("bbcd"));
+}
+
+}

water_bottles_ii/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 (maxBottlesDrunk 13 6)," 15 (maxBottlesDrunk 13 6))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (maxBottlesDrunk 10 3)," 13 (maxBottlesDrunk 10 3))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (maxBottlesDrunk 6 68)," 6 (maxBottlesDrunk 6 68))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (maxBottlesDrunk 57 95)," 57 (maxBottlesDrunk 57 95))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (maxBottlesDrunk 52 64)," 52 (maxBottlesDrunk 52 64))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (maxBottlesDrunk 49 47)," 50 (maxBottlesDrunk 49 47))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (maxBottlesDrunk 28 47)," 28 (maxBottlesDrunk 28 47))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (maxBottlesDrunk 30 3)," 36 (maxBottlesDrunk 30 3))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (maxBottlesDrunk 24 8)," 26 (maxBottlesDrunk 24 8))
+
+
+-- 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

water_bottles_ii/java_tests/Main.java

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

water_bottles_ii/meta.json

@@ -0,0 +1,97 @@
+{
+    "id": 3336,
+    "name": "water_bottles_ii",
+    "difficulty": "Medium",
+    "link": "https://leetcode.com/problems/water-bottles-ii/",
+    "date": "2024-03-24 00:00:00",
+    "task_description": "You are given two integers `numBottles` and `numExchange`. `numBottles` represents the number of full water bottles that you initially have. In one operation, you can perform one of the following operations: Drink any number of full water bottles turning them into empty bottles. Exchange `numExchange` empty bottles with one full water bottle. Then, increase `numExchange` by one. Note that you cannot exchange multiple batches of empty bottles for the same value of `numExchange`. For example, if `numBottles == 3` and `numExchange == 1`, you cannot exchange `3` empty water bottles for `3` full bottles. Return _the **maximum** number of water bottles you can drink_. **Example 1:** ``` **Input:** numBottles = 13, numExchange = 6 **Output:** 15 **Explanation:** The table above shows the number of full water bottles, empty water bottles, the value of numExchange, and the number of bottles drunk. ``` **Example 2:** ``` **Input:** numBottles = 10, numExchange = 3 **Output:** 13 **Explanation:** The table above shows the number of full water bottles, empty water bottles, the value of numExchange, and the number of bottles drunk. ``` **Constraints:** `1 <= numBottles <= 100 ` `1 <= numExchange <= 100`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "numBottles = 13, numExchange = 6",
+            "output": "15 "
+        },
+        {
+            "label": "Example 2",
+            "input": "numBottles = 10, numExchange = 3",
+            "output": "13 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                6,
+                68
+            ],
+            "output": 6
+        },
+        {
+            "input": [
+                57,
+                95
+            ],
+            "output": 57
+        },
+        {
+            "input": [
+                52,
+                64
+            ],
+            "output": 52
+        },
+        {
+            "input": [
+                49,
+                47
+            ],
+            "output": 50
+        },
+        {
+            "input": [
+                28,
+                47
+            ],
+            "output": 28
+        },
+        {
+            "input": [
+                30,
+                3
+            ],
+            "output": 36
+        },
+        {
+            "input": [
+                24,
+                8
+            ],
+            "output": 26
+        },
+        {
+            "input": [
+                74,
+                48
+            ],
+            "output": 75
+        },
+        {
+            "input": [
+                9,
+                96
+            ],
+            "output": 9
+        },
+        {
+            "input": [
+                93,
+                41
+            ],
+            "output": 95
+        }
+    ],
+    "haskell_template": "maxBottlesDrunk :: Int -> Int -> Int\nmaxBottlesDrunk numBottles numExchange ",
+    "ocaml_template": "let maxBottlesDrunk (numBottles: int) (numExchange: int) : int =  ",
+    "scala_template": "def maxBottlesDrunk(numBottles: Int,numExchange: Int): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public int maxBottlesDrunk(int numBottles, int numExchange) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def maxBottlesDrunk(self, numBottles, numExchange):\n        \"\"\"\n        :type numBottles: int\n        :type numExchange: int\n        :rtype: int\n        \"\"\"\n        "
+}

water_bottles_ii/ocaml_tests/main.ml

@@ -0,0 +1,50 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 15 (maxBottlesDrunk 13 6)
+
+let test2 _ = assert_equal 13 (maxBottlesDrunk 10 3)
+
+let test3 _ = assert_equal 6 (maxBottlesDrunk 6 68)
+
+let test4 _ = assert_equal 57 (maxBottlesDrunk 57 95)
+
+let test5 _ = assert_equal 52 (maxBottlesDrunk 52 64)
+
+let test6 _ = assert_equal 50 (maxBottlesDrunk 49 47)
+
+let test7 _ = assert_equal 28 (maxBottlesDrunk 28 47)
+
+let test8 _ = assert_equal 36 (maxBottlesDrunk 30 3)
+
+let test9 _ = assert_equal 26 (maxBottlesDrunk 24 8)
+
+let test10 _ = assert_equal 75 (maxBottlesDrunk 74 48)
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for maxBottlesDrunk" >::: [
+        
+  "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

water_bottles_ii/scala_tests/MySuite.scala

@@ -0,0 +1,44 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.maxBottlesDrunk(13,6), 15)
+  }
+
+  test("test2") {
+    assertEquals(Main.maxBottlesDrunk(10,3), 13)
+  }
+
+  test("test3") {
+    assertEquals(Main.maxBottlesDrunk(6,68), 6)
+  }
+
+  test("test4") {
+    assertEquals(Main.maxBottlesDrunk(57,95), 57)
+  }
+
+  test("test5") {
+    assertEquals(Main.maxBottlesDrunk(52,64), 52)
+  }
+
+  test("test6") {
+    assertEquals(Main.maxBottlesDrunk(49,47), 50)
+  }
+
+  test("test7") {
+    assertEquals(Main.maxBottlesDrunk(28,47), 28)
+  }
+
+  test("test8") {
+    assertEquals(Main.maxBottlesDrunk(30,3), 36)
+  }
+
+  test("test9") {
+    assertEquals(Main.maxBottlesDrunk(24,8), 26)
+  }
+
+  test("test10") {
+    assertEquals(Main.maxBottlesDrunk(74,48), 75)
+  }
+
+}

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

ways_to_express_an_integer_as_sum_of_powers/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, numberOfWays(10, 2));
+}
+@Test
+public void test2() {
+    assertEquals(2, numberOfWays(4, 1));
+}
+
+}

ways_to_express_an_integer_as_sum_of_powers/meta.json

@@ -0,0 +1,97 @@
+{
+    "id": 2882,
+    "name": "ways_to_express_an_integer_as_sum_of_powers",
+    "difficulty": "Medium",
+    "link": "https://leetcode.com/problems/ways-to-express-an-integer-as-sum-of-powers/",
+    "date": "1688774400000",
+    "task_description": "Given two **positive** integers `n` and `x`. Return _the number of ways _`n`_ can be expressed as the sum of the _`xth`_ power of **unique** positive integers, in other words, the number of sets of unique integers _`[n1, n2, ..., nk]`_ where _`n = n1x + n2x + ... + nkx`_._ Since the result can be very large, return it modulo `109 + 7`. For example, if `n = 160` and `x = 3`, one way to express `n` is `n = 23 + 33 + 53`. **Example 1:** ``` **Input:** n = 10, x = 2 **Output:** 1 **Explanation:** We can express n as the following: n = 32 + 12 = 10. It can be shown that it is the only way to express 10 as the sum of the 2nd power of unique integers. ``` **Example 2:** ``` **Input:** n = 4, x = 1 **Output:** 2 **Explanation:** We can express n in the following ways: - n = 41 = 4. - n = 31 + 11 = 4. ``` **Constraints:** `1 <= n <= 300` `1 <= x <= 5`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "n = 10, x = 2",
+            "output": "1 "
+        },
+        {
+            "label": "Example 2",
+            "input": "n = 4, x = 1",
+            "output": "2 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                50,
+                3
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                162,
+                1
+            ],
+            "output": 43812110
+        },
+        {
+            "input": [
+                27,
+                3
+            ],
+            "output": 1
+        },
+        {
+            "input": [
+                240,
+                5
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                106,
+                3
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                250,
+                1
+            ],
+            "output": 519280072
+        },
+        {
+            "input": [
+                21,
+                3
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                208,
+                4
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                2,
+                5
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                18,
+                3
+            ],
+            "output": 0
+        }
+    ],
+    "haskell_template": "numberOfWays :: Int -> Int -> Int\nnumberOfWays n x ",
+    "ocaml_template": "let numberOfWays (n: int) (x: int) : int =  ",
+    "scala_template": "def numberOfWays(n: Int,x: Int): Int = { \n    \n}",
+    "java_template": "public static int numberOfWays(int n, int x) {\n\n}",
+    "python_template": "class Solution(object):\n    def numberOfWays(self, n, x):\n        \"\"\"\n        :type n: int\n        :type x: int\n        :rtype: int\n        \"\"\"\n        "
+}

ways_to_express_an_integer_as_sum_of_powers/ocaml_tests/main.ml

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

ways_to_express_an_integer_as_sum_of_powers/scala_tests/MySuite.scala

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

ways_to_split_array_into_good_subarrays/java_tests/Main.java

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

words_within_two_edits_of_dictionary/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 (twoEditWords [ \"word \", \"note \", \"ants \", \"wood \"] [ \"wood \", \"joke \", \"moat \"])," ["word","note","wood"] (twoEditWords ["word","note","ants","wood"] ["wood","joke","moat"]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (twoEditWords [ \"yes \"] [ \"not \"])," [] (twoEditWords ["yes"] ["not"]))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

words_within_two_edits_of_dictionary/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("word","note","wood")), twoEditWords(new ArrayList<>(Arrays.asList("word","note","ants","wood")), new ArrayList<>(Arrays.asList("wood","joke","moat"))));
+}
+@Test
+public void test2() {
+    assertEquals(new ArrayList<>(), twoEditWords(new ArrayList<>(Arrays.asList("yes")), new ArrayList<>(Arrays.asList("not"))));
+}
+
+}

words_within_two_edits_of_dictionary/meta.json

@@ -0,0 +1,26 @@
+{
+    "id": 2550,
+    "name": "words_within_two_edits_of_dictionary",
+    "difficulty": "Medium",
+    "link": "https://leetcode.com/problems/words-within-two-edits-of-dictionary/",
+    "date": "1665792000000",
+    "task_description": "You are given two string arrays, `queries` and `dictionary`. All words in each array comprise of lowercase English letters and have the same length. In one **edit** you can take a word from `queries`, and change any letter in it to any other letter. Find all words from `queries` that, after a **maximum** of two edits, equal some word from `dictionary`. Return_ a list of all words from _`queries`_, __that match with some word from _`dictionary`_ after a maximum of **two edits**_. Return the words in the **same order** they appear in `queries`. **Example 1:** ``` **Input:** queries = [\"word\",\"note\",\"ants\",\"wood\"], dictionary = [\"wood\",\"joke\",\"moat\"] **Output:** [\"word\",\"note\",\"wood\"] **Explanation:** - Changing the 'r' in \"word\" to 'o' allows it to equal the dictionary word \"wood\". - Changing the 'n' to 'j' and the 't' to 'k' in \"note\" changes it to \"joke\". - It would take more than 2 edits for \"ants\" to equal a dictionary word. - \"wood\" can remain unchanged (0 edits) and match the corresponding dictionary word. Thus, we return [\"word\",\"note\",\"wood\"]. ``` **Example 2:** ``` **Input:** queries = [\"yes\"], dictionary = [\"not\"] **Output:** [] **Explanation:** Applying any two edits to \"yes\" cannot make it equal to \"not\". Thus, we return an empty array. ``` **Constraints:** `1 <= queries.length, dictionary.length <= 100` `n == queries[i].length == dictionary[j].length` `1 <= n <= 100` All `queries[i]` and `dictionary[j]` are composed of lowercase English letters.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "queries = [\"word\",\"note\",\"ants\",\"wood\"], dictionary = [\"wood\",\"joke\",\"moat\"]",
+            "output": "[\"word\",\"note\",\"wood\"] "
+        },
+        {
+            "label": "Example 2",
+            "input": "queries = [\"yes\"], dictionary = [\"not\"]",
+            "output": "[] "
+        }
+    ],
+    "private_test_cases": [],
+    "haskell_template": "twoEditWords :: [String] -> [String] -> [String]\ntwoEditWords queries dictionary ",
+    "ocaml_template": "let twoEditWords (queries: string list) (dictionary: string list) : string list =  ",
+    "scala_template": "def twoEditWords(queries: List[String],dictionary: List[String]): List[String] = { \n    \n}",
+    "java_template": "public static List<String> twoEditWords(List<String> queries, List<String> dictionary) {\n\n}",
+    "python_template": "class Solution(object):\n    def twoEditWords(self, queries, dictionary):\n        \"\"\"\n        :type queries: List[str]\n        :type dictionary: List[str]\n        :rtype: List[str]\n        \"\"\"\n        "
+}

words_within_two_edits_of_dictionary/ocaml_tests/main.ml

@@ -0,0 +1,26 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal ["word";"note";"wood"] (twoEditWords ["word";"note";"ants";"wood"] ["wood";"joke";"moat"])
+
+let test2 _ = assert_equal [] (twoEditWords ["yes"] ["not"])
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for twoEditWords" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

words_within_two_edits_of_dictionary/scala_tests/MySuite.scala

@@ -0,0 +1,12 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.twoEditWords(List("word","note","ants","wood"),List("wood","joke","moat")), List("word","note","wood"))
+  }
+
+  test("test2") {
+    assertEquals(Main.twoEditWords(List("yes"),List("not")), List())
+  }
+
+}

zero_array_transformation_i/haskell_tests/Main.hs

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

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

zero_array_transformation_i/meta.json

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