ee6dde840dcc10881743f1bf0b2a5f4bcb7e3d5bb1904794b22863e0226926d3

.gitattributes

@@ -118,3 +118,5 @@ find_building_where_alice_and_bob_can_meet/haskell_tests/Main.hs filter=lfs diff
 find_building_where_alice_and_bob_can_meet/meta.json filter=lfs diff=lfs merge=lfs -text
 find_closest_node_to_given_two_nodes/meta.json filter=lfs diff=lfs merge=lfs -text
 find_indices_with_index_and_value_difference_ii/meta.json filter=lfs diff=lfs merge=lfs -text
+find_number_of_coins_to_place_in_tree_nodes/meta.json filter=lfs diff=lfs merge=lfs -text
+find_occurrences_of_an_element_in_an_array/meta.json filter=lfs diff=lfs merge=lfs -text

find_mirror_score_of_a_string/ocaml_tests/main.ml

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

find_mirror_score_of_a_string/scala_tests/MySuite.scala

@@ -0,0 +1,16 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.calculateScore("aczzx"), 5)
+  }
+
+  test("test2") {
+    assertEquals(Main.calculateScore("abcdef"), 0)
+  }
+
+  test("test3") {
+    assertEquals(Main.calculateScore(",n,"), 0)
+  }
+
+}

find_missing_and_repeated_values/haskell_tests/Main.hs

@@ -0,0 +1,26 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+findMissingAndRepeatedValues :: [[Int]] -> [Int]
+findMissingAndRepeatedValues grid = undefined
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (findMissingAndRepeatedValues [[1,3],[2,2]])," [2,4] (findMissingAndRepeatedValues [[1,3],[2,2]]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (findMissingAndRepeatedValues [[9,1,7],[8,9,2],[3,4,6]])," [9,5] (findMissingAndRepeatedValues [[9,1,7],[8,9,2],[3,4,6]]))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

find_missing_and_repeated_values/java_tests/Main.java

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

find_missing_and_repeated_values/meta.json

@@ -0,0 +1,26 @@
+{
+    "id": 3227,
+    "name": "find_missing_and_repeated_values",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/find-missing-and-repeated-values/",
+    "date": "2023-12-10 00:00:00",
+    "task_description": "You are given a **0-indexed** 2D integer matrix `grid` of size `n * n` with values in the range `[1, n2]`. Each integer appears **exactly once** except `a` which appears **twice** and `b` which is **missing**. The task is to find the repeating and missing numbers `a` and `b`. Return _a **0-indexed **integer array _`ans`_ of size _`2`_ where _`ans[0]`_ equals to _`a`_ and _`ans[1]`_ equals to _`b`_._ **Example 1:** ``` **Input:** grid = [[1,3],[2,2]] **Output:** [2,4] **Explanation:** Number 2 is repeated and number 4 is missing so the answer is [2,4]. ``` **Example 2:** ``` **Input:** grid = [[9,1,7],[8,9,2],[3,4,6]] **Output:** [9,5] **Explanation:** Number 9 is repeated and number 5 is missing so the answer is [9,5]. ``` **Constraints:** `2 <= n == grid.length == grid[i].length <= 50` `1 <= grid[i][j] <= n * n` For all `x` that `1 <= x <= n * n` there is exactly one `x` that is not equal to any of the grid members. For all `x` that `1 <= x <= n * n` there is exactly one `x` that is equal to exactly two of the grid members. For all `x` that `1 <= x <= n * n` except two of them there is exactly one pair of `i, j` that `0 <= i, j <= n - 1` and `grid[i][j] == x`.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "grid = [[1,3],[2,2]]",
+            "output": "[2,4] "
+        },
+        {
+            "label": "Example 2",
+            "input": "grid = [[9,1,7],[8,9,2],[3,4,6]]",
+            "output": "[9,5] "
+        }
+    ],
+    "private_test_cases": [],
+    "haskell_template": "findMissingAndRepeatedValues :: [[Int]] -> [Int]\nfindMissingAndRepeatedValues grid ",
+    "ocaml_template": "let findMissingAndRepeatedValues (grid: int list list) : int list =  ",
+    "scala_template": "def findMissingAndRepeatedValues(grid: List[List[Int]]): List[Int] = { \n    \n}",
+    "java_template": "class Solution {\n    public int[] findMissingAndRepeatedValues(int[][] grid) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def findMissingAndRepeatedValues(self, grid):\n        \"\"\"\n        :type grid: List[List[int]]\n        :rtype: List[int]\n        \"\"\"\n        "
+}

find_missing_and_repeated_values/ocaml_tests/main.ml

@@ -0,0 +1,27 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+    let findMissingAndRepeatedValues (grid: int list list) : int list =   failwith "Not implemented"
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal [2;4] (findMissingAndRepeatedValues [[1;3];[2;2]])
+
+let test2 _ = assert_equal [9;5] (findMissingAndRepeatedValues [[9;1;7];[8;9;2];[3;4;6]])
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for findMissingAndRepeatedValues" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

find_missing_and_repeated_values/scala_tests/MySuite.scala

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

find_number_of_coins_to_place_in_tree_nodes/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(120,1,1,1,1,1)), placedCoins(new ArrayList<>(Arrays.asList(new ArrayList<>(Arrays.asList(0,1)),new ArrayList<>(Arrays.asList(0,2)),new ArrayList<>(Arrays.asList(0,3)),new ArrayList<>(Arrays.asList(0,4)),new ArrayList<>(Arrays.asList(0,5)))), new ArrayList<>(Arrays.asList(1,2,3,4,5,6))));
+}
+@Test
+public void test2() {
+    assertEquals(new ArrayList<>(Arrays.asList(280,140,32,1,1,1,1,1,1)), placedCoins(new ArrayList<>(Arrays.asList(new ArrayList<>(Arrays.asList(0,1)),new ArrayList<>(Arrays.asList(0,2)),new ArrayList<>(Arrays.asList(1,3)),new ArrayList<>(Arrays.asList(1,4)),new ArrayList<>(Arrays.asList(1,5)),new ArrayList<>(Arrays.asList(2,6)),new ArrayList<>(Arrays.asList(2,7)),new ArrayList<>(Arrays.asList(2,8)))), new ArrayList<>(Arrays.asList(1,4,2,3,5,7,8,-4,2))));
+}
+@Test
+public void test3() {
+    assertEquals(new ArrayList<>(Arrays.asList(0,1,1)), placedCoins(new ArrayList<>(Arrays.asList(new ArrayList<>(Arrays.asList(0,1)),new ArrayList<>(Arrays.asList(0,2)))), new ArrayList<>(Arrays.asList(1,2,-2))));
+}
+
+}

find_number_of_coins_to_place_in_tree_nodes/meta.json

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

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

find_occurrences_of_an_element_in_an_array/meta.json

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

find_polygon_with_the_largest_perimeter/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(15, largestPerimeter(Arrays.asList(5,5,5)));
+}
+@Test
+public void test2() {
+    assertEquals(12, largestPerimeter(Arrays.asList(1,12,1,2,5,50,3)));
+}
+@Test
+public void test3() {
+    assertEquals(-1, largestPerimeter(Arrays.asList(5,5,50)));
+}
+
+}

find_products_of_elements_of_big_array/haskell_tests/Main.hs

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

find_products_of_elements_of_big_array/java_tests/Main.java

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

find_products_of_elements_of_big_array/meta.json

@@ -0,0 +1,26 @@
+{
+    "id": 3411,
+    "name": "find_products_of_elements_of_big_array",
+    "difficulty": "Hard",
+    "link": "https://leetcode.com/problems/find-products-of-elements-of-big-array/",
+    "date": "2024-04-27 00:00:00",
+    "task_description": "The **powerful array** of a non-negative integer `x` is defined as the shortest sorted array of powers of two that sum up to `x`. The table below illustrates examples of how the **powerful array** is determined. It can be proven that the powerful array of `x` is unique. num Binary Representation powerful array 1 00001 [1] 8 01000 [8] 10 01010 [2, 8] 13 01101 [1, 4, 8] 23 10111 [1, 2, 4, 16] The array `big_nums` is created by concatenating the **powerful arrays** for every positive integer `i` in ascending order: 1, 2, 3, and so on. Thus, `big_nums` begins as `[1, 2, 1, 2, 4, 1, 4, 2, 4, 1, 2, 4, 8, ...]`. You are given a 2D integer matrix `queries`, where for `queries[i] = [fromi, toi, modi]` you should calculate `(big_nums[fromi] * big_nums[fromi + 1] * ... * big_nums[toi]) % modi`. Return an integer array `answer` such that `answer[i]` is the answer to the `ith` query. **Example 1:** **Input:** queries = [[1,3,7]] **Output:** [4] **Explanation:** There is one query. `big_nums[1..3] = [2,1,2]`. The product of them is 4. The result is `4 % 7 = 4.` **Example 2:** **Input:** queries = [[2,5,3],[7,7,4]] **Output:** [2,2] **Explanation:** There are two queries. First query: `big_nums[2..5] = [1,2,4,1]`. The product of them is 8. The result is `8 % 3 = 2`. Second query: `big_nums[7] = 2`. The result is `2 % 4 = 2`. **Constraints:** `1 <= queries.length <= 500` `queries[i].length == 3` `0 <= queries[i][0] <= queries[i][1] <= 1015` `1 <= queries[i][2] <= 105`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "queries = [[1,3,7]]",
+            "output": "[4] "
+        },
+        {
+            "label": "Example 2",
+            "input": "queries = [[2,5,3],[7,7,4]]",
+            "output": "[2,2] "
+        }
+    ],
+    "private_test_cases": [],
+    "haskell_template": "findProductsOfElements :: [[Int]] -> [Int]\nfindProductsOfElements queries ",
+    "ocaml_template": "let findProductsOfElements (queries: int list list) : int list =  ",
+    "scala_template": "def findProductsOfElements(queries: List[List[Int]]): List[Int] = { \n    \n}",
+    "java_template": "class Solution {\n    public int[] findProductsOfElements(long[][] queries) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def findProductsOfElements(self, queries):\n        \"\"\"\n        :type queries: List[List[int]]\n        :rtype: List[int]\n        \"\"\"\n        "
+}

find_products_of_elements_of_big_array/ocaml_tests/main.ml

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

find_products_of_elements_of_big_array/scala_tests/MySuite.scala

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

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

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

find_score_of_an_array_after_marking_all_elements/meta.json

@@ -0,0 +1,26 @@
+{
+    "id": 2695,
+    "name": "find_score_of_an_array_after_marking_all_elements",
+    "difficulty": "Medium",
+    "link": "https://leetcode.com/problems/find-score-of-an-array-after-marking-all-elements/",
+    "date": "1677888000000",
+    "task_description": "You are given an array `nums` consisting of positive integers. Starting with `score = 0`, apply the following algorithm: Choose the smallest integer of the array that is not marked. If there is a tie, choose the one with the smallest index. Add the value of the chosen integer to `score`. Mark **the chosen element and its two adjacent elements if they exist**. Repeat until all the array elements are marked. Return _the score you get after applying the above algorithm_. **Example 1:** ``` **Input:** nums = [2,1,3,4,5,2] **Output:** 7 **Explanation:** We mark the elements as follows: - 1 is the smallest unmarked element, so we mark it and its two adjacent elements: [2,1,3,4,5,2]. - 2 is the smallest unmarked element, so we mark it and its left adjacent element: [2,1,3,4,5,2]. - 4 is the only remaining unmarked element, so we mark it: [2,1,3,4,5,2]. Our score is 1 + 2 + 4 = 7. ``` **Example 2:** ``` **Input:** nums = [2,3,5,1,3,2] **Output:** 5 **Explanation:** We mark the elements as follows: - 1 is the smallest unmarked element, so we mark it and its two adjacent elements: [2,3,5,1,3,2]. - 2 is the smallest unmarked element, since there are two of them, we choose the left-most one, so we mark the one at index 0 and its right adjacent element: [2,3,5,1,3,2]. - 2 is the only remaining unmarked element, so we mark it: [2,3,5,1,3,2]. Our score is 1 + 2 + 2 = 5. ``` **Constraints:** `1 <= nums.length <= 105` `1 <= nums[i] <= 106`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "nums = [2,1,3,4,5,2]",
+            "output": "7 "
+        },
+        {
+            "label": "Example 2",
+            "input": "nums = [2,3,5,1,3,2]",
+            "output": "5 "
+        }
+    ],
+    "private_test_cases": [],
+    "haskell_template": "findScore :: [Int] -> Int\nfindScore nums ",
+    "ocaml_template": "let findScore (nums: int list) : int =  ",
+    "scala_template": "def findScore(nums: List[Int]): Int = { \n    \n}",
+    "java_template": "public static int findScore(List<Integer> nums) {\n\n}",
+    "python_template": "class Solution(object):\n    def findScore(self, nums):\n        \"\"\"\n        :type nums: List[int]\n        :rtype: int\n        \"\"\"\n        "
+}

find_score_of_an_array_after_marking_all_elements/ocaml_tests/main.ml

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

find_score_of_an_array_after_marking_all_elements/scala_tests/MySuite.scala

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

find_special_substring_of_length_k/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 (hasSpecialSubstring \"aaabaaa \" 3)," True (hasSpecialSubstring "aaabaaa" 3))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (hasSpecialSubstring \"abc \" 2)," False (hasSpecialSubstring "abc" 2))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (hasSpecialSubstring  \"npiqeyedtwkxpacknwmuiqjwfcjoaspqjjrkedlpsecmlbdzjhmmadyuffboureyfg \" 8)," False (hasSpecialSubstring "npiqeyedtwkxpacknwmuiqjwfcjoaspqjjrkedlpsecmlbdzjhmmadyuffboureyfg" 8))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (hasSpecialSubstring  \"frfibfvbjbembzqmpygdsutmdnefweotbbutvihqaodnvkhlovtyhvgksijkrvqclikuzdgjee \" 53)," False (hasSpecialSubstring "frfibfvbjbembzqmpygdsutmdnefweotbbutvihqaodnvkhlovtyhvgksijkrvqclikuzdgjee" 53))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (hasSpecialSubstring  \"ow \" 2)," False (hasSpecialSubstring "ow" 2))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (hasSpecialSubstring  \"kcbgeeldqbijcfbfwkxjtzrrgvcplhftpaz \" 10)," False (hasSpecialSubstring "kcbgeeldqbijcfbfwkxjtzrrgvcplhftpaz" 10))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (hasSpecialSubstring  \"puvexiblpdkdberrcjucrehjrzizyobtittk \" 15)," False (hasSpecialSubstring "puvexiblpdkdberrcjucrehjrzizyobtittk" 15))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (hasSpecialSubstring  \"nbmzvrvoljbqwtwmj \" 1)," True (hasSpecialSubstring "nbmzvrvoljbqwtwmj" 1))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (hasSpecialSubstring  \"laluchhncipksfyucufozhrkflsrbeqkrnrvyiaihwkptuiquycoxfpmelchzdciilupqsdaqkkyjnkzdyejhatdzjdcco \" 61)," False (hasSpecialSubstring "laluchhncipksfyucufozhrkflsrbeqkrnrvyiaihwkptuiquycoxfpmelchzdciilupqsdaqkkyjnkzdyejhatdzjdcco" 61))
+
+
+-- 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

find_special_substring_of_length_k/java_tests/Main.java

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

find_special_substring_of_length_k/meta.json

@@ -0,0 +1,97 @@
+{
+    "id": 3709,
+    "name": "find_special_substring_of_length_k",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/find-special-substring-of-length-k/",
+    "date": "2025-02-09 00:00:00",
+    "task_description": "You are given a string `s` and an integer `k`. Determine if there exists a substring of length **exactly** `k` in `s` that satisfies the following conditions: The substring consists of **only one distinct character** (e.g., `\"aaa\"` or `\"bbb\"`). If there is a character **immediately before** the substring, it must be different from the character in the substring. If there is a character **immediately after** the substring, it must also be different from the character in the substring. Return `true` if such a substring exists. Otherwise, return `false`. **Example 1:** **Input:** s = \"aaabaaa\", k = 3 **Output:** true **Explanation:** The substring `s[4..6] == \"aaa\"` satisfies the conditions. It has a length of 3. All characters are the same. The character before `\"aaa\"` is `'b'`, which is different from `'a'`. There is no character after `\"aaa\"`. **Example 2:** **Input:** s = \"abc\", k = 2 **Output:** false **Explanation:** There is no substring of length 2 that consists of one distinct character and satisfies the conditions. **Constraints:** `1 <= k <= s.length <= 100` `s` consists of lowercase English letters only.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "s = \"aaabaaa\", k = 3",
+            "output": "true "
+        },
+        {
+            "label": "Example 2",
+            "input": "s = \"abc\", k = 2",
+            "output": "false "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                "\"npiqeyedtwkxpacknwmuiqjwfcjoaspqjjrkedlpsecmlbdzjhmmadyuffboureyfg\"",
+                8
+            ],
+            "output": false
+        },
+        {
+            "input": [
+                "\"frfibfvbjbembzqmpygdsutmdnefweotbbutvihqaodnvkhlovtyhvgksijkrvqclikuzdgjee\"",
+                53
+            ],
+            "output": false
+        },
+        {
+            "input": [
+                "\"ow\"",
+                2
+            ],
+            "output": false
+        },
+        {
+            "input": [
+                "\"kcbgeeldqbijcfbfwkxjtzrrgvcplhftpaz\"",
+                10
+            ],
+            "output": false
+        },
+        {
+            "input": [
+                "\"puvexiblpdkdberrcjucrehjrzizyobtittk\"",
+                15
+            ],
+            "output": false
+        },
+        {
+            "input": [
+                "\"nbmzvrvoljbqwtwmj\"",
+                1
+            ],
+            "output": true
+        },
+        {
+            "input": [
+                "\"laluchhncipksfyucufozhrkflsrbeqkrnrvyiaihwkptuiquycoxfpmelchzdciilupqsdaqkkyjnkzdyejhatdzjdcco\"",
+                61
+            ],
+            "output": false
+        },
+        {
+            "input": [
+                "\"wohlljnaddwmpuwamgkiyfvtuzbpcjhlvohkrwnpaiolofylskymmeouuoztkpqbcxjuxqpkqhgjmuutdxdjmjdkwkamikp\"",
+                32
+            ],
+            "output": false
+        },
+        {
+            "input": [
+                "vzlfovuxlagnyfozvkgmnjtvgvrpfrdxvljppyqmgaclfmeyezxuzlkplyodjppbszuffvacllvhrhtxajwokdyov",
+                7
+            ],
+            "output": false
+        },
+        {
+            "input": [
+                "dgjbknmicwjojjbtmhtbfqlkssfvcmxnxvqagiwbuhjkikhxkqevbegxzwanhzulrxvve",
+                64
+            ],
+            "output": false
+        }
+    ],
+    "haskell_template": "hasSpecialSubstring :: String -> Int -> Bool\nhasSpecialSubstring s k ",
+    "ocaml_template": "let hasSpecialSubstring (s: string) (k: int) : bool =  ",
+    "scala_template": "def hasSpecialSubstring(s: String,k: Int): Boolean = { \n    \n}",
+    "java_template": "class Solution {\n    public boolean hasSpecialSubstring(String s, int k) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def hasSpecialSubstring(self, s, k):\n        \"\"\"\n        :type s: str\n        :type k: int\n        :rtype: bool\n        \"\"\"\n        "
+}

find_special_substring_of_length_k/ocaml_tests/main.ml

@@ -0,0 +1,50 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal true (hasSpecialSubstring "aaabaaa" 3)
+
+let test2 _ = assert_equal false (hasSpecialSubstring "abc" 2)
+
+let test3 _ = assert_equal false (hasSpecialSubstring "npiqeyedtwkxpacknwmuiqjwfcjoaspqjjrkedlpsecmlbdzjhmmadyuffboureyfg" 8)
+
+let test4 _ = assert_equal false (hasSpecialSubstring "frfibfvbjbembzqmpygdsutmdnefweotbbutvihqaodnvkhlovtyhvgksijkrvqclikuzdgjee" 53)
+
+let test5 _ = assert_equal false (hasSpecialSubstring "ow" 2)
+
+let test6 _ = assert_equal false (hasSpecialSubstring "kcbgeeldqbijcfbfwkxjtzrrgvcplhftpaz" 10)
+
+let test7 _ = assert_equal false (hasSpecialSubstring "puvexiblpdkdberrcjucrehjrzizyobtittk" 15)
+
+let test8 _ = assert_equal true (hasSpecialSubstring "nbmzvrvoljbqwtwmj" 1)
+
+let test9 _ = assert_equal false (hasSpecialSubstring "laluchhncipksfyucufozhrkflsrbeqkrnrvyiaihwkptuiquycoxfpmelchzdciilupqsdaqkkyjnkzdyejhatdzjdcco" 61)
+
+let test10 _ = assert_equal false (hasSpecialSubstring "wohlljnaddwmpuwamgkiyfvtuzbpcjhlvohkrwnpaiolofylskymmeouuoztkpqbcxjuxqpkqhgjmuutdxdjmjdkwkamikp" 32)
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for hasSpecialSubstring" >::: [
+        
+  "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

find_special_substring_of_length_k/scala_tests/MySuite.scala

@@ -0,0 +1,44 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.hasSpecialSubstring("aaabaaa",3), true)
+  }
+
+  test("test2") {
+    assertEquals(Main.hasSpecialSubstring("abc",2), false)
+  }
+
+  test("test3") {
+    assertEquals(Main.hasSpecialSubstring("npiqeyedtwkxpacknwmuiqjwfcjoaspqjjrkedlpsecmlbdzjhmmadyuffboureyfg",8), false)
+  }
+
+  test("test4") {
+    assertEquals(Main.hasSpecialSubstring("frfibfvbjbembzqmpygdsutmdnefweotbbutvihqaodnvkhlovtyhvgksijkrvqclikuzdgjee",53), false)
+  }
+
+  test("test5") {
+    assertEquals(Main.hasSpecialSubstring("ow",2), false)
+  }
+
+  test("test6") {
+    assertEquals(Main.hasSpecialSubstring("kcbgeeldqbijcfbfwkxjtzrrgvcplhftpaz",10), false)
+  }
+
+  test("test7") {
+    assertEquals(Main.hasSpecialSubstring("puvexiblpdkdberrcjucrehjrzizyobtittk",15), false)
+  }
+
+  test("test8") {
+    assertEquals(Main.hasSpecialSubstring("nbmzvrvoljbqwtwmj",1), true)
+  }
+
+  test("test9") {
+    assertEquals(Main.hasSpecialSubstring("laluchhncipksfyucufozhrkflsrbeqkrnrvyiaihwkptuiquycoxfpmelchzdciilupqsdaqkkyjnkzdyejhatdzjdcco",61), false)
+  }
+
+  test("test10") {
+    assertEquals(Main.hasSpecialSubstring("wohlljnaddwmpuwamgkiyfvtuzbpcjhlvohkrwnpaiolofylskymmeouuoztkpqbcxjuxqpkqhgjmuutdxdjmjdkwkamikp",32), false)
+  }
+
+}

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

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

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

find_subarrays_with_equal_sum/ocaml_tests/main.ml

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

find_subarrays_with_equal_sum/scala_tests/MySuite.scala

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