87988a2e0843c28eb891b6405463ff6582bf7d06d05ae8dce71469edfdee8a98

.gitattributes

@@ -135,3 +135,7 @@ frog_jump_ii/meta.json filter=lfs diff=lfs merge=lfs -text
 fruits_into_baskets_iii/haskell_tests/Main.hs filter=lfs diff=lfs merge=lfs -text
 fruits_into_baskets_iii/meta.json filter=lfs diff=lfs merge=lfs -text
 handling_sum_queries_after_update/meta.json filter=lfs diff=lfs merge=lfs -text
+house_robber_iv/meta.json filter=lfs diff=lfs merge=lfs -text
+increment_submatrices_by_one/meta.json filter=lfs diff=lfs merge=lfs -text
+intervals_between_identical_elements/meta.json filter=lfs diff=lfs merge=lfs -text
+k_th_nearest_obstacle_queries/haskell_tests/Main.hs filter=lfs diff=lfs merge=lfs -text

hash_divided_string/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 (stringHash \"abcd \" 2)," "bf" (stringHash "abcd" 2))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (stringHash \"mxz \" 3)," "i" (stringHash "mxz" 3))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (stringHash  \"mknnewhsvixaeusxsfojlvplbqyjyefrjyyhtajuilrfkjghjnsvnqaydn \" 58)," "h" (stringHash "mknnewhsvixaeusxsfojlvplbqyjyefrjyyhtajuilrfkjghjnsvnqaydn" 58))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (stringHash  \"hkbsjdlmmpstbixdukm \" 19)," "e" (stringHash "hkbsjdlmmpstbixdukm" 19))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (stringHash  \"hrenpeulegbdevkqxkgunlvgjcgcnkyfveviopkctwxwhbbkolfhagijdtrdizpirypifljngxpnptiieyomhqjjktmgoenqopchwgogggndissmbydubfvnydiiishhouqhtpyrzrfprmincrzitkspkqzrmqyendodxzqfoshzusltfmlryehtrbkjmfedsamvuitkilacsmmhbkvngiaaggirnphjxtfegigchuagijfyinrqcnqolrrtstnikodwzxkqgqvcodvgeyiyprivurjsfggblcdhutatqxcaszyplcjyxhvxjdjnbnmolpkqjfcjntszgitnmhnrxjpkpqzibqreaalrcdjxdzhgkotxgcngwtqkpsuxpqesdljpxflnczyajozieygfecszaxnkwwawzdacpermpwcivdviveknyjvlzyyjkedipifsiksmhofosobpjbxmjtxfheetuzozcwybccmdkyphebjngzmesjhxvgfcllrjsicgogubevwoyqclpkinjgmowkmqbbbjgnlruztuvssvpzexnticbbqnfprshbtbcomjsiwnnjuvvv \" 59)," "mfghqouxbh" (stringHash "hrenpeulegbdevkqxkgunlvgjcgcnkyfveviopkctwxwhbbkolfhagijdtrdizpirypifljngxpnptiieyomhqjjktmgoenqopchwgogggndissmbydubfvnydiiishhouqhtpyrzrfprmincrzitkspkqzrmqyendodxzqfoshzusltfmlryehtrbkjmfedsamvuitkilacsmmhbkvngiaaggirnphjxtfegigchuagijfyinrqcnqolrrtstnikodwzxkqgqvcodvgeyiyprivurjsfggblcdhutatqxcaszyplcjyxhvxjdjnbnmolpkqjfcjntszgitnmhnrxjpkpqzibqreaalrcdjxdzhgkotxgcngwtqkpsuxpqesdljpxflnczyajozieygfecszaxnkwwawzdacpermpwcivdviveknyjvlzyyjkedipifsiksmhofosobpjbxmjtxfheetuzozcwybccmdkyphebjngzmesjhxvgfcllrjsicgogubevwoyqclpkinjgmowkmqbbbjgnlruztuvssvpzexnticbbqnfprshbtbcomjsiwnnjuvvv" 59))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (stringHash  \"qsxlpirfwsthwxzadtjsrzwzkcdbamjlkvimwhimffqwjjgmgaeygpxjheaahqqmtgooaybcybycgfvlimxuksbqbtqkddgussimvqoagtuvrjysyxjifasioqcmtsynguoiblpvqqxudxjcdokpbdkvxsqjextaiyubizlcjrdrwfsvivnmxcknskwkznvekfaileikjclsqsfjhmfxcphvdedxjznytvlpuhwigpixxycbbamgelxwwfhkpjsgqewpixzmpftsbaewaujcowqaqaulumntwxjysxcgwpezewkvddbsrymkwwyhkuguawfljwuaqsldbwuxxfbmtbrgrsvqlpvtsyeascudehuenihqah \" 37)," "obknkshumu" (stringHash "qsxlpirfwsthwxzadtjsrzwzkcdbamjlkvimwhimffqwjjgmgaeygpxjheaahqqmtgooaybcybycgfvlimxuksbqbtqkddgussimvqoagtuvrjysyxjifasioqcmtsynguoiblpvqqxudxjcdokpbdkvxsqjextaiyubizlcjrdrwfsvivnmxcknskwkznvekfaileikjclsqsfjhmfxcphvdedxjznytvlpuhwigpixxycbbamgelxwwfhkpjsgqewpixzmpftsbaewaujcowqaqaulumntwxjysxcgwpezewkvddbsrymkwwyhkuguawfljwuaqsldbwuxxfbmtbrgrsvqlpvtsyeascudehuenihqah" 37))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (stringHash  \"imdlgramytqqhnxvrssthdpmsymozgryvqfytyufmrhzctoqcntuyrsjswjeqy \" 31)," "rr" (stringHash "imdlgramytqqhnxvrssthdpmsymozgryvqfytyufmrhzctoqcntuyrsjswjeqy" 31))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (stringHash  \"mrcfbffhqqxjcsicacqwxydlitlcacwbzvkbnpofpjztlptsigapmfowackpdvbscvbzvwcjeoewrtaxigvysjwxokurihlt \" 48)," "dx" (stringHash "mrcfbffhqqxjcsicacqwxydlitlcacwbzvkbnpofpjztlptsigapmfowackpdvbscvbzvwcjeoewrtaxigvysjwxokurihlt" 48))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (stringHash  \"mtztdwkprxmyslkvbzbctmdvkbgeqqvjtlelfxweovjijdckkxvftardiknyrvavdpvxafjbptmxzqlymyjjvrphubfbczwfhqdpvrvzvhuchzvyykdzzpxzxoffxhgzrvljihabhdpallqikkgkafwmlqtwsikhmrmamwswpxiinlncjuwndgxguhzuckqaukbodcinwublsvpftqwmpgaptfpajzsejcrpjechadcfxjdxmleklprvbgwcfjoriznbwryevhbyfdtaswzeqyogsgustciuedccxazekzgmoxaxbextrcktiphwjbtfffhslzxfishinywflldkozkkamtjpcwkuhcdshfmoadlfoalpvyfktmytetiwsscckeqpppuewghuhgangabrkqkwgibulxtyegiinfpbysbatidnxiqmlduqybpsftzzduyjemfyohwruxxettnfsfdliadoehlqwwhmvkcidpxkjxhhggtnctaczmilwsbaanyzhoktyhbqkpv \" 66)," "bffewqcx" (stringHash "mtztdwkprxmyslkvbzbctmdvkbgeqqvjtlelfxweovjijdckkxvftardiknyrvavdpvxafjbptmxzqlymyjjvrphubfbczwfhqdpvrvzvhuchzvyykdzzpxzxoffxhgzrvljihabhdpallqikkgkafwmlqtwsikhmrmamwswpxiinlncjuwndgxguhzuckqaukbodcinwublsvpftqwmpgaptfpajzsejcrpjechadcfxjdxmleklprvbgwcfjoriznbwryevhbyfdtaswzeqyogsgustciuedccxazekzgmoxaxbextrcktiphwjbtfffhslzxfishinywflldkozkkamtjpcwkuhcdshfmoadlfoalpvyfktmytetiwsscckeqpppuewghuhgangabrkqkwgibulxtyegiinfpbysbatidnxiqmlduqybpsftzzduyjemfyohwruxxettnfsfdliadoehlqwwhmvkcidpxkjxhhggtnctaczmilwsbaanyzhoktyhbqkpv" 66))
+
+
+-- 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

hash_divided_string/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", stringHash("abcd", 2));
+}
+@Test
+public void test2() {
+    assertEquals("3", stringHash("mxz", 3));
+}
+
+}

hash_divided_string/meta.json

@@ -0,0 +1,97 @@
+{
+    "id": 3540,
+    "name": "hash_divided_string",
+    "difficulty": "Medium",
+    "link": "https://leetcode.com/problems/hash-divided-string/",
+    "date": "2024-08-17 00:00:00",
+    "task_description": "You are given a string `s` of length `n` and an integer `k`, where `n` is a **multiple** of `k`. Your task is to hash the string `s` into a new string called `result`, which has a length of `n / k`. First, divide `s` into `n / k` **substrings**, each with a length of `k`. Then, initialize `result` as an **empty** string. For each **substring** in order from the beginning: The **hash value** of a character is the index of that character in the **English alphabet** (e.g., `'a' → 0`, `'b' → 1`, ..., `'z' → 25`). Calculate the _sum_ of all the **hash values** of the characters in the substring. Find the remainder of this sum when divided by 26, which is called `hashedChar`. Identify the character in the English lowercase alphabet that corresponds to `hashedChar`. Append that character to the end of `result`. Return `result`. **Example 1:** **Input:** s = \"abcd\", k = 2 **Output:** \"bf\" **Explanation:** First substring: `\"ab\"`, `0 + 1 = 1`, `1 % 26 = 1`, `result[0] = 'b'`. Second substring: `\"cd\"`, `2 + 3 = 5`, `5 % 26 = 5`, `result[1] = 'f'`. **Example 2:** **Input:** s = \"mxz\", k = 3 **Output:** \"i\" **Explanation:** The only substring: `\"mxz\"`, `12 + 23 + 25 = 60`, `60 % 26 = 8`, `result[0] = 'i'`. **Constraints:** `1 <= k <= 100` `k <= s.length <= 1000` `s.length` is divisible by `k`. `s` consists only of lowercase English letters.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "s = \"abcd\", k = 2",
+            "output": "\"bf\" "
+        },
+        {
+            "label": "Example 2",
+            "input": "s = \"mxz\", k = 3",
+            "output": "\"i\" "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                "\"mknnewhsvixaeusxsfojlvplbqyjyefrjyyhtajuilrfkjghjnsvnqaydn\"",
+                58
+            ],
+            "output": "h"
+        },
+        {
+            "input": [
+                "\"hkbsjdlmmpstbixdukm\"",
+                19
+            ],
+            "output": "e"
+        },
+        {
+            "input": [
+                "\"hrenpeulegbdevkqxkgunlvgjcgcnkyfveviopkctwxwhbbkolfhagijdtrdizpirypifljngxpnptiieyomhqjjktmgoenqopchwgogggndissmbydubfvnydiiishhouqhtpyrzrfprmincrzitkspkqzrmqyendodxzqfoshzusltfmlryehtrbkjmfedsamvuitkilacsmmhbkvngiaaggirnphjxtfegigchuagijfyinrqcnqolrrtstnikodwzxkqgqvcodvgeyiyprivurjsfggblcdhutatqxcaszyplcjyxhvxjdjnbnmolpkqjfcjntszgitnmhnrxjpkpqzibqreaalrcdjxdzhgkotxgcngwtqkpsuxpqesdljpxflnczyajozieygfecszaxnkwwawzdacpermpwcivdviveknyjvlzyyjkedipifsiksmhofosobpjbxmjtxfheetuzozcwybccmdkyphebjngzmesjhxvgfcllrjsicgogubevwoyqclpkinjgmowkmqbbbjgnlruztuvssvpzexnticbbqnfprshbtbcomjsiwnnjuvvv\"",
+                59
+            ],
+            "output": "mfghqouxbh"
+        },
+        {
+            "input": [
+                "\"qsxlpirfwsthwxzadtjsrzwzkcdbamjlkvimwhimffqwjjgmgaeygpxjheaahqqmtgooaybcybycgfvlimxuksbqbtqkddgussimvqoagtuvrjysyxjifasioqcmtsynguoiblpvqqxudxjcdokpbdkvxsqjextaiyubizlcjrdrwfsvivnmxcknskwkznvekfaileikjclsqsfjhmfxcphvdedxjznytvlpuhwigpixxycbbamgelxwwfhkpjsgqewpixzmpftsbaewaujcowqaqaulumntwxjysxcgwpezewkvddbsrymkwwyhkuguawfljwuaqsldbwuxxfbmtbrgrsvqlpvtsyeascudehuenihqah\"",
+                37
+            ],
+            "output": "obknkshumu"
+        },
+        {
+            "input": [
+                "\"imdlgramytqqhnxvrssthdpmsymozgryvqfytyufmrhzctoqcntuyrsjswjeqy\"",
+                31
+            ],
+            "output": "rr"
+        },
+        {
+            "input": [
+                "\"mrcfbffhqqxjcsicacqwxydlitlcacwbzvkbnpofpjztlptsigapmfowackpdvbscvbzvwcjeoewrtaxigvysjwxokurihlt\"",
+                48
+            ],
+            "output": "dx"
+        },
+        {
+            "input": [
+                "\"mtztdwkprxmyslkvbzbctmdvkbgeqqvjtlelfxweovjijdckkxvftardiknyrvavdpvxafjbptmxzqlymyjjvrphubfbczwfhqdpvrvzvhuchzvyykdzzpxzxoffxhgzrvljihabhdpallqikkgkafwmlqtwsikhmrmamwswpxiinlncjuwndgxguhzuckqaukbodcinwublsvpftqwmpgaptfpajzsejcrpjechadcfxjdxmleklprvbgwcfjoriznbwryevhbyfdtaswzeqyogsgustciuedccxazekzgmoxaxbextrcktiphwjbtfffhslzxfishinywflldkozkkamtjpcwkuhcdshfmoadlfoalpvyfktmytetiwsscckeqpppuewghuhgangabrkqkwgibulxtyegiinfpbysbatidnxiqmlduqybpsftzzduyjemfyohwruxxettnfsfdliadoehlqwwhmvkcidpxkjxhhggtnctaczmilwsbaanyzhoktyhbqkpv\"",
+                66
+            ],
+            "output": "bffewqcx"
+        },
+        {
+            "input": [
+                "\"tveaugfeecjmlzdskgaz\"",
+                5
+            ],
+            "output": "mvih"
+        },
+        {
+            "input": [
+                "fwwlcqeiznjbsellbqoyydgqvghkxfpqwhbrceaapetqfjff",
+                24
+            ],
+            "output": "aa"
+        },
+        {
+            "input": [
+                "lzrjjwaxglcicsujxldilsqdcazfiknweaavbyfpikbkvduavjxdpsnuuitabguyqhevqjjbqjhkbjhhndqwtflawguetmibvirgxomrkeoqufgbwwyzofxpphyumynhzvpqtnfuzsgbczcqoxasdrljnhytwgvjdzxdxqongohlqyztxuqaobhwdokrfkrjaktoeuovnpnyftjttydihvueifjhdmznimbqbvhsqjgqdxkpoogqanfakqlfxjuvsqxavytbbtvfhotridmdcxgbfniaqsdmbxsobicwmkamwljpaqpfjsglrwozobzwbavbpdliaqkbblqonvkglpkqhdbrgf",
+                70
+            ],
+            "output": "axrnr"
+        }
+    ],
+    "haskell_template": "stringHash :: String -> Int -> String\nstringHash s k ",
+    "ocaml_template": "let stringHash (s: string) (k: int) : string =  ",
+    "scala_template": "def stringHash(s: String,k: Int): String = { \n    \n}",
+    "java_template": "class Solution {\n    public String stringHash(String s, int k) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def stringHash(self, s, k):\n        \"\"\"\n        :type s: str\n        :type k: int\n        :rtype: str\n        \"\"\"\n        "
+}

hash_divided_string/ocaml_tests/main.ml

@@ -0,0 +1,50 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal "bf" (stringHash "abcd" 2)
+
+let test2 _ = assert_equal "i" (stringHash "mxz" 3)
+
+let test3 _ = assert_equal "h" (stringHash "mknnewhsvixaeusxsfojlvplbqyjyefrjyyhtajuilrfkjghjnsvnqaydn" 58)
+
+let test4 _ = assert_equal "e" (stringHash "hkbsjdlmmpstbixdukm" 19)
+
+let test5 _ = assert_equal "mfghqouxbh" (stringHash "hrenpeulegbdevkqxkgunlvgjcgcnkyfveviopkctwxwhbbkolfhagijdtrdizpirypifljngxpnptiieyomhqjjktmgoenqopchwgogggndissmbydubfvnydiiishhouqhtpyrzrfprmincrzitkspkqzrmqyendodxzqfoshzusltfmlryehtrbkjmfedsamvuitkilacsmmhbkvngiaaggirnphjxtfegigchuagijfyinrqcnqolrrtstnikodwzxkqgqvcodvgeyiyprivurjsfggblcdhutatqxcaszyplcjyxhvxjdjnbnmolpkqjfcjntszgitnmhnrxjpkpqzibqreaalrcdjxdzhgkotxgcngwtqkpsuxpqesdljpxflnczyajozieygfecszaxnkwwawzdacpermpwcivdviveknyjvlzyyjkedipifsiksmhofosobpjbxmjtxfheetuzozcwybccmdkyphebjngzmesjhxvgfcllrjsicgogubevwoyqclpkinjgmowkmqbbbjgnlruztuvssvpzexnticbbqnfprshbtbcomjsiwnnjuvvv" 59)
+
+let test6 _ = assert_equal "obknkshumu" (stringHash "qsxlpirfwsthwxzadtjsrzwzkcdbamjlkvimwhimffqwjjgmgaeygpxjheaahqqmtgooaybcybycgfvlimxuksbqbtqkddgussimvqoagtuvrjysyxjifasioqcmtsynguoiblpvqqxudxjcdokpbdkvxsqjextaiyubizlcjrdrwfsvivnmxcknskwkznvekfaileikjclsqsfjhmfxcphvdedxjznytvlpuhwigpixxycbbamgelxwwfhkpjsgqewpixzmpftsbaewaujcowqaqaulumntwxjysxcgwpezewkvddbsrymkwwyhkuguawfljwuaqsldbwuxxfbmtbrgrsvqlpvtsyeascudehuenihqah" 37)
+
+let test7 _ = assert_equal "rr" (stringHash "imdlgramytqqhnxvrssthdpmsymozgryvqfytyufmrhzctoqcntuyrsjswjeqy" 31)
+
+let test8 _ = assert_equal "dx" (stringHash "mrcfbffhqqxjcsicacqwxydlitlcacwbzvkbnpofpjztlptsigapmfowackpdvbscvbzvwcjeoewrtaxigvysjwxokurihlt" 48)
+
+let test9 _ = assert_equal "bffewqcx" (stringHash "mtztdwkprxmyslkvbzbctmdvkbgeqqvjtlelfxweovjijdckkxvftardiknyrvavdpvxafjbptmxzqlymyjjvrphubfbczwfhqdpvrvzvhuchzvyykdzzpxzxoffxhgzrvljihabhdpallqikkgkafwmlqtwsikhmrmamwswpxiinlncjuwndgxguhzuckqaukbodcinwublsvpftqwmpgaptfpajzsejcrpjechadcfxjdxmleklprvbgwcfjoriznbwryevhbyfdtaswzeqyogsgustciuedccxazekzgmoxaxbextrcktiphwjbtfffhslzxfishinywflldkozkkamtjpcwkuhcdshfmoadlfoalpvyfktmytetiwsscckeqpppuewghuhgangabrkqkwgibulxtyegiinfpbysbatidnxiqmlduqybpsftzzduyjemfyohwruxxettnfsfdliadoehlqwwhmvkcidpxkjxhhggtnctaczmilwsbaanyzhoktyhbqkpv" 66)
+
+let test10 _ = assert_equal "mvih" (stringHash "tveaugfeecjmlzdskgaz" 5)
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for stringHash" >::: [
+        
+  "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

hash_divided_string/scala_tests/MySuite.scala

@@ -0,0 +1,44 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.stringHash("abcd",2), "bf")
+  }
+
+  test("test2") {
+    assertEquals(Main.stringHash("mxz",3), "i")
+  }
+
+  test("test3") {
+    assertEquals(Main.stringHash("mknnewhsvixaeusxsfojlvplbqyjyefrjyyhtajuilrfkjghjnsvnqaydn",58), "h")
+  }
+
+  test("test4") {
+    assertEquals(Main.stringHash("hkbsjdlmmpstbixdukm",19), "e")
+  }
+
+  test("test5") {
+    assertEquals(Main.stringHash("hrenpeulegbdevkqxkgunlvgjcgcnkyfveviopkctwxwhbbkolfhagijdtrdizpirypifljngxpnptiieyomhqjjktmgoenqopchwgogggndissmbydubfvnydiiishhouqhtpyrzrfprmincrzitkspkqzrmqyendodxzqfoshzusltfmlryehtrbkjmfedsamvuitkilacsmmhbkvngiaaggirnphjxtfegigchuagijfyinrqcnqolrrtstnikodwzxkqgqvcodvgeyiyprivurjsfggblcdhutatqxcaszyplcjyxhvxjdjnbnmolpkqjfcjntszgitnmhnrxjpkpqzibqreaalrcdjxdzhgkotxgcngwtqkpsuxpqesdljpxflnczyajozieygfecszaxnkwwawzdacpermpwcivdviveknyjvlzyyjkedipifsiksmhofosobpjbxmjtxfheetuzozcwybccmdkyphebjngzmesjhxvgfcllrjsicgogubevwoyqclpkinjgmowkmqbbbjgnlruztuvssvpzexnticbbqnfprshbtbcomjsiwnnjuvvv",59), "mfghqouxbh")
+  }
+
+  test("test6") {
+    assertEquals(Main.stringHash("qsxlpirfwsthwxzadtjsrzwzkcdbamjlkvimwhimffqwjjgmgaeygpxjheaahqqmtgooaybcybycgfvlimxuksbqbtqkddgussimvqoagtuvrjysyxjifasioqcmtsynguoiblpvqqxudxjcdokpbdkvxsqjextaiyubizlcjrdrwfsvivnmxcknskwkznvekfaileikjclsqsfjhmfxcphvdedxjznytvlpuhwigpixxycbbamgelxwwfhkpjsgqewpixzmpftsbaewaujcowqaqaulumntwxjysxcgwpezewkvddbsrymkwwyhkuguawfljwuaqsldbwuxxfbmtbrgrsvqlpvtsyeascudehuenihqah",37), "obknkshumu")
+  }
+
+  test("test7") {
+    assertEquals(Main.stringHash("imdlgramytqqhnxvrssthdpmsymozgryvqfytyufmrhzctoqcntuyrsjswjeqy",31), "rr")
+  }
+
+  test("test8") {
+    assertEquals(Main.stringHash("mrcfbffhqqxjcsicacqwxydlitlcacwbzvkbnpofpjztlptsigapmfowackpdvbscvbzvwcjeoewrtaxigvysjwxokurihlt",48), "dx")
+  }
+
+  test("test9") {
+    assertEquals(Main.stringHash("mtztdwkprxmyslkvbzbctmdvkbgeqqvjtlelfxweovjijdckkxvftardiknyrvavdpvxafjbptmxzqlymyjjvrphubfbczwfhqdpvrvzvhuchzvyykdzzpxzxoffxhgzrvljihabhdpallqikkgkafwmlqtwsikhmrmamwswpxiinlncjuwndgxguhzuckqaukbodcinwublsvpftqwmpgaptfpajzsejcrpjechadcfxjdxmleklprvbgwcfjoriznbwryevhbyfdtaswzeqyogsgustciuedccxazekzgmoxaxbextrcktiphwjbtfffhslzxfishinywflldkozkkamtjpcwkuhcdshfmoadlfoalpvyfktmytetiwsscckeqpppuewghuhgangabrkqkwgibulxtyegiinfpbysbatidnxiqmlduqybpsftzzduyjemfyohwruxxettnfsfdliadoehlqwwhmvkcidpxkjxhhggtnctaczmilwsbaanyzhoktyhbqkpv",66), "bffewqcx")
+  }
+
+  test("test10") {
+    assertEquals(Main.stringHash("tveaugfeecjmlzdskgaz",5), "mvih")
+  }
+
+}

high_access_employees/java_tests/Main.java

@@ -0,0 +1,24 @@
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+import java.util.List;
+import java.util.Arrays;
+public class Main {
+    //Program start
+    
+    //Program end
+
+    @Test
+public void test1() {
+    assertEquals(Arrays.asList("a"), findHighAccessEmployees(Arrays.asList(Arrays.asList("a","0549"),Arrays.asList("b","0457"),Arrays.asList("a","0532"),Arrays.asList("a","0621"),Arrays.asList("b","0540"))));
+}
+@Test
+public void test2() {
+    assertEquals(Arrays.asList("c","d"), findHighAccessEmployees(Arrays.asList(Arrays.asList("d","0002"),Arrays.asList("c","0808"),Arrays.asList("c","0829"),Arrays.asList("e","0215"),Arrays.asList("d","1508"),Arrays.asList("d","1444"),Arrays.asList("d","1410"),Arrays.asList("c","0809"))));
+}
+@Test
+public void test3() {
+    assertEquals(Arrays.asList("ab","cd"), findHighAccessEmployees(Arrays.asList(Arrays.asList("cd","1025"),Arrays.asList("ab","1025"),Arrays.asList("cd","1046"),Arrays.asList("cd","1055"),Arrays.asList("ab","1124"),Arrays.asList("ab","1120"))));
+}
+
+}

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

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

house_robber_iv/meta.json

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

house_robber_iv/ocaml_tests/main.ml

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

house_robber_iv/scala_tests/MySuite.scala

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

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

increment_submatrices_by_one/meta.json

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

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

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

intersection_of_multiple_arrays/ocaml_tests/main.ml

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

intersection_of_multiple_arrays/scala_tests/MySuite.scala

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

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

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

intervals_between_identical_elements/meta.json

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

intervals_between_identical_elements/ocaml_tests/main.ml

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

intervals_between_identical_elements/scala_tests/MySuite.scala

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

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

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

k_divisible_elements_subarrays/meta.json

@@ -0,0 +1,910 @@
+{
+    "id": 2339,
+    "name": "k_divisible_elements_subarrays",
+    "difficulty": "Medium",
+    "link": "https://leetcode.com/problems/k-divisible-elements-subarrays/",
+    "date": "1650758400000",
+    "task_description": "Given an integer array `nums` and two integers `k` and `p`, return _the number of **distinct subarrays,** which have **at most**_ `k` _elements _that are _divisible by_ `p`. Two arrays `nums1` and `nums2` are said to be **distinct** if: They are of **different** lengths, or There exists **at least** one index `i` where `nums1[i] != nums2[i]`. A **subarray** is defined as a **non-empty** contiguous sequence of elements in an array. **Example 1:** ``` **Input:** nums = [**2**,3,3,**2**,**2**], k = 2, p = 2 **Output:** 11 **Explanation:** The elements at indices 0, 3, and 4 are divisible by p = 2. The 11 distinct subarrays which have at most k = 2 elements divisible by 2 are: [2], [2,3], [2,3,3], [2,3,3,2], [3], [3,3], [3,3,2], [3,3,2,2], [3,2], [3,2,2], and [2,2]. Note that the subarrays [2] and [3] occur more than once in nums, but they should each be counted only once. The subarray [2,3,3,2,2] should not be counted because it has 3 elements that are divisible by 2. ``` **Example 2:** ``` **Input:** nums = [1,2,3,4], k = 4, p = 1 **Output:** 10 **Explanation:** All element of nums are divisible by p = 1. Also, every subarray of nums will have at most 4 elements that are divisible by 1. Since all subarrays are distinct, the total number of subarrays satisfying all the constraints is 10. ``` **Constraints:** `1 <= nums.length <= 200` `1 <= nums[i], p <= 200` `1 <= k <= nums.length` **Follow up:** Can you solve this problem in O(n2) time complexity?",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "nums = [ 2 ,3,3, 2 , 2 ], k = 2, p = 2",
+            "output": "11 "
+        },
+        {
+            "label": "Example 2",
+            "input": "nums = [1,2,3,4], k = 4, p = 1",
+            "output": "10 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                [
+                    167,
+                    70,
+                    128,
+                    58,
+                    184,
+                    186,
+                    14,
+                    71,
+                    26,
+                    45,
+                    24,
+                    25,
+                    41,
+                    2,
+                    198,
+                    54,
+                    92,
+                    95,
+                    151,
+                    55,
+                    166,
+                    194,
+                    140,
+                    24,
+                    91,
+                    158,
+                    57,
+                    8,
+                    49,
+                    28,
+                    55,
+                    131,
+                    31,
+                    164,
+                    110,
+                    142,
+                    146,
+                    91,
+                    149,
+                    162,
+                    185,
+                    172,
+                    36,
+                    178,
+                    133,
+                    176
+                ],
+                14,
+                152
+            ],
+            "output": 1078
+        },
+        {
+            "input": [
+                [
+                    64,
+                    116,
+                    128,
+                    67,
+                    47,
+                    163,
+                    153,
+                    64,
+                    148,
+                    10,
+                    73,
+                    146,
+                    33,
+                    191,
+                    61,
+                    145,
+                    154,
+                    78,
+                    14,
+                    85,
+                    1,
+                    165,
+                    171,
+                    91,
+                    36,
+                    101,
+                    5,
+                    118,
+                    40,
+                    61,
+                    180,
+                    18,
+                    198,
+                    187,
+                    164,
+                    67,
+                    43,
+                    41,
+                    180,
+                    43,
+                    150,
+                    181,
+                    8,
+                    21,
+                    191,
+                    104,
+                    20,
+                    83,
+                    78,
+                    33,
+                    15,
+                    115,
+                    159,
+                    142,
+                    92,
+                    10,
+                    135,
+                    47,
+                    68,
+                    116,
+                    46,
+                    30,
+                    80,
+                    125,
+                    65,
+                    119,
+                    85,
+                    193,
+                    194,
+                    114,
+                    137,
+                    106,
+                    74,
+                    93,
+                    24,
+                    20,
+                    145,
+                    50,
+                    142,
+                    13,
+                    107,
+                    99,
+                    168,
+                    15,
+                    152,
+                    140,
+                    155,
+                    16,
+                    92,
+                    114,
+                    155,
+                    54,
+                    141,
+                    161,
+                    118,
+                    193,
+                    105,
+                    189,
+                    172,
+                    168,
+                    188,
+                    84,
+                    57,
+                    27,
+                    68,
+                    106,
+                    177,
+                    9,
+                    134,
+                    122,
+                    32,
+                    114,
+                    25,
+                    173,
+                    1,
+                    48,
+                    13,
+                    9,
+                    88,
+                    191,
+                    171,
+                    56,
+                    87,
+                    195,
+                    165,
+                    55,
+                    104,
+                    179,
+                    148,
+                    37,
+                    9,
+                    150,
+                    173,
+                    184,
+                    178,
+                    88,
+                    173,
+                    59,
+                    81,
+                    108,
+                    195,
+                    95,
+                    175,
+                    105,
+                    63,
+                    199,
+                    179,
+                    55,
+                    101,
+                    184,
+                    172,
+                    75,
+                    148,
+                    13,
+                    23,
+                    50,
+                    19,
+                    146,
+                    11,
+                    153,
+                    176
+                ],
+                124,
+                134
+            ],
+            "output": 12991
+        },
+        {
+            "input": [
+                [
+                    55,
+                    73,
+                    9,
+                    35,
+                    36,
+                    152,
+                    184,
+                    130,
+                    128,
+                    50,
+                    159,
+                    75,
+                    125,
+                    20,
+                    45,
+                    198
+                ],
+                16,
+                18
+            ],
+            "output": 136
+        },
+        {
+            "input": [
+                [
+                    119,
+                    127,
+                    77,
+                    3,
+                    100,
+                    55,
+                    99,
+                    96,
+                    18,
+                    179,
+                    121
+                ],
+                7,
+                167
+            ],
+            "output": 66
+        },
+        {
+            "input": [
+                [
+                    163,
+                    168,
+                    140,
+                    68,
+                    140,
+                    176,
+                    160,
+                    114,
+                    141,
+                    122,
+                    168,
+                    165,
+                    162,
+                    31,
+                    2,
+                    194,
+                    149,
+                    157,
+                    143,
+                    2,
+                    176,
+                    48,
+                    12,
+                    182,
+                    144,
+                    109,
+                    34,
+                    137,
+                    48,
+                    96,
+                    61,
+                    127,
+                    189,
+                    188,
+                    178,
+                    124,
+                    155,
+                    74,
+                    94,
+                    8,
+                    73,
+                    46,
+                    158,
+                    41,
+                    150,
+                    75,
+                    81,
+                    131,
+                    189,
+                    145,
+                    58,
+                    42,
+                    142,
+                    100,
+                    126,
+                    118,
+                    191,
+                    81,
+                    132,
+                    200,
+                    58,
+                    117,
+                    170,
+                    183,
+                    41,
+                    18,
+                    33,
+                    30,
+                    76,
+                    106,
+                    82,
+                    102,
+                    9,
+                    92,
+                    44,
+                    172,
+                    81,
+                    197,
+                    92,
+                    80,
+                    165,
+                    138,
+                    46,
+                    134,
+                    147,
+                    157,
+                    28,
+                    171
+                ],
+                18,
+                177
+            ],
+            "output": 3902
+        },
+        {
+            "input": [
+                [
+                    153,
+                    24,
+                    189,
+                    40,
+                    28,
+                    139,
+                    195,
+                    168,
+                    61,
+                    98,
+                    140,
+                    52,
+                    166,
+                    132,
+                    60,
+                    180,
+                    15
+                ],
+                3,
+                82
+            ],
+            "output": 153
+        },
+        {
+            "input": [
+                [
+                    60,
+                    11,
+                    190,
+                    147,
+                    105,
+                    99,
+                    73,
+                    106,
+                    16,
+                    178,
+                    134,
+                    70,
+                    106,
+                    24,
+                    47,
+                    56,
+                    107,
+                    85,
+                    48,
+                    119,
+                    59,
+                    95,
+                    137,
+                    157,
+                    152,
+                    47,
+                    155,
+                    84,
+                    92,
+                    113,
+                    62,
+                    93,
+                    113,
+                    10,
+                    22,
+                    105,
+                    81,
+                    185,
+                    76,
+                    33,
+                    65,
+                    54,
+                    140,
+                    75,
+                    199,
+                    94,
+                    44,
+                    85,
+                    55,
+                    163,
+                    104,
+                    142,
+                    80,
+                    167,
+                    182,
+                    53,
+                    33,
+                    91,
+                    50,
+                    197,
+                    19,
+                    190,
+                    25
+                ],
+                39,
+                194
+            ],
+            "output": 2009
+        },
+        {
+            "input": [
+                [
+                    78,
+                    118,
+                    40,
+                    60,
+                    85,
+                    200,
+                    137,
+                    147,
+                    10,
+                    157,
+                    133,
+                    67,
+                    58,
+                    132,
+                    71,
+                    192,
+                    167,
+                    174,
+                    42,
+                    168,
+                    129,
+                    95,
+                    28,
+                    62,
+                    29,
+                    78,
+                    55,
+                    129,
+                    184,
+                    183,
+                    67,
+                    38,
+                    55,
+                    62,
+                    173,
+                    30,
+                    70,
+                    114,
+                    34,
+                    101,
+                    64,
+                    185,
+                    81,
+                    81,
+                    10,
+                    82,
+                    170,
+                    140,
+                    184,
+                    95,
+                    58,
+                    11,
+                    35,
+                    81,
+                    191,
+                    146,
+                    168,
+                    116,
+                    16,
+                    51,
+                    179,
+                    118,
+                    43,
+                    104,
+                    154,
+                    67,
+                    75,
+                    138,
+                    185,
+                    148,
+                    200,
+                    167,
+                    62,
+                    176,
+                    94,
+                    156,
+                    126,
+                    69,
+                    39,
+                    112,
+                    173,
+                    58,
+                    21,
+                    160,
+                    2,
+                    80,
+                    195,
+                    116,
+                    38,
+                    192,
+                    146,
+                    95,
+                    135,
+                    34,
+                    82,
+                    36,
+                    62,
+                    23,
+                    23,
+                    183,
+                    128,
+                    174,
+                    151,
+                    32,
+                    133,
+                    43,
+                    79,
+                    4,
+                    194,
+                    46,
+                    179,
+                    200,
+                    27,
+                    118,
+                    135,
+                    185,
+                    191,
+                    194,
+                    149,
+                    40,
+                    82,
+                    25,
+                    106,
+                    109,
+                    73,
+                    5,
+                    180,
+                    77,
+                    49,
+                    177,
+                    122,
+                    8,
+                    106,
+                    20,
+                    3,
+                    59,
+                    183,
+                    167,
+                    134,
+                    138,
+                    179,
+                    114,
+                    129,
+                    78,
+                    147,
+                    131,
+                    180,
+                    41
+                ],
+                108,
+                56
+            ],
+            "output": 10974
+        },
+        {
+            "input": [
+                [
+                    51,
+                    126,
+                    55,
+                    133,
+                    129,
+                    180,
+                    24,
+                    155,
+                    92,
+                    52,
+                    124,
+                    104,
+                    10,
+                    46,
+                    134,
+                    134,
+                    165,
+                    16,
+                    21,
+                    157,
+                    90,
+                    146,
+                    17,
+                    99,
+                    183,
+                    70,
+                    181,
+                    120,
+                    151,
+                    118,
+                    55,
+                    21,
+                    98,
+                    36,
+                    103,
+                    80,
+                    82,
+                    43,
+                    168,
+                    82,
+                    57,
+                    51,
+                    131,
+                    69,
+                    160,
+                    66,
+                    157,
+                    199,
+                    116,
+                    166,
+                    86,
+                    8,
+                    110,
+                    154,
+                    51,
+                    81,
+                    58,
+                    181,
+                    93,
+                    142,
+                    166,
+                    126,
+                    74,
+                    29,
+                    32,
+                    110,
+                    69,
+                    17,
+                    190,
+                    123,
+                    1,
+                    14,
+                    84,
+                    80,
+                    151,
+                    192,
+                    104,
+                    65,
+                    196,
+                    18,
+                    29,
+                    122,
+                    159,
+                    42,
+                    47,
+                    137,
+                    130,
+                    12,
+                    5,
+                    54,
+                    35,
+                    4,
+                    128,
+                    34,
+                    182,
+                    54,
+                    183,
+                    13,
+                    188,
+                    44,
+                    141,
+                    76,
+                    13,
+                    97,
+                    185,
+                    166,
+                    3,
+                    104,
+                    167,
+                    83,
+                    66,
+                    151,
+                    133,
+                    93,
+                    47,
+                    32,
+                    125,
+                    24,
+                    121,
+                    199,
+                    87,
+                    2,
+                    23,
+                    104
+                ],
+                107,
+                150
+            ],
+            "output": 7719
+        },
+        {
+            "input": [
+                [
+                    31,
+                    141,
+                    119,
+                    126,
+                    21,
+                    162,
+                    18,
+                    126,
+                    184,
+                    82,
+                    117,
+                    183,
+                    64,
+                    143,
+                    143,
+                    32,
+                    29,
+                    171,
+                    173,
+                    169,
+                    11,
+                    55,
+                    167,
+                    6,
+                    119,
+                    192,
+                    54,
+                    124,
+                    6,
+                    198,
+                    197,
+                    195,
+                    56,
+                    192,
+                    195,
+                    161,
+                    165,
+                    59,
+                    82,
+                    164,
+                    137,
+                    66,
+                    123,
+                    87,
+                    132,
+                    179,
+                    145,
+                    132,
+                    73,
+                    145,
+                    168,
+                    127,
+                    8,
+                    189,
+                    139,
+                    12,
+                    172,
+                    152,
+                    180,
+                    158,
+                    13,
+                    44,
+                    76,
+                    91,
+                    178,
+                    32,
+                    176,
+                    32,
+                    171,
+                    2,
+                    53,
+                    126,
+                    101,
+                    4,
+                    50,
+                    118,
+                    81,
+                    165,
+                    129,
+                    192,
+                    56,
+                    191,
+                    195,
+                    127,
+                    110,
+                    117,
+                    48,
+                    173,
+                    92,
+                    108,
+                    195,
+                    108,
+                    172,
+                    138,
+                    113,
+                    160,
+                    11,
+                    122,
+                    19,
+                    173,
+                    90,
+                    40,
+                    34,
+                    167,
+                    1,
+                    192,
+                    90,
+                    122,
+                    134,
+                    148,
+                    28,
+                    93,
+                    66,
+                    192,
+                    137,
+                    186,
+                    56,
+                    145,
+                    91
+                ],
+                81,
+                96
+            ],
+            "output": 7105
+        }
+    ],
+    "haskell_template": "countDistinct :: [Int] -> Int -> Int -> Int\ncountDistinct nums k p ",
+    "ocaml_template": "let countDistinct (nums: int list) (k: int) (p: int) : int =  ",
+    "scala_template": "def countDistinct(nums: List[Int],k: Int,p: Int): Int = { \n    \n}",
+    "java_template": "public static int countDistinct(List<Integer> nums, int k, int p) {\n\n}",
+    "python_template": "class Solution(object):\n    def countDistinct(self, nums, k, p):\n        \"\"\"\n        :type nums: List[int]\n        :type k: int\n        :type p: int\n        :rtype: int\n        \"\"\"\n        "
+}

k_divisible_elements_subarrays/ocaml_tests/main.ml

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

k_divisible_elements_subarrays/scala_tests/MySuite.scala

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

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

k_highest_ranked_items_within_a_price_range/java_tests/Main.java

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

k_highest_ranked_items_within_a_price_range/meta.json

@@ -0,0 +1,917 @@
+{
+    "id": 2250,
+    "name": "k_highest_ranked_items_within_a_price_range",
+    "difficulty": "Medium",
+    "link": "https://leetcode.com/problems/k-highest-ranked-items-within-a-price-range/",
+    "date": "1641600000000",
+    "task_description": "You are given a **0-indexed** 2D integer array `grid` of size `m x n` that represents a map of the items in a shop. The integers in the grid represent the following: `0` represents a wall that you cannot pass through. `1` represents an empty cell that you can freely move to and from. All other positive integers represent the price of an item in that cell. You may also freely move to and from these item cells. It takes `1` step to travel between adjacent grid cells. You are also given integer arrays `pricing` and `start` where `pricing = [low, high]` and `start = [row, col]` indicates that you start at the position `(row, col)` and are interested only in items with a price in the range of `[low, high]` (**inclusive**). You are further given an integer `k`. You are interested in the **positions** of the `k` **highest-ranked** items whose prices are **within** the given price range. The rank is determined by the **first** of these criteria that is different: Distance, defined as the length of the shortest path from the `start` (**shorter** distance has a higher rank). Price (**lower** price has a higher rank, but it must be **in the price range**). The row number (**smaller** row number has a higher rank). The column number (**smaller** column number has a higher rank). Return _the _`k`_ highest-ranked items within the price range **sorted** by their rank (highest to lowest)_. If there are fewer than `k` reachable items within the price range, return _**all** of them_. **Example 1:** ``` **Input:** grid = [[1,2,0,1],[1,3,0,1],[0,2,5,1]], pricing = [2,5], start = [0,0], k = 3 **Output:** [[0,1],[1,1],[2,1]] **Explanation:** You start at (0,0). With a price range of [2,5], we can take items from (0,1), (1,1), (2,1) and (2,2). The ranks of these items are: - (0,1) with distance 1 - (1,1) with distance 2 - (2,1) with distance 3 - (2,2) with distance 4 Thus, the 3 highest ranked items in the price range are (0,1), (1,1), and (2,1). ``` **Example 2:** ``` **Input:** grid = [[1,2,0,1],[1,3,3,1],[0,2,5,1]], pricing = [2,3], start = [2,3], k = 2 **Output:** [[2,1],[1,2]] **Explanation:** You start at (2,3). With a price range of [2,3], we can take items from (0,1), (1,1), (1,2) and (2,1). The ranks of these items are: - (2,1) with distance 2, price 2 - (1,2) with distance 2, price 3 - (1,1) with distance 3 - (0,1) with distance 4 Thus, the 2 highest ranked items in the price range are (2,1) and (1,2). ``` **Example 3:** ``` **Input:** grid = [[1,1,1],[0,0,1],[2,3,4]], pricing = [2,3], start = [0,0], k = 3 **Output:** [[2,1],[2,0]] **Explanation:** You start at (0,0). With a price range of [2,3], we can take items from (2,0) and (2,1). The ranks of these items are: - (2,1) with distance 5 - (2,0) with distance 6 Thus, the 2 highest ranked items in the price range are (2,1) and (2,0). Note that k = 3 but there are only 2 reachable items within the price range. ``` **Constraints:** `m == grid.length` `n == grid[i].length` `1 <= m, n <= 105` `1 <= m * n <= 105` `0 <= grid[i][j] <= 105` `pricing.length == 2` `2 <= low <= high <= 105` `start.length == 2` `0 <= row <= m - 1` `0 <= col <= n - 1` `grid[row][col] > 0` `1 <= k <= m * n`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "grid = [[1,2,0,1],[1,3,0,1],[0,2,5,1]], pricing = [2,5], start = [0,0], k = 3",
+            "output": "[[0,1],[1,1],[2,1]] "
+        },
+        {
+            "label": "Example 2",
+            "input": "grid = [[1,2,0,1],[1,3,3,1],[0,2,5,1]], pricing = [2,3], start = [2,3], k = 2",
+            "output": "[[2,1],[1,2]] "
+        },
+        {
+            "label": "Example 3",
+            "input": "grid = [[1,1,1],[0,0,1],[2,3,4]], pricing = [2,3], start = [0,0], k = 3",
+            "output": "[[2,1],[2,0]] "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                [
+                    [
+                        0,
+                        33,
+                        66,
+                        86,
+                        0,
+                        0,
+                        17
+                    ],
+                    [
+                        7,
+                        0,
+                        1,
+                        17,
+                        24,
+                        0,
+                        39
+                    ],
+                    [
+                        0,
+                        15,
+                        83,
+                        8,
+                        53,
+                        0,
+                        57
+                    ]
+                ],
+                [
+                    31,
+                    74
+                ],
+                [
+                    0,
+                    3
+                ],
+                12
+            ],
+            "output": [
+                [
+                    0,
+                    2
+                ],
+                [
+                    0,
+                    1
+                ],
+                [
+                    2,
+                    4
+                ]
+            ]
+        },
+        {
+            "input": [
+                [
+                    [
+                        3,
+                        0,
+                        0,
+                        26,
+                        34,
+                        0,
+                        81,
+                        39
+                    ],
+                    [
+                        97,
+                        68,
+                        0,
+                        11,
+                        65,
+                        10,
+                        9,
+                        79
+                    ],
+                    [
+                        13,
+                        98,
+                        32,
+                        18,
+                        72,
+                        0,
+                        79,
+                        75
+                    ],
+                    [
+                        0,
+                        24,
+                        70,
+                        65,
+                        58,
+                        39,
+                        78,
+                        74
+                    ],
+                    [
+                        74,
+                        35,
+                        75,
+                        48,
+                        0,
+                        0,
+                        91,
+                        76
+                    ],
+                    [
+                        77,
+                        98,
+                        91,
+                        5,
+                        18,
+                        72,
+                        0,
+                        24
+                    ]
+                ],
+                [
+                    41,
+                    74
+                ],
+                [
+                    3,
+                    4
+                ],
+                19
+            ],
+            "output": [
+                [
+                    3,
+                    4
+                ],
+                [
+                    3,
+                    3
+                ],
+                [
+                    2,
+                    4
+                ],
+                [
+                    4,
+                    3
+                ],
+                [
+                    1,
+                    4
+                ],
+                [
+                    3,
+                    2
+                ],
+                [
+                    3,
+                    7
+                ],
+                [
+                    1,
+                    1
+                ],
+                [
+                    5,
+                    5
+                ],
+                [
+                    4,
+                    0
+                ]
+            ]
+        },
+        {
+            "input": [
+                [
+                    [
+                        0,
+                        27,
+                        0,
+                        47,
+                        79,
+                        89,
+                        92,
+                        78,
+                        93,
+                        99
+                    ],
+                    [
+                        13,
+                        50,
+                        41,
+                        0,
+                        0,
+                        95,
+                        0,
+                        100,
+                        44,
+                        97
+                    ],
+                    [
+                        28,
+                        0,
+                        67,
+                        40,
+                        0,
+                        0,
+                        73,
+                        0,
+                        20,
+                        41
+                    ],
+                    [
+                        68,
+                        66,
+                        0,
+                        95,
+                        59,
+                        59,
+                        0,
+                        23,
+                        62,
+                        0
+                    ],
+                    [
+                        18,
+                        72,
+                        0,
+                        0,
+                        0,
+                        0,
+                        8,
+                        16,
+                        24,
+                        88
+                    ]
+                ],
+                [
+                    11,
+                    44
+                ],
+                [
+                    3,
+                    9
+                ],
+                4
+            ],
+            "output": [
+                [
+                    2,
+                    9
+                ],
+                [
+                    2,
+                    8
+                ],
+                [
+                    3,
+                    7
+                ],
+                [
+                    4,
+                    8
+                ]
+            ]
+        },
+        {
+            "input": [
+                [
+                    [
+                        89,
+                        5,
+                        22,
+                        0,
+                        45,
+                        98,
+                        22
+                    ],
+                    [
+                        13,
+                        56,
+                        0,
+                        95,
+                        94,
+                        12,
+                        95
+                    ],
+                    [
+                        59,
+                        0,
+                        0,
+                        0,
+                        40,
+                        90,
+                        99
+                    ],
+                    [
+                        32,
+                        86,
+                        12,
+                        3,
+                        0,
+                        95,
+                        89
+                    ],
+                    [
+                        74,
+                        47,
+                        54,
+                        29,
+                        0,
+                        2,
+                        0
+                    ],
+                    [
+                        55,
+                        19,
+                        77,
+                        0,
+                        7,
+                        69,
+                        30
+                    ],
+                    [
+                        61,
+                        22,
+                        0,
+                        0,
+                        62,
+                        37,
+                        88
+                    ],
+                    [
+                        0,
+                        0,
+                        75,
+                        0,
+                        40,
+                        97,
+                        0
+                    ],
+                    [
+                        0,
+                        61,
+                        45,
+                        0,
+                        34,
+                        0,
+                        0
+                    ]
+                ],
+                [
+                    34,
+                    91
+                ],
+                [
+                    2,
+                    2
+                ],
+                35
+            ],
+            "output": [
+                [
+                    4,
+                    2
+                ],
+                [
+                    3,
+                    1
+                ],
+                [
+                    4,
+                    1
+                ],
+                [
+                    5,
+                    2
+                ],
+                [
+                    2,
+                    0
+                ],
+                [
+                    4,
+                    0
+                ],
+                [
+                    5,
+                    0
+                ],
+                [
+                    1,
+                    1
+                ],
+                [
+                    6,
+                    0
+                ],
+                [
+                    0,
+                    0
+                ]
+            ]
+        },
+        {
+            "input": [
+                [
+                    [
+                        37,
+                        44
+                    ],
+                    [
+                        77,
+                        0
+                    ],
+                    [
+                        0,
+                        43
+                    ],
+                    [
+                        21,
+                        79
+                    ],
+                    [
+                        42,
+                        30
+                    ],
+                    [
+                        0,
+                        90
+                    ],
+                    [
+                        22,
+                        71
+                    ]
+                ],
+                [
+                    8,
+                    44
+                ],
+                [
+                    0,
+                    0
+                ],
+                3
+            ],
+            "output": [
+                [
+                    0,
+                    0
+                ],
+                [
+                    0,
+                    1
+                ]
+            ]
+        },
+        {
+            "input": [
+                [
+                    [
+                        0,
+                        58,
+                        98,
+                        2,
+                        0,
+                        42,
+                        0,
+                        9
+                    ],
+                    [
+                        45,
+                        49,
+                        10,
+                        0,
+                        53,
+                        13,
+                        0,
+                        40
+                    ],
+                    [
+                        0,
+                        26,
+                        81,
+                        52,
+                        0,
+                        79,
+                        21,
+                        73
+                    ],
+                    [
+                        14,
+                        29,
+                        98,
+                        0,
+                        66,
+                        17,
+                        28,
+                        16
+                    ]
+                ],
+                [
+                    19,
+                    93
+                ],
+                [
+                    1,
+                    3
+                ],
+                7
+            ],
+            "output": [
+                [
+                    2,
+                    3
+                ],
+                [
+                    1,
+                    4
+                ],
+                [
+                    1,
+                    1
+                ],
+                [
+                    2,
+                    2
+                ],
+                [
+                    2,
+                    1
+                ],
+                [
+                    0,
+                    5
+                ],
+                [
+                    1,
+                    0
+                ]
+            ]
+        },
+        {
+            "input": [
+                [
+                    [
+                        62,
+                        34,
+                        23,
+                        88,
+                        0,
+                        90,
+                        0,
+                        5,
+                        19,
+                        0
+                    ],
+                    [
+                        0,
+                        0,
+                        0,
+                        33,
+                        4,
+                        0,
+                        69,
+                        48,
+                        80,
+                        0
+                    ],
+                    [
+                        96,
+                        0,
+                        93,
+                        0,
+                        0,
+                        0,
+                        66,
+                        0,
+                        60,
+                        24
+                    ],
+                    [
+                        58,
+                        87,
+                        31,
+                        9,
+                        43,
+                        20,
+                        5,
+                        82,
+                        23,
+                        0
+                    ],
+                    [
+                        4,
+                        45,
+                        15,
+                        8,
+                        44,
+                        76,
+                        47,
+                        62,
+                        0,
+                        2
+                    ],
+                    [
+                        58,
+                        33,
+                        66,
+                        73,
+                        0,
+                        77,
+                        80,
+                        39,
+                        0,
+                        12
+                    ]
+                ],
+                [
+                    9,
+                    64
+                ],
+                [
+                    2,
+                    4
+                ],
+                45
+            ],
+            "output": [
+                [
+                    3,
+                    4
+                ],
+                [
+                    3,
+                    3
+                ],
+                [
+                    3,
+                    5
+                ],
+                [
+                    1,
+                    3
+                ],
+                [
+                    4,
+                    4
+                ],
+                [
+                    3,
+                    2
+                ],
+                [
+                    4,
+                    2
+                ],
+                [
+                    0,
+                    2
+                ],
+                [
+                    4,
+                    6
+                ],
+                [
+                    3,
+                    8
+                ],
+                [
+                    0,
+                    1
+                ],
+                [
+                    4,
+                    1
+                ],
+                [
+                    3,
+                    0
+                ],
+                [
+                    4,
+                    7
+                ],
+                [
+                    5,
+                    1
+                ],
+                [
+                    5,
+                    7
+                ],
+                [
+                    1,
+                    7
+                ],
+                [
+                    2,
+                    8
+                ],
+                [
+                    0,
+                    0
+                ],
+                [
+                    2,
+                    9
+                ],
+                [
+                    5,
+                    0
+                ],
+                [
+                    0,
+                    8
+                ]
+            ]
+        },
+        {
+            "input": [
+                [
+                    [
+                        0,
+                        0,
+                        11,
+                        0,
+                        0,
+                        23,
+                        0,
+                        0,
+                        44,
+                        18
+                    ]
+                ],
+                [
+                    48,
+                    92
+                ],
+                [
+                    0,
+                    5
+                ],
+                4
+            ],
+            "output": []
+        },
+        {
+            "input": [
+                [
+                    [
+                        0,
+                        32,
+                        44,
+                        51,
+                        2,
+                        98
+                    ]
+                ],
+                [
+                    43,
+                    52
+                ],
+                [
+                    0,
+                    5
+                ],
+                2
+            ],
+            "output": [
+                [
+                    0,
+                    3
+                ],
+                [
+                    0,
+                    2
+                ]
+            ]
+        },
+        {
+            "input": [
+                [
+                    [
+                        0,
+                        0,
+                        48,
+                        33,
+                        7,
+                        3
+                    ],
+                    [
+                        99,
+                        0,
+                        0,
+                        71,
+                        1,
+                        0
+                    ],
+                    [
+                        0,
+                        0,
+                        10,
+                        0,
+                        0,
+                        87
+                    ],
+                    [
+                        89,
+                        69,
+                        66,
+                        20,
+                        72,
+                        35
+                    ],
+                    [
+                        15,
+                        0,
+                        100,
+                        0,
+                        88,
+                        31
+                    ],
+                    [
+                        38,
+                        0,
+                        68,
+                        73,
+                        14,
+                        32
+                    ],
+                    [
+                        99,
+                        27,
+                        86,
+                        71,
+                        98,
+                        86
+                    ],
+                    [
+                        49,
+                        60,
+                        21,
+                        81,
+                        3,
+                        95
+                    ],
+                    [
+                        62,
+                        0,
+                        0,
+                        0,
+                        97,
+                        65
+                    ],
+                    [
+                        89,
+                        69,
+                        33,
+                        6,
+                        92,
+                        80
+                    ]
+                ],
+                [
+                    5,
+                    12
+                ],
+                [
+                    7,
+                    3
+                ],
+                57
+            ],
+            "output": [
+                [
+                    9,
+                    3
+                ],
+                [
+                    2,
+                    2
+                ]
+            ]
+        }
+    ],
+    "haskell_template": "highestRankedKItems :: [[Int]] -> [Int] -> [Int] -> Int -> [[Int]]\nhighestRankedKItems grid pricing start k ",
+    "ocaml_template": "let highestRankedKItems (grid: int list list) (pricing: int list) (start: int list) (k: int) : int list list =  ",
+    "scala_template": "def highestRankedKItems(grid: List[List[Int]],pricing: List[Int],start: List[Int],k: Int): List[List[Int]] = { \n    \n}",
+    "java_template": "public static List<List<Integer>> highestRankedKItems(List<List<Integer>> grid, List<Integer> pricing, List<Integer> start, int k) {\n\n}",
+    "python_template": "class Solution(object):\n    def highestRankedKItems(self, grid, pricing, start, k):\n        \"\"\"\n        :type grid: List[List[int]]\n        :type pricing: List[int]\n        :type start: List[int]\n        :type k: int\n        :rtype: List[List[int]]\n        \"\"\"\n        "
+}

k_highest_ranked_items_within_a_price_range/ocaml_tests/main.ml

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

k_highest_ranked_items_within_a_price_range/scala_tests/MySuite.scala

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

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

k_items_with_the_maximum_sum/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, kItemsWithMaximumSum(3, 2, 0, 2));
+}
+@Test
+public void test2() {
+    assertEquals(3, kItemsWithMaximumSum(3, 2, 0, 4));
+}
+
+}

k_items_with_the_maximum_sum/meta.json

@@ -0,0 +1,117 @@
+{
+    "id": 2715,
+    "name": "k_items_with_the_maximum_sum",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/k-items-with-the-maximum-sum/",
+    "date": "1679184000000",
+    "task_description": "There is a bag that consists of items, each item has a number `1`, `0`, or `-1` written on it. You are given four **non-negative **integers `numOnes`, `numZeros`, `numNegOnes`, and `k`. The bag initially contains: `numOnes` items with `1`s written on them. `numZeroes` items with `0`s written on them. `numNegOnes` items with `-1`s written on them. We want to pick exactly `k` items among the available items. Return _the **maximum** possible sum of numbers written on the items_. **Example 1:** ``` **Input:** numOnes = 3, numZeros = 2, numNegOnes = 0, k = 2 **Output:** 2 **Explanation:** We have a bag of items with numbers written on them {1, 1, 1, 0, 0}. We take 2 items with 1 written on them and get a sum in a total of 2. It can be proven that 2 is the maximum possible sum. ``` **Example 2:** ``` **Input:** numOnes = 3, numZeros = 2, numNegOnes = 0, k = 4 **Output:** 3 **Explanation:** We have a bag of items with numbers written on them {1, 1, 1, 0, 0}. We take 3 items with 1 written on them, and 1 item with 0 written on it, and get a sum in a total of 3. It can be proven that 3 is the maximum possible sum. ``` **Constraints:** `0 <= numOnes, numZeros, numNegOnes <= 50` `0 <= k <= numOnes + numZeros + numNegOnes`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "numOnes = 3, numZeros = 2, numNegOnes = 0, k = 2",
+            "output": "2 "
+        },
+        {
+            "label": "Example 2",
+            "input": "numOnes = 3, numZeros = 2, numNegOnes = 0, k = 4",
+            "output": "3 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                31,
+                26,
+                16,
+                7
+            ],
+            "output": 7
+        },
+        {
+            "input": [
+                11,
+                42,
+                34,
+                77
+            ],
+            "output": -13
+        },
+        {
+            "input": [
+                23,
+                23,
+                3,
+                22
+            ],
+            "output": 22
+        },
+        {
+            "input": [
+                46,
+                32,
+                24,
+                85
+            ],
+            "output": 39
+        },
+        {
+            "input": [
+                36,
+                38,
+                14,
+                7
+            ],
+            "output": 7
+        },
+        {
+            "input": [
+                18,
+                18,
+                33,
+                10
+            ],
+            "output": 10
+        },
+        {
+            "input": [
+                41,
+                10,
+                33,
+                55
+            ],
+            "output": 37
+        },
+        {
+            "input": [
+                18,
+                22,
+                13,
+                3
+            ],
+            "output": 3
+        },
+        {
+            "input": [
+                44,
+                43,
+                32,
+                119
+            ],
+            "output": 12
+        },
+        {
+            "input": [
+                33,
+                35,
+                20,
+                26
+            ],
+            "output": 26
+        }
+    ],
+    "haskell_template": "kItemsWithMaximumSum :: Int -> Int -> Int -> Int -> Int\nkItemsWithMaximumSum numOnes numZeros numNegOnes k ",
+    "ocaml_template": "let kItemsWithMaximumSum (numOnes: int) (numZeros: int) (numNegOnes: int) (k: int) : int =  ",
+    "scala_template": "def kItemsWithMaximumSum(numOnes: Int,numZeros: Int,numNegOnes: Int,k: Int): Int = { \n    \n}",
+    "java_template": "public static int kItemsWithMaximumSum(int numOnes, int numZeros, int numNegOnes, int k) {\n\n}",
+    "python_template": "class Solution(object):\n    def kItemsWithMaximumSum(self, numOnes, numZeros, numNegOnes, k):\n        \"\"\"\n        :type numOnes: int\n        :type numZeros: int\n        :type numNegOnes: int\n        :type k: int\n        :rtype: int\n        \"\"\"\n        "
+}

k_items_with_the_maximum_sum/ocaml_tests/main.ml

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

k_items_with_the_maximum_sum/scala_tests/MySuite.scala

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