d626876cf072af0b6013a204ca3af7b22fd6e14b0b49e196df4e4b44ef5e012d

.gitattributes

@@ -85,3 +85,5 @@ count_subarrays_where_max_element_appears_at_least_k_times/meta.json filter=lfs
 count_subarrays_with_score_less_than_k/meta.json filter=lfs diff=lfs merge=lfs -text
 count_submatrices_with_equal_frequency_of_x_and_y/haskell_tests/Main.hs filter=lfs diff=lfs merge=lfs -text
 count_submatrices_with_equal_frequency_of_x_and_y/meta.json filter=lfs diff=lfs merge=lfs -text
+count_substrings_that_satisfy_k_constraint_ii/haskell_tests/Main.hs filter=lfs diff=lfs merge=lfs -text
+count_substrings_that_satisfy_k_constraint_ii/meta.json filter=lfs diff=lfs merge=lfs -text

count_submatrices_with_top_left_element_and_sum_less_than_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(4, countSubmatrices(new ArrayList<>(Arrays.asList(new ArrayList<>(Arrays.asList(7,6,3)),new ArrayList<>(Arrays.asList(6,6,1)))), 18));
+}
+@Test
+public void test2() {
+    assertEquals(6, countSubmatrices(new ArrayList<>(Arrays.asList(new ArrayList<>(Arrays.asList(7,2,9)),new ArrayList<>(Arrays.asList(1,5,0)),new ArrayList<>(Arrays.asList(2,6,6)))), 20));
+}
+
+}

count_substrings_divisible_by_last_digit/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(11, countSubstrings("12936"));
+}
+@Test
+public void test2() {
+    assertEquals(18, countSubstrings("5701283"));
+}
+@Test
+public void test3() {
+    assertEquals(25, countSubstrings("1010101010"));
+}
+
+}

count_substrings_starting_and_ending_with_given_character/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(6, countSubstrings("abada", "a"));
+}
+@Test
+public void test2() {
+    assertEquals(6, countSubstrings("zzz", "z"));
+}
+
+}

count_substrings_that_can_be_rearranged_to_contain_a_string_ii/java_tests/Main.java

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

count_substrings_that_satisfy_k_constraint_i/haskell_tests/Main.hs

@@ -0,0 +1,45 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (countKConstraintSubstrings \"10101 \" 1)," 12 (countKConstraintSubstrings "10101" 1))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (countKConstraintSubstrings \"1010101 \" 2)," 25 (countKConstraintSubstrings "1010101" 2))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (countKConstraintSubstrings \"11111 \" 1)," 15 (countKConstraintSubstrings "11111" 1))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (countKConstraintSubstrings  \"11 \" 2)," 3 (countKConstraintSubstrings "11" 2))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (countKConstraintSubstrings  \"1 \" 1)," 1 (countKConstraintSubstrings "1" 1))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (countKConstraintSubstrings  \"1011100110011101110000000101111110001 \" 36)," 703 (countKConstraintSubstrings "1011100110011101110000000101111110001" 36))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (countKConstraintSubstrings  \"1111100100000100001110110001001110110011110 \" 33)," 946 (countKConstraintSubstrings "1111100100000100001110110001001110110011110" 33))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (countKConstraintSubstrings  \"011010011 \" 5)," 45 (countKConstraintSubstrings "011010011" 5))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (countKConstraintSubstrings  \"011111100010010111111100010100000101110111101110 \" 9)," 782 (countKConstraintSubstrings "011111100010010111111100010100000101110111101110" 9))
+
+
+-- 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

count_substrings_that_satisfy_k_constraint_i/java_tests/Main.java

@@ -0,0 +1,25 @@
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+import java.util.List;
+import java.util.Arrays;
+import java.util.ArrayList;
+public class Main {
+    //Program start
+    
+    //Program end
+
+    @Test
+public void test1() {
+    assertEquals(12, countKConstraintSubstrings("10101", 1));
+}
+@Test
+public void test2() {
+    assertEquals(25, countKConstraintSubstrings("1010101", 2));
+}
+@Test
+public void test3() {
+    assertEquals(15, countKConstraintSubstrings("11111", 1));
+}
+
+}

count_substrings_that_satisfy_k_constraint_i/meta.json

@@ -0,0 +1,102 @@
+{
+    "id": 3543,
+    "name": "count_substrings_that_satisfy_k_constraint_i",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/count-substrings-that-satisfy-k-constraint-i/",
+    "date": "2024-08-11 00:00:00",
+    "task_description": "You are given a **binary** string `s` and an integer `k`. A **binary string** satisfies the **k-constraint** if **either** of the following conditions holds: The number of `0`'s in the string is at most `k`. The number of `1`'s in the string is at most `k`. Return an integer denoting the number of substrings of `s` that satisfy the **k-constraint**. **Example 1:** **Input:** s = \"10101\", k = 1 **Output:** 12 **Explanation:** Every substring of `s` except the substrings `\"1010\"`, `\"10101\"`, and `\"0101\"` satisfies the k-constraint. **Example 2:** **Input:** s = \"1010101\", k = 2 **Output:** 25 **Explanation:** Every substring of `s` except the substrings with a length greater than 5 satisfies the k-constraint. **Example 3:** **Input:** s = \"11111\", k = 1 **Output:** 15 **Explanation:** All substrings of `s` satisfy the k-constraint. **Constraints:** `1 <= s.length <= 50 ` `1 <= k <= s.length` `s[i]` is either `'0'` or `'1'`.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "s = \"10101\", k = 1",
+            "output": "12 "
+        },
+        {
+            "label": "Example 2",
+            "input": "s = \"1010101\", k = 2",
+            "output": "25 "
+        },
+        {
+            "label": "Example 3",
+            "input": "s = \"11111\", k = 1",
+            "output": "15 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                "\"11\"",
+                2
+            ],
+            "output": 3
+        },
+        {
+            "input": [
+                "\"1\"",
+                1
+            ],
+            "output": 1
+        },
+        {
+            "input": [
+                "\"1011100110011101110000000101111110001\"",
+                36
+            ],
+            "output": 703
+        },
+        {
+            "input": [
+                "\"1111100100000100001110110001001110110011110\"",
+                33
+            ],
+            "output": 946
+        },
+        {
+            "input": [
+                "\"011010011\"",
+                5
+            ],
+            "output": 45
+        },
+        {
+            "input": [
+                "\"011111100010010111111100010100000101110111101110\"",
+                9
+            ],
+            "output": 782
+        },
+        {
+            "input": [
+                "\"11\"",
+                1
+            ],
+            "output": 3
+        },
+        {
+            "input": [
+                "01000111100001100100000010010001111010000111000011",
+                41
+            ],
+            "output": 1275
+        },
+        {
+            "input": [
+                "10000100000010011110011110001000000000101001",
+                26
+            ],
+            "output": 990
+        },
+        {
+            "input": [
+                "11001000101000001011",
+                8
+            ],
+            "output": 210
+        }
+    ],
+    "haskell_template": "countKConstraintSubstrings :: String -> Int -> Int\ncountKConstraintSubstrings s k ",
+    "ocaml_template": "let countKConstraintSubstrings (s: string) (k: int) : int =  ",
+    "scala_template": "def countKConstraintSubstrings(s: String,k: Int): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public int countKConstraintSubstrings(String s, int k) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def countKConstraintSubstrings(self, s, k):\n        \"\"\"\n        :type s: str\n        :type k: int\n        :rtype: int\n        \"\"\"\n        "
+}

count_substrings_that_satisfy_k_constraint_i/ocaml_tests/main.ml

@@ -0,0 +1,50 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 12 (countKConstraintSubstrings "10101" 1)
+
+let test2 _ = assert_equal 25 (countKConstraintSubstrings "1010101" 2)
+
+let test3 _ = assert_equal 15 (countKConstraintSubstrings "11111" 1)
+
+let test4 _ = assert_equal 3 (countKConstraintSubstrings "11" 2)
+
+let test5 _ = assert_equal 1 (countKConstraintSubstrings "1" 1)
+
+let test6 _ = assert_equal 703 (countKConstraintSubstrings "1011100110011101110000000101111110001" 36)
+
+let test7 _ = assert_equal 946 (countKConstraintSubstrings "1111100100000100001110110001001110110011110" 33)
+
+let test8 _ = assert_equal 45 (countKConstraintSubstrings "011010011" 5)
+
+let test9 _ = assert_equal 782 (countKConstraintSubstrings "011111100010010111111100010100000101110111101110" 9)
+
+let test10 _ = assert_equal 3 (countKConstraintSubstrings "11" 1)
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for countKConstraintSubstrings" >::: [
+        
+  "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

count_substrings_that_satisfy_k_constraint_i/scala_tests/MySuite.scala

@@ -0,0 +1,44 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.countKConstraintSubstrings("10101",1), 12)
+  }
+
+  test("test2") {
+    assertEquals(Main.countKConstraintSubstrings("1010101",2), 25)
+  }
+
+  test("test3") {
+    assertEquals(Main.countKConstraintSubstrings("11111",1), 15)
+  }
+
+  test("test4") {
+    assertEquals(Main.countKConstraintSubstrings("11",2), 3)
+  }
+
+  test("test5") {
+    assertEquals(Main.countKConstraintSubstrings("1",1), 1)
+  }
+
+  test("test6") {
+    assertEquals(Main.countKConstraintSubstrings("1011100110011101110000000101111110001",36), 703)
+  }
+
+  test("test7") {
+    assertEquals(Main.countKConstraintSubstrings("1111100100000100001110110001001110110011110",33), 946)
+  }
+
+  test("test8") {
+    assertEquals(Main.countKConstraintSubstrings("011010011",5), 45)
+  }
+
+  test("test9") {
+    assertEquals(Main.countKConstraintSubstrings("011111100010010111111100010100000101110111101110",9), 782)
+  }
+
+  test("test10") {
+    assertEquals(Main.countKConstraintSubstrings("11",1), 3)
+  }
+
+}

count_substrings_that_satisfy_k_constraint_ii/haskell_tests/Main.hs

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

count_substrings_that_satisfy_k_constraint_ii/java_tests/Main.java

@@ -0,0 +1,21 @@
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+import java.util.List;
+import java.util.Arrays;
+import java.util.ArrayList;
+public class Main {
+    //Program start
+    
+    //Program end
+
+    @Test
+public void test1() {
+    assertEquals(new ArrayList<>(Arrays.asList(26)), countKConstraintSubstrings("0001111", 2, new ArrayList<>(Arrays.asList(new ArrayList<>(Arrays.asList(0,6))))));
+}
+@Test
+public void test2() {
+    assertEquals(new ArrayList<>(Arrays.asList(15,9,3)), countKConstraintSubstrings("010101", 1, new ArrayList<>(Arrays.asList(new ArrayList<>(Arrays.asList(0,5)),new ArrayList<>(Arrays.asList(1,4)),new ArrayList<>(Arrays.asList(2,3))))));
+}
+
+}

count_substrings_that_satisfy_k_constraint_ii/meta.json

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

count_symmetric_integers/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 (countSymmetricIntegers 1 100)," 9 (countSymmetricIntegers 1 100))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (countSymmetricIntegers 1200 1230)," 4 (countSymmetricIntegers 1200 1230))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

count_symmetric_integers/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(9, countSymmetricIntegers(1, 100));
+}
+@Test
+public void test2() {
+    assertEquals(4, countSymmetricIntegers(1200, 1230));
+}
+
+}

count_symmetric_integers/meta.json

@@ -0,0 +1,26 @@
+{
+    "id": 2998,
+    "name": "count_symmetric_integers",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/count-symmetric-integers/",
+    "date": "1693094400000",
+    "task_description": "You are given two positive integers `low` and `high`. An integer `x` consisting of `2 * n` digits is **symmetric** if the sum of the first `n` digits of `x` is equal to the sum of the last `n` digits of `x`. Numbers with an odd number of digits are never symmetric. Return _the **number of symmetric** integers in the range_ `[low, high]`. **Example 1:** ``` **Input:** low = 1, high = 100 **Output:** 9 **Explanation:** There are 9 symmetric integers between 1 and 100: 11, 22, 33, 44, 55, 66, 77, 88, and 99. ``` **Example 2:** ``` **Input:** low = 1200, high = 1230 **Output:** 4 **Explanation:** There are 4 symmetric integers between 1200 and 1230: 1203, 1212, 1221, and 1230. ``` **Constraints:** `1 <= low <= high <= 104`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "low = 1, high = 100",
+            "output": "9 "
+        },
+        {
+            "label": "Example 2",
+            "input": "low = 1200, high = 1230",
+            "output": "4 "
+        }
+    ],
+    "private_test_cases": [],
+    "haskell_template": "countSymmetricIntegers :: Int -> Int -> Int\ncountSymmetricIntegers low high ",
+    "ocaml_template": "let countSymmetricIntegers (low: int) (high: int) : int =  ",
+    "scala_template": "def countSymmetricIntegers(low: Int,high: Int): Int = { \n    \n}",
+    "java_template": "public static int countSymmetricIntegers(int low, int high) {\n\n}",
+    "python_template": "class Solution(object):\n    def countSymmetricIntegers(self, low, high):\n        \"\"\"\n        :type low: int\n        :type high: int\n        :rtype: int\n        \"\"\"\n        "
+}

count_symmetric_integers/ocaml_tests/main.ml

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

count_symmetric_integers/scala_tests/MySuite.scala

@@ -0,0 +1,12 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.countSymmetricIntegers(1,100), 9)
+  }
+
+  test("test2") {
+    assertEquals(Main.countSymmetricIntegers(1200,1230), 4)
+  }
+
+}

count_tested_devices_after_test_operations/haskell_tests/Main.hs

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

count_tested_devices_after_test_operations/java_tests/Main.java

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

count_tested_devices_after_test_operations/meta.json

@@ -0,0 +1,525 @@
+{
+    "id": 3220,
+    "name": "count_tested_devices_after_test_operations",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/count-tested-devices-after-test-operations/",
+    "date": "2023-12-03 00:00:00",
+    "task_description": "You are given a **0-indexed** integer array `batteryPercentages` having length `n`, denoting the battery percentages of `n` **0-indexed** devices. Your task is to test each device `i` **in order** from `0` to `n - 1`, by performing the following test operations: If `batteryPercentages[i]` is **greater** than `0`: **Increment** the count of tested devices. **Decrease** the battery percentage of all devices with indices `j` in the range `[i + 1, n - 1]` by `1`, ensuring their battery percentage **never goes below** `0`, i.e, `batteryPercentages[j] = max(0, batteryPercentages[j] - 1)`. Move to the next device. Otherwise, move to the next device without performing any test. Return _an integer denoting the number of devices that will be tested after performing the test operations in order._ **Example 1:** ``` **Input:** batteryPercentages = [1,1,2,1,3] **Output:** 3 **Explanation: **Performing the test operations in order starting from device 0: At device 0, batteryPercentages[0] > 0, so there is now 1 tested device, and batteryPercentages becomes [1,0,1,0,2]. At device 1, batteryPercentages[1] == 0, so we move to the next device without testing. At device 2, batteryPercentages[2] > 0, so there are now 2 tested devices, and batteryPercentages becomes [1,0,1,0,1]. At device 3, batteryPercentages[3] == 0, so we move to the next device without testing. At device 4, batteryPercentages[4] > 0, so there are now 3 tested devices, and batteryPercentages stays the same. So, the answer is 3. ``` **Example 2:** ``` **Input:** batteryPercentages = [0,1,2] **Output:** 2 **Explanation:** Performing the test operations in order starting from device 0: At device 0, batteryPercentages[0] == 0, so we move to the next device without testing. At device 1, batteryPercentages[1] > 0, so there is now 1 tested device, and batteryPercentages becomes [0,1,1]. At device 2, batteryPercentages[2] > 0, so there are now 2 tested devices, and batteryPercentages stays the same. So, the answer is 2. ``` **Constraints:** `1 <= n == batteryPercentages.length <= 100 ` `0 <= batteryPercentages[i] <= 100`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "batteryPercentages = [1,1,2,1,3]",
+            "output": "3 "
+        },
+        {
+            "label": "Example 2",
+            "input": "batteryPercentages = [0,1,2]",
+            "output": "2 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                54,
+                43,
+                50,
+                48,
+                97,
+                39,
+                90,
+                92,
+                55,
+                87,
+                85,
+                66,
+                7,
+                44,
+                73,
+                88,
+                94,
+                87,
+                89,
+                98,
+                2,
+                38,
+                3,
+                91,
+                57,
+                59,
+                89,
+                19,
+                71,
+                15,
+                47,
+                36,
+                27,
+                90,
+                14,
+                15,
+                20,
+                2,
+                16,
+                37,
+                91,
+                97,
+                48,
+                38,
+                92,
+                53,
+                22,
+                100,
+                51,
+                90,
+                95,
+                7,
+                92,
+                89,
+                16,
+                15,
+                90,
+                39,
+                92,
+                36,
+                78,
+                59,
+                17,
+                43,
+                90,
+                48,
+                95,
+                9,
+                29,
+                45,
+                48,
+                65,
+                30,
+                47,
+                87,
+                21,
+                1,
+                98,
+                20
+            ],
+            "output": 51
+        },
+        {
+            "input": [
+                91,
+                81,
+                30,
+                72,
+                20,
+                63,
+                81,
+                45
+            ],
+            "output": 8
+        },
+        {
+            "input": [
+                65,
+                13,
+                66,
+                88,
+                60,
+                35,
+                51,
+                54,
+                74,
+                75,
+                56,
+                11,
+                73,
+                42,
+                90,
+                29,
+                29,
+                23,
+                97,
+                87,
+                73,
+                43,
+                29,
+                44,
+                69,
+                43,
+                11,
+                47,
+                39,
+                83,
+                56,
+                6,
+                15,
+                37,
+                40,
+                22,
+                32,
+                72,
+                2,
+                80,
+                22,
+                56,
+                5,
+                53,
+                55,
+                30,
+                39,
+                29,
+                19,
+                60,
+                93,
+                73,
+                1,
+                53,
+                4,
+                88,
+                55,
+                39,
+                57,
+                31,
+                6,
+                73,
+                3,
+                98,
+                73,
+                77,
+                84,
+                21,
+                11,
+                18,
+                95,
+                4,
+                59,
+                72,
+                24,
+                44,
+                37,
+                58,
+                8,
+                19,
+                44,
+                95,
+                55,
+                50,
+                63,
+                70,
+                98,
+                35,
+                84,
+                67,
+                72,
+                51,
+                26,
+                10,
+                99,
+                11,
+                37,
+                49
+            ],
+            "output": 62
+        },
+        {
+            "input": [
+                31,
+                81,
+                10,
+                45,
+                1,
+                86,
+                23,
+                14,
+                99,
+                53,
+                66,
+                78,
+                22,
+                81,
+                3,
+                51,
+                53,
+                33,
+                69,
+                54,
+                36,
+                41,
+                84,
+                64,
+                7,
+                52,
+                32,
+                14,
+                55,
+                72,
+                30,
+                49,
+                69,
+                60,
+                92,
+                31,
+                13,
+                61,
+                15,
+                0,
+                94,
+                68,
+                85,
+                52,
+                100,
+                60,
+                95,
+                61,
+                37,
+                82,
+                8,
+                0,
+                52,
+                9,
+                68,
+                25,
+                34,
+                26,
+                0,
+                79,
+                63,
+                18,
+                23,
+                60,
+                51,
+                72,
+                48,
+                25,
+                48,
+                74,
+                64,
+                13
+            ],
+            "output": 50
+        },
+        {
+            "input": [
+                62,
+                22,
+                60,
+                57,
+                20,
+                69,
+                60,
+                24,
+                53,
+                39,
+                39,
+                46,
+                33,
+                43,
+                98,
+                82,
+                63,
+                94,
+                10,
+                10,
+                20,
+                85,
+                15,
+                20,
+                62,
+                63,
+                0,
+                21,
+                38,
+                84,
+                6
+            ],
+            "output": 24
+        },
+        {
+            "input": [
+                18,
+                100,
+                59,
+                91,
+                40,
+                56,
+                5,
+                36,
+                48,
+                4,
+                97,
+                93,
+                30,
+                98,
+                1,
+                7,
+                77,
+                47,
+                36,
+                94
+            ],
+            "output": 16
+        },
+        {
+            "input": [
+                22,
+                81,
+                76,
+                86,
+                38,
+                36,
+                84,
+                69,
+                72,
+                55,
+                85,
+                96,
+                57,
+                28,
+                30,
+                26,
+                6,
+                64,
+                79,
+                65,
+                57,
+                95,
+                61,
+                45,
+                54,
+                58,
+                75,
+                2,
+                9,
+                60,
+                99,
+                77,
+                53,
+                8,
+                71,
+                59,
+                6,
+                31,
+                67,
+                81,
+                100,
+                100,
+                82,
+                29,
+                86,
+                49,
+                80,
+                35,
+                12,
+                9,
+                42,
+                47,
+                35,
+                75,
+                61,
+                42,
+                43,
+                21,
+                64,
+                19,
+                27,
+                54
+            ],
+            "output": 46
+        },
+        {
+            "input": [
+                33,
+                61,
+                0,
+                33,
+                81,
+                7,
+                70,
+                27,
+                30,
+                25,
+                66,
+                12,
+                12,
+                68,
+                13,
+                14,
+                62,
+                73,
+                25,
+                67,
+                52,
+                5,
+                74,
+                59,
+                71,
+                32,
+                38,
+                71,
+                61,
+                84,
+                25,
+                34,
+                20,
+                66,
+                54,
+                77,
+                32,
+                99,
+                41,
+                95,
+                84,
+                14,
+                31,
+                92,
+                92,
+                23,
+                55,
+                15,
+                92,
+                86,
+                59,
+                62,
+                35,
+                72,
+                11,
+                61,
+                80,
+                50,
+                3,
+                0,
+                52,
+                60,
+                11
+            ],
+            "output": 49
+        },
+        {
+            "input": [
+                49,
+                69,
+                25,
+                47,
+                43,
+                80,
+                47,
+                51,
+                79,
+                0
+            ],
+            "output": 9
+        },
+        {
+            "input": [
+                38,
+                78,
+                0,
+                31,
+                58
+            ],
+            "output": 4
+        }
+    ],
+    "haskell_template": "countTestedDevices :: [Int] -> Int\ncountTestedDevices batteryPercentages ",
+    "ocaml_template": "let countTestedDevices (batteryPercentages: int list) : int =  ",
+    "scala_template": "def countTestedDevices(batteryPercentages: List[Int]): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public int countTestedDevices(int[] batteryPercentages) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def countTestedDevices(self, batteryPercentages):\n        \"\"\"\n        :type batteryPercentages: List[int]\n        :rtype: int\n        \"\"\"\n        "
+}

count_tested_devices_after_test_operations/ocaml_tests/main.ml

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

count_tested_devices_after_test_operations/scala_tests/MySuite.scala

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

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

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

count_the_hidden_sequences/meta.json

@@ -0,0 +1,578 @@
+{
+    "id": 2249,
+    "name": "count_the_hidden_sequences",
+    "difficulty": "Medium",
+    "link": "https://leetcode.com/problems/count-the-hidden-sequences/",
+    "date": "1641600000000",
+    "task_description": "You are given a **0-indexed** array of `n` integers `differences`, which describes the **differences **between each pair of **consecutive **integers of a **hidden** sequence of length `(n + 1)`. More formally, call the hidden sequence `hidden`, then we have that `differences[i] = hidden[i + 1] - hidden[i]`. You are further given two integers `lower` and `upper` that describe the **inclusive** range of values `[lower, upper]` that the hidden sequence can contain. For example, given `differences = [1, -3, 4]`, `lower = 1`, `upper = 6`, the hidden sequence is a sequence of length `4` whose elements are in between `1` and `6` (**inclusive**). `[3, 4, 1, 5]` and `[4, 5, 2, 6]` are possible hidden sequences. `[5, 6, 3, 7]` is not possible since it contains an element greater than `6`. `[1, 2, 3, 4]` is not possible since the differences are not correct. Return _the number of **possible** hidden sequences there are._ If there are no possible sequences, return `0`. **Example 1:** ``` **Input:** differences = [1,-3,4], lower = 1, upper = 6 **Output:** 2 **Explanation:** The possible hidden sequences are: - [3, 4, 1, 5] - [4, 5, 2, 6] Thus, we return 2. ``` **Example 2:** ``` **Input:** differences = [3,-4,5,1,-2], lower = -4, upper = 5 **Output:** 4 **Explanation:** The possible hidden sequences are: - [-3, 0, -4, 1, 2, 0] - [-2, 1, -3, 2, 3, 1] - [-1, 2, -2, 3, 4, 2] - [0, 3, -1, 4, 5, 3] Thus, we return 4. ``` **Example 3:** ``` **Input:** differences = [4,-7,2], lower = 3, upper = 6 **Output:** 0 **Explanation:** There are no possible hidden sequences. Thus, we return 0. ``` **Constraints:** `n == differences.length` `1 <= n <= 105` `-105 <= differences[i] <= 105` `-105 <= lower <= upper <= 105`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "differences = [1,-3,4], lower = 1, upper = 6",
+            "output": "2 "
+        },
+        {
+            "label": "Example 2",
+            "input": "differences = [3,-4,5,1,-2], lower = -4, upper = 5",
+            "output": "4 "
+        },
+        {
+            "label": "Example 3",
+            "input": "differences = [4,-7,2], lower = 3, upper = 6",
+            "output": "0 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                [
+                    -70,
+                    69,
+                    86,
+                    -85,
+                    96,
+                    4,
+                    52,
+                    48,
+                    51,
+                    -86,
+                    71,
+                    -28,
+                    41,
+                    16,
+                    -45,
+                    -53,
+                    73,
+                    47,
+                    -27,
+                    33,
+                    -50,
+                    -17,
+                    -73,
+                    87,
+                    -54,
+                    -17,
+                    17,
+                    -100,
+                    101,
+                    98,
+                    -6,
+                    22,
+                    -69,
+                    -97,
+                    -89,
+                    100,
+                    -2,
+                    40,
+                    60,
+                    99,
+                    16,
+                    22,
+                    -105,
+                    -27,
+                    18,
+                    -32,
+                    -95,
+                    89,
+                    85,
+                    -67,
+                    -41,
+                    -33,
+                    -7,
+                    100
+                ],
+                5,
+                100
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                [
+                    27,
+                    -28,
+                    -37,
+                    -47,
+                    -3,
+                    90,
+                    -46,
+                    37,
+                    -17,
+                    -14,
+                    -85,
+                    90,
+                    -53,
+                    16,
+                    17,
+                    17,
+                    52,
+                    43,
+                    -89,
+                    84,
+                    70,
+                    2,
+                    -29,
+                    59,
+                    -70,
+                    103,
+                    86,
+                    58,
+                    82,
+                    17,
+                    -48,
+                    -18
+                ],
+                25,
+                53
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                [
+                    -13,
+                    58,
+                    84,
+                    -26,
+                    99,
+                    -26,
+                    6,
+                    26,
+                    -55,
+                    -70,
+                    -57,
+                    52,
+                    72,
+                    -98,
+                    28,
+                    -99,
+                    70,
+                    99,
+                    -23,
+                    85,
+                    78,
+                    64,
+                    26,
+                    89,
+                    -42,
+                    67,
+                    -93,
+                    56,
+                    79,
+                    43,
+                    49,
+                    44,
+                    -1,
+                    60,
+                    -15,
+                    45,
+                    -88,
+                    -80,
+                    25,
+                    -78,
+                    79,
+                    53,
+                    -71,
+                    -62,
+                    -44,
+                    -89,
+                    28,
+                    -36,
+                    -82,
+                    -104,
+                    -50,
+                    46,
+                    -47,
+                    25,
+                    -50,
+                    -42,
+                    -45,
+                    -76,
+                    20
+                ],
+                -92,
+                -4
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                [
+                    -77,
+                    -59,
+                    -90,
+                    -45,
+                    20,
+                    -72,
+                    -68,
+                    1,
+                    -103,
+                    -11,
+                    -47,
+                    93,
+                    -10,
+                    -86,
+                    -94,
+                    76,
+                    73
+                ],
+                -37,
+                48
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                [
+                    -105,
+                    -74,
+                    -7,
+                    68,
+                    -101,
+                    -8,
+                    49,
+                    10,
+                    26,
+                    -83,
+                    70,
+                    94,
+                    60,
+                    66,
+                    81,
+                    98,
+                    2,
+                    65,
+                    -69,
+                    -21,
+                    -58,
+                    -42,
+                    87,
+                    -29,
+                    78,
+                    -94,
+                    -41,
+                    36,
+                    -34,
+                    75,
+                    94,
+                    55,
+                    -20,
+                    -38,
+                    -66,
+                    33,
+                    105,
+                    54,
+                    26,
+                    78,
+                    -101,
+                    10,
+                    -31,
+                    73,
+                    19,
+                    -81,
+                    67,
+                    -32,
+                    -11,
+                    -72,
+                    -24,
+                    34,
+                    -77,
+                    53,
+                    -74,
+                    50,
+                    64,
+                    -62,
+                    -71,
+                    54,
+                    54,
+                    -59,
+                    -9,
+                    -21,
+                    100,
+                    -81,
+                    66
+                ],
+                105,
+                105
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                [
+                    61,
+                    33,
+                    -22,
+                    34,
+                    13,
+                    -75,
+                    -53,
+                    90,
+                    -9,
+                    79,
+                    55,
+                    -5,
+                    6,
+                    55,
+                    10,
+                    -53,
+                    -104,
+                    -82,
+                    92,
+                    46,
+                    -54,
+                    -34,
+                    85,
+                    96,
+                    -102,
+                    -28,
+                    -55,
+                    -60,
+                    19,
+                    10,
+                    54,
+                    -63,
+                    -6,
+                    14,
+                    -80,
+                    61,
+                    -50,
+                    43
+                ],
+                -71,
+                76
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                [
+                    69,
+                    -12,
+                    -9,
+                    78,
+                    -50,
+                    18,
+                    -5,
+                    -28,
+                    90,
+                    26,
+                    -60,
+                    40,
+                    -1,
+                    -95,
+                    -51,
+                    99,
+                    64,
+                    -23,
+                    -93,
+                    6,
+                    -104,
+                    -80,
+                    26,
+                    81,
+                    -103,
+                    56,
+                    -43,
+                    86,
+                    66,
+                    29,
+                    -24,
+                    -86,
+                    -77,
+                    12,
+                    -36,
+                    -71,
+                    96,
+                    10,
+                    -41,
+                    -26,
+                    72,
+                    32,
+                    -35,
+                    99,
+                    -87
+                ],
+                96,
+                104
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                [
+                    6,
+                    -21,
+                    46,
+                    90,
+                    -56,
+                    -35,
+                    -91,
+                    73,
+                    -71,
+                    23,
+                    35,
+                    43,
+                    -13,
+                    -33,
+                    70,
+                    -92,
+                    47,
+                    6,
+                    32,
+                    -18,
+                    71,
+                    20,
+                    12,
+                    -78,
+                    40,
+                    -55,
+                    -29,
+                    48,
+                    45,
+                    9,
+                    -83,
+                    -83,
+                    48,
+                    -52,
+                    -98,
+                    51,
+                    17,
+                    -28,
+                    -53,
+                    46,
+                    -11,
+                    -42,
+                    -83,
+                    -104,
+                    -51,
+                    -88,
+                    26
+                ],
+                -102,
+                -72
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                [
+                    53,
+                    -57,
+                    -25,
+                    29,
+                    97,
+                    70,
+                    -62,
+                    25,
+                    76,
+                    -58,
+                    0,
+                    67,
+                    -9,
+                    53,
+                    -37
+                ],
+                -65,
+                -47
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                [
+                    -7,
+                    60,
+                    -76,
+                    -77,
+                    -45,
+                    17,
+                    -11,
+                    8,
+                    -78,
+                    -52,
+                    13,
+                    33,
+                    43,
+                    -90,
+                    61,
+                    -77,
+                    -80,
+                    -32,
+                    102,
+                    -34,
+                    -33,
+                    -71,
+                    -6,
+                    -71,
+                    7,
+                    59,
+                    -93,
+                    60,
+                    74,
+                    -53,
+                    -96,
+                    7,
+                    43,
+                    -24,
+                    -76,
+                    72,
+                    -53,
+                    -64,
+                    23,
+                    74,
+                    -18,
+                    -7,
+                    24,
+                    25,
+                    -20,
+                    -70,
+                    17,
+                    90,
+                    -46,
+                    12,
+                    -103,
+                    -67,
+                    -9,
+                    83,
+                    -20,
+                    37,
+                    22,
+                    53,
+                    -90,
+                    87,
+                    55,
+                    -42,
+                    -60,
+                    -94,
+                    -45,
+                    -23,
+                    -50,
+                    91,
+                    71,
+                    -24,
+                    -32,
+                    -94,
+                    100,
+                    -50,
+                    -47,
+                    32,
+                    46,
+                    -11,
+                    102,
+                    42,
+                    -53,
+                    58
+                ],
+                39,
+                62
+            ],
+            "output": 0
+        }
+    ],
+    "haskell_template": "numberOfArrays :: [Int] -> Int -> Int -> Int\nnumberOfArrays differences lower upper ",
+    "ocaml_template": "let numberOfArrays (differences: int list) (lower: int) (upper: int) : int =  ",
+    "scala_template": "def numberOfArrays(differences: List[Int],lower: Int,upper: Int): Int = { \n    \n}",
+    "java_template": "public static int numberOfArrays(List<Integer> differences, int lower, int upper) {\n\n}",
+    "python_template": "class Solution(object):\n    def numberOfArrays(self, differences, lower, upper):\n        \"\"\"\n        :type differences: List[int]\n        :type lower: int\n        :type upper: int\n        :rtype: int\n        \"\"\"\n        "
+}

count_the_hidden_sequences/ocaml_tests/main.ml

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

count_the_hidden_sequences/scala_tests/MySuite.scala

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

count_the_number_of_arrays_with_k_matching_adjacent_elements/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 (countGoodArrays 3 2 1)," 4 (countGoodArrays 3 2 1))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (countGoodArrays 4 2 2)," 6 (countGoodArrays 4 2 2))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (countGoodArrays 5 2 0)," 2 (countGoodArrays 5 2 0))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (countGoodArrays 46602 24391 20531)," 891511181 (countGoodArrays 46602 24391 20531))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (countGoodArrays 17103 5354 10144)," 343110856 (countGoodArrays 17103 5354 10144))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (countGoodArrays 5697 37912 4080)," 738769666 (countGoodArrays 5697 37912 4080))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (countGoodArrays 80119 96321 52737)," 615287085 (countGoodArrays 80119 96321 52737))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (countGoodArrays 98177 38305 44965)," 532242521 (countGoodArrays 98177 38305 44965))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (countGoodArrays 10577 75301 8138)," 82714097 (countGoodArrays 10577 75301 8138))
+
+
+-- 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

count_the_number_of_arrays_with_k_matching_adjacent_elements/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(4, countGoodArrays(3, 2, 1));
+}
+@Test
+public void test2() {
+    assertEquals(6, countGoodArrays(4, 2, 2));
+}
+@Test
+public void test3() {
+    assertEquals(2, countGoodArrays(5, 2, 0));
+}
+
+}

count_the_number_of_arrays_with_k_matching_adjacent_elements/meta.json

@@ -0,0 +1,112 @@
+{
+    "id": 3682,
+    "name": "count_the_number_of_arrays_with_k_matching_adjacent_elements",
+    "difficulty": "Hard",
+    "link": "https://leetcode.com/problems/count-the-number-of-arrays-with-k-matching-adjacent-elements/",
+    "date": "2024-12-22 00:00:00",
+    "task_description": "You are given three integers `n`, `m`, `k`. A **good array** `arr` of size `n` is defined as follows: Each element in `arr` is in the **inclusive** range `[1, m]`. _Exactly_ `k` indices `i` (where `1 <= i < n`) satisfy the condition `arr[i - 1] == arr[i]`. Return the number of **good arrays** that can be formed. Since the answer may be very large, return it **modulo **`109 + 7`. **Example 1:** **Input:** n = 3, m = 2, k = 1 **Output:** 4 **Explanation:** There are 4 good arrays. They are `[1, 1, 2]`, `[1, 2, 2]`, `[2, 1, 1]` and `[2, 2, 1]`. Hence, the answer is 4. **Example 2:** **Input:** n = 4, m = 2, k = 2 **Output:** 6 **Explanation:** The good arrays are `[1, 1, 1, 2]`, `[1, 1, 2, 2]`, `[1, 2, 2, 2]`, `[2, 1, 1, 1]`, `[2, 2, 1, 1]` and `[2, 2, 2, 1]`. Hence, the answer is 6. **Example 3:** **Input:** n = 5, m = 2, k = 0 **Output:** 2 **Explanation:** The good arrays are `[1, 2, 1, 2, 1]` and `[2, 1, 2, 1, 2]`. Hence, the answer is 2. **Constraints:** `1 <= n <= 105` `1 <= m <= 105` `0 <= k <= n - 1`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "n = 3, m = 2, k = 1",
+            "output": "4 "
+        },
+        {
+            "label": "Example 2",
+            "input": "n = 4, m = 2, k = 2",
+            "output": "6 "
+        },
+        {
+            "label": "Example 3",
+            "input": "n = 5, m = 2, k = 0",
+            "output": "2 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                46602,
+                24391,
+                20531
+            ],
+            "output": 891511181
+        },
+        {
+            "input": [
+                17103,
+                5354,
+                10144
+            ],
+            "output": 343110856
+        },
+        {
+            "input": [
+                5697,
+                37912,
+                4080
+            ],
+            "output": 738769666
+        },
+        {
+            "input": [
+                80119,
+                96321,
+                52737
+            ],
+            "output": 615287085
+        },
+        {
+            "input": [
+                98177,
+                38305,
+                44965
+            ],
+            "output": 532242521
+        },
+        {
+            "input": [
+                10577,
+                75301,
+                8138
+            ],
+            "output": 82714097
+        },
+        {
+            "input": [
+                25557,
+                67054,
+                13962
+            ],
+            "output": 763883936
+        },
+        {
+            "input": [
+                62512,
+                2930,
+                56704
+            ],
+            "output": 628401229
+        },
+        {
+            "input": [
+                89952,
+                94204,
+                41803
+            ],
+            "output": 623576131
+        },
+        {
+            "input": [
+                43138,
+                58555,
+                14245
+            ],
+            "output": 969703223
+        }
+    ],
+    "haskell_template": "countGoodArrays :: Int -> Int -> Int -> Int\ncountGoodArrays n m k ",
+    "ocaml_template": "let countGoodArrays (n: int) (m: int) (k: int) : int =  ",
+    "scala_template": "def countGoodArrays(n: Int,m: Int,k: Int): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public int countGoodArrays(int n, int m, int k) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def countGoodArrays(self, n, m, k):\n        \"\"\"\n        :type n: int\n        :type m: int\n        :type k: int\n        :rtype: int\n        \"\"\"\n        "
+}

count_the_number_of_arrays_with_k_matching_adjacent_elements/ocaml_tests/main.ml

@@ -0,0 +1,50 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 4 (countGoodArrays 3 2 1)
+
+let test2 _ = assert_equal 6 (countGoodArrays 4 2 2)
+
+let test3 _ = assert_equal 2 (countGoodArrays 5 2 0)
+
+let test4 _ = assert_equal 891511181 (countGoodArrays 46602 24391 20531)
+
+let test5 _ = assert_equal 343110856 (countGoodArrays 17103 5354 10144)
+
+let test6 _ = assert_equal 738769666 (countGoodArrays 5697 37912 4080)
+
+let test7 _ = assert_equal 615287085 (countGoodArrays 80119 96321 52737)
+
+let test8 _ = assert_equal 532242521 (countGoodArrays 98177 38305 44965)
+
+let test9 _ = assert_equal 82714097 (countGoodArrays 10577 75301 8138)
+
+let test10 _ = assert_equal 763883936 (countGoodArrays 25557 67054 13962)
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for countGoodArrays" >::: [
+        
+  "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

count_the_number_of_arrays_with_k_matching_adjacent_elements/scala_tests/MySuite.scala

@@ -0,0 +1,44 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.countGoodArrays(3,2,1), 4)
+  }
+
+  test("test2") {
+    assertEquals(Main.countGoodArrays(4,2,2), 6)
+  }
+
+  test("test3") {
+    assertEquals(Main.countGoodArrays(5,2,0), 2)
+  }
+
+  test("test4") {
+    assertEquals(Main.countGoodArrays(46602,24391,20531), 891511181)
+  }
+
+  test("test5") {
+    assertEquals(Main.countGoodArrays(17103,5354,10144), 343110856)
+  }
+
+  test("test6") {
+    assertEquals(Main.countGoodArrays(5697,37912,4080), 738769666)
+  }
+
+  test("test7") {
+    assertEquals(Main.countGoodArrays(80119,96321,52737), 615287085)
+  }
+
+  test("test8") {
+    assertEquals(Main.countGoodArrays(98177,38305,44965), 532242521)
+  }
+
+  test("test9") {
+    assertEquals(Main.countGoodArrays(10577,75301,8138), 82714097)
+  }
+
+  test("test10") {
+    assertEquals(Main.countGoodArrays(25557,67054,13962), 763883936)
+  }
+
+}