92988b1e4e7745ed81cac53dcd42a92de49fde9a78668977a27ff3a15c81c91a

.gitattributes

@@ -120,3 +120,5 @@ find_closest_node_to_given_two_nodes/meta.json filter=lfs diff=lfs merge=lfs -te
 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_subtree_sizes_after_changes/meta.json filter=lfs diff=lfs merge=lfs -text
+find_the_first_player_to_win_k_games_in_a_row/meta.json filter=lfs diff=lfs merge=lfs -text

find_substring_with_given_hash_value/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 (subStrHash \"leetcode \" 7 20 2 0)," "ee" (subStrHash "leetcode" 7 20 2 0))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (subStrHash \"fbxzaad \" 31 100 3 32)," "fbx" (subStrHash "fbxzaad" 31 100 3 32))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

find_substring_with_given_hash_value/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("0", subStrHash("leetcode", 7, 20, 2, 0));
+}
+@Test
+public void test2() {
+    assertEquals("32", subStrHash("fbxzaad", 31, 100, 3, 32));
+}
+
+}

find_substring_with_given_hash_value/ocaml_tests/main.ml

@@ -0,0 +1,26 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal "ee" (subStrHash "leetcode" 7 20 2 0)
+
+let test2 _ = assert_equal "fbx" (subStrHash "fbxzaad" 31 100 3 32)
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for subStrHash" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

find_substring_with_given_hash_value/scala_tests/MySuite.scala

@@ -0,0 +1,12 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.subStrHash("leetcode",7,20,2,0), "ee")
+  }
+
+  test("test2") {
+    assertEquals(Main.subStrHash("fbxzaad",31,100,3,32), "fbx")
+  }
+
+}

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

find_subtree_sizes_after_changes/meta.json

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

find_the_array_concatenation_value/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 (findTheArrayConcVal [7,52,2,4])," 596 (findTheArrayConcVal [7,52,2,4]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (findTheArrayConcVal [5,14,13,8,12])," 673 (findTheArrayConcVal [5,14,13,8,12]))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

find_the_array_concatenation_value/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(596, findTheArrayConcVal(new ArrayList<>(Arrays.asList(7,52,2,4))));
+}
+@Test
+public void test2() {
+    assertEquals(673, findTheArrayConcVal(new ArrayList<>(Arrays.asList(5,14,13,8,12))));
+}
+
+}

find_the_array_concatenation_value/ocaml_tests/main.ml

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

find_the_array_concatenation_value/scala_tests/MySuite.scala

@@ -0,0 +1,12 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.findTheArrayConcVal(List(7,52,2,4)), 596)
+  }
+
+  test("test2") {
+    assertEquals(Main.findTheArrayConcVal(List(5,14,13,8,12)), 673)
+  }
+
+}

find_the_child_who_has_the_ball_after_k_seconds/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 (numberOfChild 3 5)," 1 (numberOfChild 3 5))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (numberOfChild 5 6)," 2 (numberOfChild 5 6))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (numberOfChild 4 2)," 2 (numberOfChild 4 2))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (numberOfChild 46 27)," 27 (numberOfChild 46 27))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (numberOfChild 11 18)," 2 (numberOfChild 11 18))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (numberOfChild 39 46)," 30 (numberOfChild 39 46))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (numberOfChild 41 50)," 30 (numberOfChild 41 50))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (numberOfChild 32 33)," 29 (numberOfChild 32 33))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (numberOfChild 27 47)," 5 (numberOfChild 27 47))
+
+
+-- 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_the_child_who_has_the_ball_after_k_seconds/java_tests/Main.java

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

find_the_child_who_has_the_ball_after_k_seconds/meta.json

@@ -0,0 +1,102 @@
+{
+    "id": 3450,
+    "name": "find_the_child_who_has_the_ball_after_k_seconds",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/find-the-child-who-has-the-ball-after-k-seconds/",
+    "date": "2024-06-02 00:00:00",
+    "task_description": "You are given two **positive** integers `n` and `k`. There are `n` children numbered from `0` to `n - 1` standing in a queue _in order_ from left to right. Initially, child 0 holds a ball and the direction of passing the ball is towards the right direction. After each second, the child holding the ball passes it to the child next to them. Once the ball reaches **either** end of the line, i.e. child 0 or child `n - 1`, the direction of passing is **reversed**. Return the number of the child who receives the ball after `k` seconds. **Example 1:** **Input:** n = 3, k = 5 **Output:** 1 **Explanation:** Time elapsed Children `0` `[0, 1, 2]` `1` `[0, 1, 2]` `2` `[0, 1, 2]` `3` `[0, 1, 2]` `4` `[0, 1, 2]` `5` `[0, 1, 2]` **Example 2:** **Input:** n = 5, k = 6 **Output:** 2 **Explanation:** Time elapsed Children `0` `[0, 1, 2, 3, 4]` `1` `[0, 1, 2, 3, 4]` `2` `[0, 1, 2, 3, 4]` `3` `[0, 1, 2, 3, 4]` `4` `[0, 1, 2, 3, 4]` `5` `[0, 1, 2, 3, 4]` `6` `[0, 1, 2, 3, 4]` **Example 3:** **Input:** n = 4, k = 2 **Output:** 2 **Explanation:** Time elapsed Children `0` `[0, 1, 2, 3]` `1` `[0, 1, 2, 3]` `2` `[0, 1, 2, 3]` **Constraints:** `2 <= n <= 50` `1 <= k <= 50` **Note:** This question is the same as 2582: Pass the Pillow.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "n = 3, k = 5",
+            "output": "1 "
+        },
+        {
+            "label": "Example 2",
+            "input": "n = 5, k = 6",
+            "output": "2 "
+        },
+        {
+            "label": "Example 3",
+            "input": "n = 4, k = 2",
+            "output": "2 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                46,
+                27
+            ],
+            "output": 27
+        },
+        {
+            "input": [
+                11,
+                18
+            ],
+            "output": 2
+        },
+        {
+            "input": [
+                39,
+                46
+            ],
+            "output": 30
+        },
+        {
+            "input": [
+                41,
+                50
+            ],
+            "output": 30
+        },
+        {
+            "input": [
+                32,
+                33
+            ],
+            "output": 29
+        },
+        {
+            "input": [
+                27,
+                47
+            ],
+            "output": 5
+        },
+        {
+            "input": [
+                47,
+                24
+            ],
+            "output": 24
+        },
+        {
+            "input": [
+                18,
+                4
+            ],
+            "output": 4
+        },
+        {
+            "input": [
+                41,
+                35
+            ],
+            "output": 35
+        },
+        {
+            "input": [
+                36,
+                10
+            ],
+            "output": 10
+        }
+    ],
+    "haskell_template": "numberOfChild :: Int -> Int -> Int\nnumberOfChild n k ",
+    "ocaml_template": "let numberOfChild (n: int) (k: int) : int =  ",
+    "scala_template": "def numberOfChild(n: Int,k: Int): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public int numberOfChild(int n, int k) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def numberOfChild(self, n, k):\n        \"\"\"\n        :type n: int\n        :type k: int\n        :rtype: int\n        \"\"\"\n        "
+}

find_the_child_who_has_the_ball_after_k_seconds/ocaml_tests/main.ml

@@ -0,0 +1,50 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 1 (numberOfChild 3 5)
+
+let test2 _ = assert_equal 2 (numberOfChild 5 6)
+
+let test3 _ = assert_equal 2 (numberOfChild 4 2)
+
+let test4 _ = assert_equal 27 (numberOfChild 46 27)
+
+let test5 _ = assert_equal 2 (numberOfChild 11 18)
+
+let test6 _ = assert_equal 30 (numberOfChild 39 46)
+
+let test7 _ = assert_equal 30 (numberOfChild 41 50)
+
+let test8 _ = assert_equal 29 (numberOfChild 32 33)
+
+let test9 _ = assert_equal 5 (numberOfChild 27 47)
+
+let test10 _ = assert_equal 24 (numberOfChild 47 24)
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for numberOfChild" >::: [
+        
+  "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_the_child_who_has_the_ball_after_k_seconds/scala_tests/MySuite.scala

@@ -0,0 +1,44 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.numberOfChild(3,5), 1)
+  }
+
+  test("test2") {
+    assertEquals(Main.numberOfChild(5,6), 2)
+  }
+
+  test("test3") {
+    assertEquals(Main.numberOfChild(4,2), 2)
+  }
+
+  test("test4") {
+    assertEquals(Main.numberOfChild(46,27), 27)
+  }
+
+  test("test5") {
+    assertEquals(Main.numberOfChild(11,18), 2)
+  }
+
+  test("test6") {
+    assertEquals(Main.numberOfChild(39,46), 30)
+  }
+
+  test("test7") {
+    assertEquals(Main.numberOfChild(41,50), 30)
+  }
+
+  test("test8") {
+    assertEquals(Main.numberOfChild(32,33), 29)
+  }
+
+  test("test9") {
+    assertEquals(Main.numberOfChild(27,47), 5)
+  }
+
+  test("test10") {
+    assertEquals(Main.numberOfChild(47,24), 24)
+  }
+
+}

find_the_count_of_good_integers/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 (countGoodIntegers 3 5)," 27 (countGoodIntegers 3 5))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (countGoodIntegers 1 4)," 2 (countGoodIntegers 1 4))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (countGoodIntegers 5 6)," 246 (countGoodIntegers 5 6))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (countGoodIntegers 2 4)," 2 (countGoodIntegers 2 4))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (countGoodIntegers 9 6)," 12476696 (countGoodIntegers 9 6))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (countGoodIntegers 10 5)," 19284856 (countGoodIntegers 10 5))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (countGoodIntegers 4 5)," 52 (countGoodIntegers 4 5))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (countGoodIntegers 10 1)," 41457024 (countGoodIntegers 10 1))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (countGoodIntegers 7 5)," 182335 (countGoodIntegers 7 5))
+
+
+-- 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_the_count_of_good_integers/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(27, countGoodIntegers(3, 5));
+}
+@Test
+public void test2() {
+    assertEquals(2, countGoodIntegers(1, 4));
+}
+@Test
+public void test3() {
+    assertEquals(246, countGoodIntegers(5, 6));
+}
+
+}

find_the_count_of_good_integers/meta.json

@@ -0,0 +1,102 @@
+{
+    "id": 3548,
+    "name": "find_the_count_of_good_integers",
+    "difficulty": "Hard",
+    "link": "https://leetcode.com/problems/find-the-count-of-good-integers/",
+    "date": "2024-08-17 00:00:00",
+    "task_description": "You are given two **positive** integers `n` and `k`. An integer `x` is called **k-palindromic** if: `x` is a palindrome. `x` is divisible by `k`. An integer is called **good** if its digits can be _rearranged_ to form a **k-palindromic** integer. For example, for `k = 2`, 2020 can be rearranged to form the _k-palindromic_ integer 2002, whereas 1010 cannot be rearranged to form a _k-palindromic_ integer. Return the count of **good** integers containing `n` digits. **Note** that _any_ integer must **not** have leading zeros, **neither** before **nor** after rearrangement. For example, 1010 _cannot_ be rearranged to form 101. **Example 1:** **Input:** n = 3, k = 5 **Output:** 27 **Explanation:** _Some_ of the good integers are: 551 because it can be rearranged to form 515. 525 because it is already k-palindromic. **Example 2:** **Input:** n = 1, k = 4 **Output:** 2 **Explanation:** The two good integers are 4 and 8. **Example 3:** **Input:** n = 5, k = 6 **Output:** 2468 **Constraints:** `1 <= n <= 10` `1 <= k <= 9`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "n = 3, k = 5",
+            "output": "27 "
+        },
+        {
+            "label": "Example 2",
+            "input": "n = 1, k = 4",
+            "output": "2 "
+        },
+        {
+            "label": "Example 3",
+            "input": "n = 5, k = 6",
+            "output": "246"
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                2,
+                4
+            ],
+            "output": 2
+        },
+        {
+            "input": [
+                9,
+                6
+            ],
+            "output": 12476696
+        },
+        {
+            "input": [
+                10,
+                5
+            ],
+            "output": 19284856
+        },
+        {
+            "input": [
+                4,
+                5
+            ],
+            "output": 52
+        },
+        {
+            "input": [
+                10,
+                1
+            ],
+            "output": 41457024
+        },
+        {
+            "input": [
+                7,
+                5
+            ],
+            "output": 182335
+        },
+        {
+            "input": [
+                4,
+                7
+            ],
+            "output": 76
+        },
+        {
+            "input": [
+                4,
+                3
+            ],
+            "output": 84
+        },
+        {
+            "input": [
+                5,
+                1
+            ],
+            "output": 10935
+        },
+        {
+            "input": [
+                9,
+                8
+            ],
+            "output": 30771543
+        }
+    ],
+    "haskell_template": "countGoodIntegers :: Int -> Int -> Int\ncountGoodIntegers n k ",
+    "ocaml_template": "let countGoodIntegers (n: int) (k: int) : int =  ",
+    "scala_template": "def countGoodIntegers(n: Int,k: Int): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public long countGoodIntegers(int n, int k) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def countGoodIntegers(self, n, k):\n        \"\"\"\n        :type n: int\n        :type k: int\n        :rtype: int\n        \"\"\"\n        "
+}

find_the_count_of_good_integers/ocaml_tests/main.ml

@@ -0,0 +1,50 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 27 (countGoodIntegers 3 5)
+
+let test2 _ = assert_equal 2 (countGoodIntegers 1 4)
+
+let test3 _ = assert_equal 246 (countGoodIntegers 5 6)
+
+let test4 _ = assert_equal 2 (countGoodIntegers 2 4)
+
+let test5 _ = assert_equal 12476696 (countGoodIntegers 9 6)
+
+let test6 _ = assert_equal 19284856 (countGoodIntegers 10 5)
+
+let test7 _ = assert_equal 52 (countGoodIntegers 4 5)
+
+let test8 _ = assert_equal 41457024 (countGoodIntegers 10 1)
+
+let test9 _ = assert_equal 182335 (countGoodIntegers 7 5)
+
+let test10 _ = assert_equal 76 (countGoodIntegers 4 7)
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for countGoodIntegers" >::: [
+        
+  "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_the_count_of_good_integers/scala_tests/MySuite.scala

@@ -0,0 +1,44 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.countGoodIntegers(3,5), 27)
+  }
+
+  test("test2") {
+    assertEquals(Main.countGoodIntegers(1,4), 2)
+  }
+
+  test("test3") {
+    assertEquals(Main.countGoodIntegers(5,6), 246)
+  }
+
+  test("test4") {
+    assertEquals(Main.countGoodIntegers(2,4), 2)
+  }
+
+  test("test5") {
+    assertEquals(Main.countGoodIntegers(9,6), 12476696)
+  }
+
+  test("test6") {
+    assertEquals(Main.countGoodIntegers(10,5), 19284856)
+  }
+
+  test("test7") {
+    assertEquals(Main.countGoodIntegers(4,5), 52)
+  }
+
+  test("test8") {
+    assertEquals(Main.countGoodIntegers(10,1), 41457024)
+  }
+
+  test("test9") {
+    assertEquals(Main.countGoodIntegers(7,5), 182335)
+  }
+
+  test("test10") {
+    assertEquals(Main.countGoodIntegers(4,7), 76)
+  }
+
+}

find_the_distinct_difference_array/haskell_tests/Main.hs

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

find_the_distinct_difference_array/meta.json

@@ -0,0 +1,481 @@
+{
+    "id": 2777,
+    "name": "find_the_distinct_difference_array",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/find-the-distinct-difference-array/",
+    "date": "2023-04-30 00:00:00",
+    "task_description": "You are given a **0-indexed** array `nums` of length `n`. The **distinct difference** array of `nums` is an array `diff` of length `n` such that `diff[i]` is equal to the number of distinct elements in the suffix `nums[i + 1, ..., n - 1]` **subtracted from** the number of distinct elements in the prefix `nums[0, ..., i]`. Return _the **distinct difference** array of _`nums`. Note that `nums[i, ..., j]` denotes the subarray of `nums` starting at index `i` and ending at index `j` inclusive. Particularly, if `i > j` then `nums[i, ..., j]` denotes an empty subarray. **Example 1:** ``` **Input:** nums = [1,2,3,4,5] **Output:** [-3,-1,1,3,5] **Explanation:** For index i = 0, there is 1 element in the prefix and 4 distinct elements in the suffix. Thus, diff[0] = 1 - 4 = -3. For index i = 1, there are 2 distinct elements in the prefix and 3 distinct elements in the suffix. Thus, diff[1] = 2 - 3 = -1. For index i = 2, there are 3 distinct elements in the prefix and 2 distinct elements in the suffix. Thus, diff[2] = 3 - 2 = 1. For index i = 3, there are 4 distinct elements in the prefix and 1 distinct element in the suffix. Thus, diff[3] = 4 - 1 = 3. For index i = 4, there are 5 distinct elements in the prefix and no elements in the suffix. Thus, diff[4] = 5 - 0 = 5. ``` **Example 2:** ``` **Input:** nums = [3,2,3,4,2] **Output:** [-2,-1,0,2,3] **Explanation:** For index i = 0, there is 1 element in the prefix and 3 distinct elements in the suffix. Thus, diff[0] = 1 - 3 = -2. For index i = 1, there are 2 distinct elements in the prefix and 3 distinct elements in the suffix. Thus, diff[1] = 2 - 3 = -1. For index i = 2, there are 2 distinct elements in the prefix and 2 distinct elements in the suffix. Thus, diff[2] = 2 - 2 = 0. For index i = 3, there are 3 distinct elements in the prefix and 1 distinct element in the suffix. Thus, diff[3] = 3 - 1 = 2. For index i = 4, there are 3 distinct elements in the prefix and no elements in the suffix. Thus, diff[4] = 3 - 0 = 3. ``` **Constraints:** `1 <= n == nums.length <= 50` `1 <= nums[i] <= 50`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "nums = [1,2,3,4,5]",
+            "output": "[-3,-1,1,3,5] "
+        },
+        {
+            "label": "Example 2",
+            "input": "nums = [3,2,3,4,2]",
+            "output": "[-2,-1,0,2,3] "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                44,
+                1,
+                46,
+                10,
+                5,
+                7,
+                50,
+                2,
+                44,
+                32,
+                1,
+                26,
+                34,
+                21,
+                33,
+                30,
+                5,
+                6,
+                33,
+                12,
+                13,
+                1,
+                37
+            ],
+            "output": [
+                -17,
+                -16,
+                -14,
+                -12,
+                -11,
+                -9,
+                -7,
+                -5,
+                -4,
+                -2,
+                -2,
+                0,
+                2,
+                4,
+                5,
+                7,
+                8,
+                10,
+                11,
+                13,
+                15,
+                16,
+                18
+            ]
+        },
+        {
+            "input": [
+                37
+            ],
+            "output": [
+                1
+            ]
+        },
+        {
+            "input": [
+                17,
+                31,
+                15,
+                24,
+                8,
+                5,
+                41,
+                12,
+                33,
+                23,
+                44,
+                3,
+                33,
+                45,
+                45,
+                44,
+                35,
+                37,
+                2,
+                31,
+                11,
+                38,
+                5,
+                10,
+                4,
+                48,
+                35,
+                1,
+                40,
+                3,
+                13
+            ],
+            "output": [
+                -22,
+                -21,
+                -19,
+                -17,
+                -15,
+                -14,
+                -12,
+                -10,
+                -9,
+                -7,
+                -6,
+                -5,
+                -4,
+                -3,
+                -2,
+                -1,
+                0,
+                2,
+                4,
+                5,
+                7,
+                9,
+                10,
+                12,
+                14,
+                16,
+                17,
+                19,
+                21,
+                22,
+                24
+            ]
+        },
+        {
+            "input": [
+                13,
+                1,
+                39,
+                29,
+                17,
+                39
+            ],
+            "output": [
+                -3,
+                -1,
+                0,
+                2,
+                4,
+                5
+            ]
+        },
+        {
+            "input": [
+                14,
+                21,
+                34,
+                43,
+                2,
+                3,
+                48,
+                17,
+                1,
+                16,
+                40,
+                50,
+                27,
+                36,
+                6,
+                28,
+                26,
+                2,
+                44,
+                33,
+                43,
+                6,
+                13,
+                20,
+                21,
+                4,
+                6,
+                41,
+                38,
+                19,
+                39,
+                42,
+                14,
+                7,
+                35,
+                4,
+                39,
+                12,
+                6,
+                10,
+                25,
+                18
+            ],
+            "output": [
+                -32,
+                -31,
+                -29,
+                -28,
+                -27,
+                -25,
+                -23,
+                -21,
+                -19,
+                -17,
+                -15,
+                -13,
+                -11,
+                -9,
+                -8,
+                -6,
+                -4,
+                -3,
+                -1,
+                1,
+                2,
+                2,
+                4,
+                6,
+                7,
+                8,
+                8,
+                10,
+                12,
+                14,
+                15,
+                17,
+                18,
+                20,
+                22,
+                23,
+                24,
+                26,
+                27,
+                29,
+                31,
+                33
+            ]
+        },
+        {
+            "input": [
+                10,
+                8,
+                44,
+                4,
+                33,
+                21,
+                50,
+                46,
+                29,
+                41,
+                45,
+                24,
+                30,
+                10,
+                43,
+                29,
+                38,
+                31,
+                14,
+                7,
+                3,
+                19,
+                27,
+                32,
+                5,
+                43,
+                24,
+                32,
+                6,
+                15,
+                24
+            ],
+            "output": [
+                -24,
+                -22,
+                -20,
+                -18,
+                -16,
+                -14,
+                -12,
+                -10,
+                -9,
+                -7,
+                -5,
+                -4,
+                -2,
+                -1,
+                0,
+                1,
+                3,
+                5,
+                7,
+                9,
+                11,
+                13,
+                15,
+                16,
+                18,
+                19,
+                19,
+                20,
+                22,
+                24,
+                25
+            ]
+        },
+        {
+            "input": [
+                2,
+                2,
+                1,
+                39,
+                18,
+                15,
+                15,
+                3,
+                18,
+                4,
+                47,
+                6,
+                8,
+                26,
+                28,
+                37,
+                30,
+                4,
+                22,
+                2,
+                12,
+                12,
+                32,
+                13,
+                18,
+                39,
+                13
+            ],
+            "output": [
+                -17,
+                -17,
+                -15,
+                -14,
+                -13,
+                -12,
+                -11,
+                -9,
+                -9,
+                -8,
+                -6,
+                -4,
+                -2,
+                0,
+                2,
+                4,
+                6,
+                7,
+                9,
+                10,
+                11,
+                12,
+                14,
+                15,
+                16,
+                17,
+                18
+            ]
+        },
+        {
+            "input": [
+                44,
+                41,
+                17,
+                11,
+                3,
+                21,
+                7,
+                1,
+                23,
+                48,
+                39,
+                41,
+                44,
+                26,
+                28,
+                46,
+                46,
+                9,
+                5,
+                29,
+                38,
+                5,
+                1,
+                4,
+                17
+            ],
+            "output": [
+                -18,
+                -17,
+                -16,
+                -14,
+                -12,
+                -10,
+                -8,
+                -7,
+                -5,
+                -3,
+                -1,
+                0,
+                1,
+                3,
+                5,
+                6,
+                7,
+                9,
+                10,
+                12,
+                14,
+                15,
+                16,
+                18,
+                19
+            ]
+        },
+        {
+            "input": [
+                19,
+                35,
+                2,
+                8,
+                30,
+                46
+            ],
+            "output": [
+                -4,
+                -2,
+                0,
+                2,
+                4,
+                6
+            ]
+        },
+        {
+            "input": [
+                19,
+                41,
+                16,
+                40,
+                20
+            ],
+            "output": [
+                -3,
+                -1,
+                1,
+                3,
+                5
+            ]
+        }
+    ],
+    "haskell_template": "distinctDifferenceArray :: [Int] -> [Int]\ndistinctDifferenceArray nums ",
+    "ocaml_template": "let distinctDifferenceArray (nums: int list) : int list =  ",
+    "scala_template": "def distinctDifferenceArray(nums: List[Int]): List[Int] = { \n    \n}",
+    "java_template": "class Solution {\n    public int[] distinctDifferenceArray(int[] nums) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def distinctDifferenceArray(self, nums):\n        \"\"\"\n        :type nums: List[int]\n        :rtype: List[int]\n        \"\"\"\n        "
+}

find_the_distinct_difference_array/ocaml_tests/main.ml

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

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

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

find_the_divisibility_array_of_a_string/java_tests/Main.java

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

find_the_divisibility_array_of_a_string/ocaml_tests/main.ml

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

find_the_divisibility_array_of_a_string/scala_tests/MySuite.scala

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

find_the_encrypted_string/haskell_tests/Main.hs

@@ -0,0 +1,45 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (getEncryptedString \"dart \" 3)," "tdar" (getEncryptedString "dart" 3))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (getEncryptedString \"aaa \" 1)," "aaa" (getEncryptedString "aaa" 1))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (getEncryptedString  \"rbbuoygmhvmavtzmldkjebyivpuowhrivdwbptxxrmio \" 7741)," "miorbbuoygmhvmavtzmldkjebyivpuowhrivdwbptxxr" (getEncryptedString "rbbuoygmhvmavtzmldkjebyivpuowhrivdwbptxxrmio" 7741))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (getEncryptedString  \"hvhqfefrfsrrnzulrpiwithkpxofnpkulntdhbinzhxqyxkmnffmqytnvoxb \" 2798)," "inzhxqyxkmnffmqytnvoxbhvhqfefrfsrrnzulrpiwithkpxofnpkulntdhb" (getEncryptedString "hvhqfefrfsrrnzulrpiwithkpxofnpkulntdhbinzhxqyxkmnffmqytnvoxb" 2798))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (getEncryptedString  \"zgbvjxqqdqvlqgggyblhcdukedgcayseoppquyjrtrwzclevblddphqzhkozxqe \" 4109)," "ggyblhcdukedgcayseoppquyjrtrwzclevblddphqzhkozxqezgbvjxqqdqvlqg" (getEncryptedString "zgbvjxqqdqvlqgggyblhcdukedgcayseoppquyjrtrwzclevblddphqzhkozxqe" 4109))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (getEncryptedString  \"nxwxpleawbsjapojgdy \" 3352)," "wbsjapojgdynxwxplea" (getEncryptedString "nxwxpleawbsjapojgdy" 3352))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (getEncryptedString  \"dwratwxwsycospwwsvgyapifwgxqsekzkgguhqnlcclmnthlcbebbnoprqjacebuzgzxwkw \" 7103)," "atwxwsycospwwsvgyapifwgxqsekzkgguhqnlcclmnthlcbebbnoprqjacebuzgzxwkwdwr" (getEncryptedString "dwratwxwsycospwwsvgyapifwgxqsekzkgguhqnlcclmnthlcbebbnoprqjacebuzgzxwkw" 7103))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (getEncryptedString  \"xxdstahykrysrgeqhhttsaqfqbwfpdgtymrfxnmkotfswvpzzphhwwjbpfrkgilove \" 328)," "vexxdstahykrysrgeqhhttsaqfqbwfpdgtymrfxnmkotfswvpzzphhwwjbpfrkgilo" (getEncryptedString "xxdstahykrysrgeqhhttsaqfqbwfpdgtymrfxnmkotfswvpzzphhwwjbpfrkgilove" 328))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (getEncryptedString  \"rezrxaokhzkrvtkbmezlcqwjfxbaeeaafdwxzffckzmvshncjipexriwcqnffkbprae \" 7727)," "wjfxbaeeaafdwxzffckzmvshncjipexriwcqnffkbpraerezrxaokhzkrvtkbmezlcq" (getEncryptedString "rezrxaokhzkrvtkbmezlcqwjfxbaeeaafdwxzffckzmvshncjipexriwcqnffkbprae" 7727))
+
+
+-- 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_the_encrypted_string/java_tests/Main.java

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

find_the_encrypted_string/meta.json

@@ -0,0 +1,97 @@
+{
+    "id": 3468,
+    "name": "find_the_encrypted_string",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/find-the-encrypted-string/",
+    "date": "2024-06-30 00:00:00",
+    "task_description": "You are given a string `s` and an integer `k`. Encrypt the string using the following algorithm: For each character `c` in `s`, replace `c` with the `kth` character after `c` in the string (in a cyclic manner). Return the _encrypted string_. **Example 1:** **Input:** s = \"dart\", k = 3 **Output:** \"tdar\" **Explanation:** For `i = 0`, the 3rd character after `'d'` is `'t'`. For `i = 1`, the 3rd character after `'a'` is `'d'`. For `i = 2`, the 3rd character after `'r'` is `'a'`. For `i = 3`, the 3rd character after `'t'` is `'r'`. **Example 2:** **Input:** s = \"aaa\", k = 1 **Output:** \"aaa\" **Explanation:** As all the characters are the same, the encrypted string will also be the same. **Constraints:** `1 <= s.length <= 100` `1 <= k <= 104` `s` consists only of lowercase English letters.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "s = \"dart\", k = 3",
+            "output": "\"tdar\" "
+        },
+        {
+            "label": "Example 2",
+            "input": "s = \"aaa\", k = 1",
+            "output": "\"aaa\" "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                "\"rbbuoygmhvmavtzmldkjebyivpuowhrivdwbptxxrmio\"",
+                7741
+            ],
+            "output": "miorbbuoygmhvmavtzmldkjebyivpuowhrivdwbptxxr"
+        },
+        {
+            "input": [
+                "\"hvhqfefrfsrrnzulrpiwithkpxofnpkulntdhbinzhxqyxkmnffmqytnvoxb\"",
+                2798
+            ],
+            "output": "inzhxqyxkmnffmqytnvoxbhvhqfefrfsrrnzulrpiwithkpxofnpkulntdhb"
+        },
+        {
+            "input": [
+                "\"zgbvjxqqdqvlqgggyblhcdukedgcayseoppquyjrtrwzclevblddphqzhkozxqe\"",
+                4109
+            ],
+            "output": "ggyblhcdukedgcayseoppquyjrtrwzclevblddphqzhkozxqezgbvjxqqdqvlqg"
+        },
+        {
+            "input": [
+                "\"nxwxpleawbsjapojgdy\"",
+                3352
+            ],
+            "output": "wbsjapojgdynxwxplea"
+        },
+        {
+            "input": [
+                "\"dwratwxwsycospwwsvgyapifwgxqsekzkgguhqnlcclmnthlcbebbnoprqjacebuzgzxwkw\"",
+                7103
+            ],
+            "output": "atwxwsycospwwsvgyapifwgxqsekzkgguhqnlcclmnthlcbebbnoprqjacebuzgzxwkwdwr"
+        },
+        {
+            "input": [
+                "\"xxdstahykrysrgeqhhttsaqfqbwfpdgtymrfxnmkotfswvpzzphhwwjbpfrkgilove\"",
+                328
+            ],
+            "output": "vexxdstahykrysrgeqhhttsaqfqbwfpdgtymrfxnmkotfswvpzzphhwwjbpfrkgilo"
+        },
+        {
+            "input": [
+                "\"rezrxaokhzkrvtkbmezlcqwjfxbaeeaafdwxzffckzmvshncjipexriwcqnffkbprae\"",
+                7727
+            ],
+            "output": "wjfxbaeeaafdwxzffckzmvshncjipexriwcqnffkbpraerezrxaokhzkrvtkbmezlcq"
+        },
+        {
+            "input": [
+                "\"hftlmhlrdtkfmlzukcyazjbglrizzhyhupqzxyybtiiddsgzhfqhavqacrlimfhusrrgarplrqwr\"",
+                6417
+            ],
+            "output": "pqzxyybtiiddsgzhfqhavqacrlimfhusrrgarplrqwrhftlmhlrdtkfmlzukcyazjbglrizzhyhu"
+        },
+        {
+            "input": [
+                "iurvokhadhprgjlpdase",
+                4012
+            ],
+            "output": "gjlpdaseiurvokhadhpr"
+        },
+        {
+            "input": [
+                "zlodkbooipzfdfoflitcduiqcbxphftkmcpphnshpldvtad",
+                3091
+            ],
+            "output": "hnshpldvtadzlodkbooipzfdfoflitcduiqcbxphftkmcpp"
+        }
+    ],
+    "haskell_template": "getEncryptedString :: String -> Int -> String\ngetEncryptedString s k ",
+    "ocaml_template": "let getEncryptedString (s: string) (k: int) : string =  ",
+    "scala_template": "def getEncryptedString(s: String,k: Int): String = { \n    \n}",
+    "java_template": "class Solution {\n    public String getEncryptedString(String s, int k) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def getEncryptedString(self, s, k):\n        \"\"\"\n        :type s: str\n        :type k: int\n        :rtype: str\n        \"\"\"\n        "
+}

find_the_encrypted_string/ocaml_tests/main.ml

@@ -0,0 +1,50 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal "tdar" (getEncryptedString "dart" 3)
+
+let test2 _ = assert_equal "aaa" (getEncryptedString "aaa" 1)
+
+let test3 _ = assert_equal "miorbbuoygmhvmavtzmldkjebyivpuowhrivdwbptxxr" (getEncryptedString "rbbuoygmhvmavtzmldkjebyivpuowhrivdwbptxxrmio" 7741)
+
+let test4 _ = assert_equal "inzhxqyxkmnffmqytnvoxbhvhqfefrfsrrnzulrpiwithkpxofnpkulntdhb" (getEncryptedString "hvhqfefrfsrrnzulrpiwithkpxofnpkulntdhbinzhxqyxkmnffmqytnvoxb" 2798)
+
+let test5 _ = assert_equal "ggyblhcdukedgcayseoppquyjrtrwzclevblddphqzhkozxqezgbvjxqqdqvlqg" (getEncryptedString "zgbvjxqqdqvlqgggyblhcdukedgcayseoppquyjrtrwzclevblddphqzhkozxqe" 4109)
+
+let test6 _ = assert_equal "wbsjapojgdynxwxplea" (getEncryptedString "nxwxpleawbsjapojgdy" 3352)
+
+let test7 _ = assert_equal "atwxwsycospwwsvgyapifwgxqsekzkgguhqnlcclmnthlcbebbnoprqjacebuzgzxwkwdwr" (getEncryptedString "dwratwxwsycospwwsvgyapifwgxqsekzkgguhqnlcclmnthlcbebbnoprqjacebuzgzxwkw" 7103)
+
+let test8 _ = assert_equal "vexxdstahykrysrgeqhhttsaqfqbwfpdgtymrfxnmkotfswvpzzphhwwjbpfrkgilo" (getEncryptedString "xxdstahykrysrgeqhhttsaqfqbwfpdgtymrfxnmkotfswvpzzphhwwjbpfrkgilove" 328)
+
+let test9 _ = assert_equal "wjfxbaeeaafdwxzffckzmvshncjipexriwcqnffkbpraerezrxaokhzkrvtkbmezlcq" (getEncryptedString "rezrxaokhzkrvtkbmezlcqwjfxbaeeaafdwxzffckzmvshncjipexriwcqnffkbprae" 7727)
+
+let test10 _ = assert_equal "pqzxyybtiiddsgzhfqhavqacrlimfhusrrgarplrqwrhftlmhlrdtkfmlzukcyazjbglrizzhyhu" (getEncryptedString "hftlmhlrdtkfmlzukcyazjbglrizzhyhupqzxyybtiiddsgzhfqhavqacrlimfhusrrgarplrqwr" 6417)
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for getEncryptedString" >::: [
+        
+  "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_the_encrypted_string/scala_tests/MySuite.scala

@@ -0,0 +1,44 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.getEncryptedString("dart",3), "tdar")
+  }
+
+  test("test2") {
+    assertEquals(Main.getEncryptedString("aaa",1), "aaa")
+  }
+
+  test("test3") {
+    assertEquals(Main.getEncryptedString("rbbuoygmhvmavtzmldkjebyivpuowhrivdwbptxxrmio",7741), "miorbbuoygmhvmavtzmldkjebyivpuowhrivdwbptxxr")
+  }
+
+  test("test4") {
+    assertEquals(Main.getEncryptedString("hvhqfefrfsrrnzulrpiwithkpxofnpkulntdhbinzhxqyxkmnffmqytnvoxb",2798), "inzhxqyxkmnffmqytnvoxbhvhqfefrfsrrnzulrpiwithkpxofnpkulntdhb")
+  }
+
+  test("test5") {
+    assertEquals(Main.getEncryptedString("zgbvjxqqdqvlqgggyblhcdukedgcayseoppquyjrtrwzclevblddphqzhkozxqe",4109), "ggyblhcdukedgcayseoppquyjrtrwzclevblddphqzhkozxqezgbvjxqqdqvlqg")
+  }
+
+  test("test6") {
+    assertEquals(Main.getEncryptedString("nxwxpleawbsjapojgdy",3352), "wbsjapojgdynxwxplea")
+  }
+
+  test("test7") {
+    assertEquals(Main.getEncryptedString("dwratwxwsycospwwsvgyapifwgxqsekzkgguhqnlcclmnthlcbebbnoprqjacebuzgzxwkw",7103), "atwxwsycospwwsvgyapifwgxqsekzkgguhqnlcclmnthlcbebbnoprqjacebuzgzxwkwdwr")
+  }
+
+  test("test8") {
+    assertEquals(Main.getEncryptedString("xxdstahykrysrgeqhhttsaqfqbwfpdgtymrfxnmkotfswvpzzphhwwjbpfrkgilove",328), "vexxdstahykrysrgeqhhttsaqfqbwfpdgtymrfxnmkotfswvpzzphhwwjbpfrkgilo")
+  }
+
+  test("test9") {
+    assertEquals(Main.getEncryptedString("rezrxaokhzkrvtkbmezlcqwjfxbaeeaafdwxzffckzmvshncjipexriwcqnffkbprae",7727), "wjfxbaeeaafdwxzffckzmvshncjipexriwcqnffkbpraerezrxaokhzkrvtkbmezlcq")
+  }
+
+  test("test10") {
+    assertEquals(Main.getEncryptedString("hftlmhlrdtkfmlzukcyazjbglrizzhyhupqzxyybtiiddsgzhfqhavqacrlimfhusrrgarplrqwr",6417), "pqzxyybtiiddsgzhfqhavqacrlimfhusrrgarplrqwrhftlmhlrdtkfmlzukcyazjbglrizzhyhu")
+  }
+
+}

find_the_first_player_to_win_k_games_in_a_row/java_tests/Main.java

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

find_the_first_player_to_win_k_games_in_a_row/meta.json

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

find_the_grid_of_region_average/java_tests/Main.java

@@ -0,0 +1,25 @@
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+import java.util.List;
+import java.util.Arrays;
+import java.util.ArrayList;
+public class Main {
+    //Program start
+    
+    //Program end
+
+    @Test
+public void test1() {
+    assertEquals(new ArrayList<>(Arrays.asList(new ArrayList<>(Arrays.asList(9,9,9,9)),new ArrayList<>(Arrays.asList(9,9,9,9)),new ArrayList<>(Arrays.asList(9,9,9,9)))), resultGrid(new ArrayList<>(Arrays.asList(new ArrayList<>(Arrays.asList(5,6,7,10)),new ArrayList<>(Arrays.asList(8,9,10,10)),new ArrayList<>(Arrays.asList(11,12,13,10)))), 3));
+}
+@Test
+public void test2() {
+    assertEquals(new ArrayList<>(Arrays.asList(new ArrayList<>(Arrays.asList(25,25,25)),new ArrayList<>(Arrays.asList(27,27,27)),new ArrayList<>(Arrays.asList(27,27,27)),new ArrayList<>(Arrays.asList(30,30,30)))), resultGrid(new ArrayList<>(Arrays.asList(new ArrayList<>(Arrays.asList(10,20,30)),new ArrayList<>(Arrays.asList(15,25,35)),new ArrayList<>(Arrays.asList(20,30,40)),new ArrayList<>(Arrays.asList(25,35,45)))), 12));
+}
+@Test
+public void test3() {
+    assertEquals(new ArrayList<>(Arrays.asList(new ArrayList<>(Arrays.asList(5,6,7)),new ArrayList<>(Arrays.asList(8,9,10)),new ArrayList<>(Arrays.asList(11,12,13)))), resultGrid(new ArrayList<>(Arrays.asList(new ArrayList<>(Arrays.asList(5,6,7)),new ArrayList<>(Arrays.asList(8,9,10)),new ArrayList<>(Arrays.asList(11,12,13)))), 1));
+}
+
+}

find_the_integer_added_to_array_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 (addedInteger [2,6,4] [9,7,5])," 3 (addedInteger [2,6,4] [9,7,5]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (addedInteger [10] [5])," (-5) (addedInteger [10] [5]))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (addedInteger [1,1,1,1] [1,1,1,1])," 0 (addedInteger [1,1,1,1] [1,1,1,1]))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (addedInteger [900, 406, 917, 736, 331, 89, 81, 268, 776, 577, 299, 33, 555, 191, 54, 329, 85, 429, 623, 887, 533, 290, 806, 636, 946, 105] [697, 203, 714, 533, 128, ( -114), ( -122), 65, 573, 374, 96, ( -170), 352, ( -12), ( -149), 126, ( -118), 226, 420, 684, 330, 87, 603, 433, 743, ( -98)])," (-203) (addedInteger [900, 406, 917, 736, 331, 89, 81, 268, 776, 577, 299, 33, 555, 191, 54, 329, 85, 429, 623, 887, 533, 290, 806, 636, 946, 105] [697, 203, 714, 533, 128, -114, -122, 65, 573, 374, 96, -170, 352, -12, -149, 126, -118, 226, 420, 684, 330, 87, 603, 433, 743, -98]))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (addedInteger [102, 64, 584, 874, 258, 453, 115, 505, 147, 784, 692, 257, 884, 872, 194, 380, 23, 268, 125, 419, 704, 749, 149, 458, 730, 731, 113, 649, 697, 895, 172, 384, 568, 414, 69, 407, 696, 501, 285, 478, 524, 198, 11, 942, 464, 816, 461, 869, 211] [673, 635, 1155, 1445, 829, 1024, 686, 1076, 718, 1355, 1263, 828, 1455, 1443, 765, 951, 594, 839, 696, 990, 1275, 1320, 720, 1029, 1301, 1302, 684, 1220, 1268, 1466, 743, 955, 1139, 985, 640, 978, 1267, 1072, 856, 1049, 1095, 769, 582, 1513, 1035, 1387, 1032, 1440, 782])," 571 (addedInteger [102, 64, 584, 874, 258, 453, 115, 505, 147, 784, 692, 257, 884, 872, 194, 380, 23, 268, 125, 419, 704, 749, 149, 458, 730, 731, 113, 649, 697, 895, 172, 384, 568, 414, 69, 407, 696, 501, 285, 478, 524, 198, 11, 942, 464, 816, 461, 869, 211] [673, 635, 1155, 1445, 829, 1024, 686, 1076, 718, 1355, 1263, 828, 1455, 1443, 765, 951, 594, 839, 696, 990, 1275, 1320, 720, 1029, 1301, 1302, 684, 1220, 1268, 1466, 743, 955, 1139, 985, 640, 978, 1267, 1072, 856, 1049, 1095, 769, 582, 1513, 1035, 1387, 1032, 1440, 782]))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (addedInteger [728, 220, 82] [1309, 801, 663])," 581 (addedInteger [728, 220, 82] [1309, 801, 663]))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (addedInteger [382, 525, 20, 929, 409, 352, 407, 278, 120, 425, 299, 168, 262, 257, 274, 447, 147, 941, 307, 991, 380, 775, 384, 536, 143, 384, 600, 131, 870, 20, 937, 71, 809, 664, 524, 707, 930, 724, 730, 477, 326, 390, 310] [1308, 1451, 946, 1855, 1335, 1278, 1333, 1204, 1046, 1351, 1225, 1094, 1188, 1183, 1200, 1373, 1073, 1867, 1233, 1917, 1306, 1701, 1310, 1462, 1069, 1310, 1526, 1057, 1796, 946, 1863, 997, 1735, 1590, 1450, 1633, 1856, 1650, 1656, 1403, 1252, 1316, 1236])," 926 (addedInteger [382, 525, 20, 929, 409, 352, 407, 278, 120, 425, 299, 168, 262, 257, 274, 447, 147, 941, 307, 991, 380, 775, 384, 536, 143, 384, 600, 131, 870, 20, 937, 71, 809, 664, 524, 707, 930, 724, 730, 477, 326, 390, 310] [1308, 1451, 946, 1855, 1335, 1278, 1333, 1204, 1046, 1351, 1225, 1094, 1188, 1183, 1200, 1373, 1073, 1867, 1233, 1917, 1306, 1701, 1310, 1462, 1069, 1310, 1526, 1057, 1796, 946, 1863, 997, 1735, 1590, 1450, 1633, 1856, 1650, 1656, 1403, 1252, 1316, 1236]))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (addedInteger [106, 441, 732, 944, 345, 134, 985, 522, 51, 242, 685, 270, 710, 946, 769, 870, 910, 453, 753, 495, 794, 779, 553, 821, 359, 604, 964, 885, 919, 341, 454, 829, 473, 39, 135, 560, 189, 590, 584] [569, 904, 1195, 1407, 808, 597, 1448, 985, 514, 705, 1148, 733, 1173, 1409, 1232, 1333, 1373, 916, 1216, 958, 1257, 1242, 1016, 1284, 822, 1067, 1427, 1348, 1382, 804, 917, 1292, 936, 502, 598, 1023, 652, 1053, 1047])," 463 (addedInteger [106, 441, 732, 944, 345, 134, 985, 522, 51, 242, 685, 270, 710, 946, 769, 870, 910, 453, 753, 495, 794, 779, 553, 821, 359, 604, 964, 885, 919, 341, 454, 829, 473, 39, 135, 560, 189, 590, 584] [569, 904, 1195, 1407, 808, 597, 1448, 985, 514, 705, 1148, 733, 1173, 1409, 1232, 1333, 1373, 916, 1216, 958, 1257, 1242, 1016, 1284, 822, 1067, 1427, 1348, 1382, 804, 917, 1292, 936, 502, 598, 1023, 652, 1053, 1047]))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (addedInteger [181, 844, 69, 52, 815, 368, 150, 273, 872, 972, 198, 926, 818, 534, 488, 182, 708, 254, 89, 601, 769, 401, 340, 593, 28, 429, 25, 624, 594, 406, 479, 171, 556, 757, 988, 478, 763, 833, 795, 382, 374, 936, 572, 509, 169, 781, 745, 538, 905, 632, 868, 274, 758, 955, 468, 771, 192, 627, 77, 606, 971, 571, 409, 381, 932, 810, 508, 143, 735, 616, 233, 367, 396, 413, 119, 970, 96, 637, 325, 188, 421, 551, 547, 443, 570, 428] [808, 1471, 696, 679, 1442, 995, 777, 900, 1499, 1599, 825, 1553, 1445, 1161, 1115, 809, 1335, 881, 716, 1228, 1396, 1028, 967, 1220, 655, 1056, 652, 1251, 1221, 1033, 1106, 798, 1183, 1384, 1615, 1105, 1390, 1460, 1422, 1009, 1001, 1563, 1199, 1136, 796, 1408, 1372, 1165, 1532, 1259, 1495, 901, 1385, 1582, 1095, 1398, 819, 1254, 704, 1233, 1598, 1198, 1036, 1008, 1559, 1437, 1135, 770, 1362, 1243, 860, 994, 1023, 1040, 746, 1597, 723, 1264, 952, 815, 1048, 1178, 1174, 1070, 1197, 1055])," 627 (addedInteger [181, 844, 69, 52, 815, 368, 150, 273, 872, 972, 198, 926, 818, 534, 488, 182, 708, 254, 89, 601, 769, 401, 340, 593, 28, 429, 25, 624, 594, 406, 479, 171, 556, 757, 988, 478, 763, 833, 795, 382, 374, 936, 572, 509, 169, 781, 745, 538, 905, 632, 868, 274, 758, 955, 468, 771, 192, 627, 77, 606, 971, 571, 409, 381, 932, 810, 508, 143, 735, 616, 233, 367, 396, 413, 119, 970, 96, 637, 325, 188, 421, 551, 547, 443, 570, 428] [808, 1471, 696, 679, 1442, 995, 777, 900, 1499, 1599, 825, 1553, 1445, 1161, 1115, 809, 1335, 881, 716, 1228, 1396, 1028, 967, 1220, 655, 1056, 652, 1251, 1221, 1033, 1106, 798, 1183, 1384, 1615, 1105, 1390, 1460, 1422, 1009, 1001, 1563, 1199, 1136, 796, 1408, 1372, 1165, 1532, 1259, 1495, 901, 1385, 1582, 1095, 1398, 819, 1254, 704, 1233, 1598, 1198, 1036, 1008, 1559, 1437, 1135, 770, 1362, 1243, 860, 994, 1023, 1040, 746, 1597, 723, 1264, 952, 815, 1048, 1178, 1174, 1070, 1197, 1055]))
+
+
+-- 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