f7d2bc3d9c9de3eb48f5a72335a4087e03fb4617f3c5ace04dcbcf0adcdb98c9

.gitattributes

@@ -77,3 +77,5 @@ count_array_pairs_divisible_by_k/meta.json filter=lfs diff=lfs merge=lfs -text
 count_connected_components_in_lcm_graph/meta.json filter=lfs diff=lfs merge=lfs -text
 count_days_without_meetings/meta.json filter=lfs diff=lfs merge=lfs -text
 count_good_triplets_in_an_array/meta.json filter=lfs diff=lfs merge=lfs -text
+count_non_decreasing_subarrays_after_k_operations/meta.json filter=lfs diff=lfs merge=lfs -text
+count_number_of_bad_pairs/meta.json filter=lfs diff=lfs merge=lfs -text

count_hills_and_valleys_in_an_array/ocaml_tests/main.ml

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

count_hills_and_valleys_in_an_array/scala_tests/MySuite.scala

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

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

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

count_increasing_quadruplets/ocaml_tests/main.ml

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

count_increasing_quadruplets/scala_tests/MySuite.scala

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

count_k_reducible_numbers_less_than_n/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 (countKReducibleNumbers \"111 \" 1)," 3 (countKReducibleNumbers "111" 1))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (countKReducibleNumbers \"1000 \" 2)," 6 (countKReducibleNumbers "1000" 2))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (countKReducibleNumbers \"1 \" 3)," 0 (countKReducibleNumbers "1" 3))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (countKReducibleNumbers  \"10111011110001110011110001101100110100011100101011001111101100101100001110011011001111011101010111001000001111110111000101011011100101101000011111110110101010100100010110001111001011010101111100100100011101111100100101111010101010000111100101001111110001101011000111010101110001111000100100001010110001010110100110101011100101011101000001011101011111001011101101111001100100010001 \" 2)," 520827334 (countKReducibleNumbers "10111011110001110011110001101100110100011100101011001111101100101100001110011011001111011101010111001000001111110111000101011011100101101000011111110110101010100100010110001111001011010101111100100100011101111100100101111010101010000111100101001111110001101011000111010101110001111000100100001010110001010110100110101011100101011101000001011101011111001011101101111001100100010001" 2))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (countKReducibleNumbers  \"100011111101000101100100100100011101100000100011101111010010110000001010101110011111110110001010100000111011101011111011011001111101101100010110101111010000101111010011100001011101110000110110111111011001100101100110100010111000000101011111100011100001111000110111010101111011011010011010100011101100110000100111111011111100011001011000001101111000010100010001110110110110110010111011001010001101011001110001110101010 \" 5)," 477882612 (countKReducibleNumbers "100011111101000101100100100100011101100000100011101111010010110000001010101110011111110110001010100000111011101011111011011001111101101100010110101111010000101111010011100001011101110000110110111111011001100101100110100010111000000101011111100011100001111000110111010101111011011010011010100011101100110000100111111011111100011001011000001101111000010100010001110110110110110010111011001010001101011001110001110101010" 5))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (countKReducibleNumbers  \"1110010110110111111000101101010100110010010000000111010001101011001110000111001101110101111100110001001000101000110100101010111111000110111010010011011000100101111101110111011110100001001011010101100110011101010101100110001111101110100010000100000001100011110001000100100010010000110000100000010101001001110000100110010000100101000111110100101101110000101101111010000011001111011000110001010101011011001010110101001000100101111101000101001001111101010110111111001011000001011111111011001001100001010111101010111001111010101011100000011000101010011010000001100011100010010 \" 3)," 462393043 (countKReducibleNumbers "1110010110110111111000101101010100110010010000000111010001101011001110000111001101110101111100110001001000101000110100101010111111000110111010010011011000100101111101110111011110100001001011010101100110011101010101100110001111101110100010000100000001100011110001000100100010010000110000100000010101001001110000100110010000100101000111110100101101110000101101111010000011001111011000110001010101011011001010110101001000100101111101000101001001111101010110111111001011000001011111111011001001100001010111101010111001111010101011100000011000101010011010000001100011100010010" 3))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (countKReducibleNumbers  \"1111101111111110011000111111100111010110110101111111101010101101001101100101011010011010100011011011101111111101101000111110010111111111100111101001101001000110111000101000101000111011101000100011110010110110010110100010010101111001100001110100000111111011001011110111100100100111011100001110111001101000101110110010000101100001001111010110100000101110100110110101010101110111011110001101100101000000100110000001101010000010111101000001000011101100100100101101001101011111000110010110110000000000011011000111111111000100001110001100100000110011010111001011001101000011011101010110111110011110101010101011010101011001011010000100011001011011010011110011110000001101000000000101111010100101101100011110000101101010111011001010001101010101100010010101001000110 \" 3)," 443977979 (countKReducibleNumbers "1111101111111110011000111111100111010110110101111111101010101101001101100101011010011010100011011011101111111101101000111110010111111111100111101001101001000110111000101000101000111011101000100011110010110110010110100010010101111001100001110100000111111011001011110111100100100111011100001110111001101000101110110010000101100001001111010110100000101110100110110101010101110111011110001101100101000000100110000001101010000010111101000001000011101100100100101101001101011111000110010110110000000000011011000111111111000100001110001100100000110011010111001011001101000011011101010110111110011110101010101011010101011001011010000100011001011011010011110011110000001101000000000101111010100101101100011110000101101010111011001010001101010101100010010101001000110" 3))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (countKReducibleNumbers  \"11011111110010110010100101110110100010111011100111110000011010111110110110011101001101011110110100110010110101100010010 \" 3)," 334341265 (countKReducibleNumbers "11011111110010110010100101110110100010111011100111110000011010111110110110011101001101011110110100110010110101100010010" 3))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (countKReducibleNumbers  \"1100110011010000110011100111010011111100001110001110100101011011000101111100000001101111110100111000011110100111100101000101001011111010010010001001101001011001011110001001101011010101011000010001100101111100000001111010000101100011111100110111011001100001000010010111011101101010101000000110101111110001000100010111100111100011010001101100110001001110000100101100110110100001100100100011001110100110011001001111100101101100001111011000000100000110110011 \" 5)," 695404935 (countKReducibleNumbers "1100110011010000110011100111010011111100001110001110100101011011000101111100000001101111110100111000011110100111100101000101001011111010010010001001101001011001011110001001101011010101011000010001100101111100000001111010000101100011111100110111011001100001000010010111011101101010101000000110101111110001000100010111100111100011010001101100110001001110000100101100110110100001100100100011001110100110011001001111100101101100001111011000000100000110110011" 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

count_k_reducible_numbers_less_than_n/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(3, countKReducibleNumbers("111", 1));
+}
+@Test
+public void test2() {
+    assertEquals(6, countKReducibleNumbers("1000", 2));
+}
+@Test
+public void test3() {
+    assertEquals(0, countKReducibleNumbers("1", 3));
+}
+
+}

count_k_reducible_numbers_less_than_n/meta.json

@@ -0,0 +1,102 @@
+{
+    "id": 3631,
+    "name": "count_k_reducible_numbers_less_than_n",
+    "difficulty": "Hard",
+    "link": "https://leetcode.com/problems/count-k-reducible-numbers-less-than-n/",
+    "date": "2024-11-03 00:00:00",
+    "task_description": "You are given a **binary** string `s` representing a number `n` in its binary form. You are also given an integer `k`. An integer `x` is called **k-reducible** if performing the following operation **at most** `k` times reduces it to 1: Replace `x` with the **count** of set bits in its binary representation. For example, the binary representation of 6 is `\"110\"`. Applying the operation once reduces it to 2 (since `\"110\"` has two set bits). Applying the operation again to 2 (binary `\"10\"`) reduces it to 1 (since `\"10\"` has one set bit). Return an integer denoting the number of positive integers **less** than `n` that are **k-reducible**. Since the answer may be too large, return it **modulo** `109 + 7`. **Example 1:** **Input:** s = \"111\", k = 1 **Output:** 3 **Explanation: ** `n = 7`. The 1-reducible integers less than 7 are 1, 2, and 4. **Example 2:** **Input:** s = \"1000\", k = 2 **Output:** 6 **Explanation:** `n = 8`. The 2-reducible integers less than 8 are 1, 2, 3, 4, 5, and 6. **Example 3:** **Input:** s = \"1\", k = 3 **Output:** 0 **Explanation:** There are no positive integers less than `n = 1`, so the answer is 0. **Constraints:** `1 <= s.length <= 800` `s` has no leading zeros. `s` consists only of the characters `'0'` and `'1'`. `1 <= k <= 5`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "s = \"111\", k = 1",
+            "output": "3 "
+        },
+        {
+            "label": "Example 2",
+            "input": "s = \"1000\", k = 2",
+            "output": "6 "
+        },
+        {
+            "label": "Example 3",
+            "input": "s = \"1\", k = 3",
+            "output": "0 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                "\"10111011110001110011110001101100110100011100101011001111101100101100001110011011001111011101010111001000001111110111000101011011100101101000011111110110101010100100010110001111001011010101111100100100011101111100100101111010101010000111100101001111110001101011000111010101110001111000100100001010110001010110100110101011100101011101000001011101011111001011101101111001100100010001\"",
+                2
+            ],
+            "output": 520827334
+        },
+        {
+            "input": [
+                "\"100011111101000101100100100100011101100000100011101111010010110000001010101110011111110110001010100000111011101011111011011001111101101100010110101111010000101111010011100001011101110000110110111111011001100101100110100010111000000101011111100011100001111000110111010101111011011010011010100011101100110000100111111011111100011001011000001101111000010100010001110110110110110010111011001010001101011001110001110101010\"",
+                5
+            ],
+            "output": 477882612
+        },
+        {
+            "input": [
+                "\"1110010110110111111000101101010100110010010000000111010001101011001110000111001101110101111100110001001000101000110100101010111111000110111010010011011000100101111101110111011110100001001011010101100110011101010101100110001111101110100010000100000001100011110001000100100010010000110000100000010101001001110000100110010000100101000111110100101101110000101101111010000011001111011000110001010101011011001010110101001000100101111101000101001001111101010110111111001011000001011111111011001001100001010111101010111001111010101011100000011000101010011010000001100011100010010\"",
+                3
+            ],
+            "output": 462393043
+        },
+        {
+            "input": [
+                "\"1111101111111110011000111111100111010110110101111111101010101101001101100101011010011010100011011011101111111101101000111110010111111111100111101001101001000110111000101000101000111011101000100011110010110110010110100010010101111001100001110100000111111011001011110111100100100111011100001110111001101000101110110010000101100001001111010110100000101110100110110101010101110111011110001101100101000000100110000001101010000010111101000001000011101100100100101101001101011111000110010110110000000000011011000111111111000100001110001100100000110011010111001011001101000011011101010110111110011110101010101011010101011001011010000100011001011011010011110011110000001101000000000101111010100101101100011110000101101010111011001010001101010101100010010101001000110\"",
+                3
+            ],
+            "output": 443977979
+        },
+        {
+            "input": [
+                "\"11011111110010110010100101110110100010111011100111110000011010111110110110011101001101011110110100110010110101100010010\"",
+                3
+            ],
+            "output": 334341265
+        },
+        {
+            "input": [
+                "\"1100110011010000110011100111010011111100001110001110100101011011000101111100000001101111110100111000011110100111100101000101001011111010010010001001101001011001011110001001101011010101011000010001100101111100000001111010000101100011111100110111011001100001000010010111011101101010101000000110101111110001000100010111100111100011010001101100110001001110000100101100110110100001100100100011001110100110011001001111100101101100001111011000000100000110110011\"",
+                5
+            ],
+            "output": 695404935
+        },
+        {
+            "input": [
+                "\"1000111111101010010011001010011000111101000011010011001101101011100111010111110100111001011100101010110011000100110010000100111100101111011001011001001010100101000111000110111101110010010001000110001101101100100111011011101010111010011010000010111100111101100010110001000111101000101010110101100011000100111010100100110011000111001100001111011111000010000001011010001100111010010010001111000001000000001011001101010110010100100000000110011000\"",
+                1
+            ],
+            "output": 442
+        },
+        {
+            "input": [
+                "1010010010101010000000110001001001001100001011000110000011001001001000111100110011001101011011101010100100110100111110101011100000",
+                2
+            ],
+            "output": 395325718
+        },
+        {
+            "input": [
+                "11010111100101000011110010111110111001000100111001100001100000101100001001010001011001101011001101101011001101101001011101111",
+                3
+            ],
+            "output": 369901981
+        },
+        {
+            "input": [
+                "11110001001110111010101011000101101001111101111011111101000101111000001010011100100011010110001100101101111110000101011101101010001011000001100010010100100010011001110101000011010101001100100110111100010110100100001111110001110000101110100111011011111111000011110101",
+                2
+            ],
+            "output": 469218050
+        }
+    ],
+    "haskell_template": "countKReducibleNumbers :: String -> Int -> Int\ncountKReducibleNumbers s k ",
+    "ocaml_template": "let countKReducibleNumbers (s: string) (k: int) : int =  ",
+    "scala_template": "def countKReducibleNumbers(s: String,k: Int): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public int countKReducibleNumbers(String s, int k) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def countKReducibleNumbers(self, s, k):\n        \"\"\"\n        :type s: str\n        :type k: int\n        :rtype: int\n        \"\"\"\n        "
+}

count_k_reducible_numbers_less_than_n/ocaml_tests/main.ml

@@ -0,0 +1,50 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 3 (countKReducibleNumbers "111" 1)
+
+let test2 _ = assert_equal 6 (countKReducibleNumbers "1000" 2)
+
+let test3 _ = assert_equal 0 (countKReducibleNumbers "1" 3)
+
+let test4 _ = assert_equal 520827334 (countKReducibleNumbers "10111011110001110011110001101100110100011100101011001111101100101100001110011011001111011101010111001000001111110111000101011011100101101000011111110110101010100100010110001111001011010101111100100100011101111100100101111010101010000111100101001111110001101011000111010101110001111000100100001010110001010110100110101011100101011101000001011101011111001011101101111001100100010001" 2)
+
+let test5 _ = assert_equal 477882612 (countKReducibleNumbers "100011111101000101100100100100011101100000100011101111010010110000001010101110011111110110001010100000111011101011111011011001111101101100010110101111010000101111010011100001011101110000110110111111011001100101100110100010111000000101011111100011100001111000110111010101111011011010011010100011101100110000100111111011111100011001011000001101111000010100010001110110110110110010111011001010001101011001110001110101010" 5)
+
+let test6 _ = assert_equal 462393043 (countKReducibleNumbers "1110010110110111111000101101010100110010010000000111010001101011001110000111001101110101111100110001001000101000110100101010111111000110111010010011011000100101111101110111011110100001001011010101100110011101010101100110001111101110100010000100000001100011110001000100100010010000110000100000010101001001110000100110010000100101000111110100101101110000101101111010000011001111011000110001010101011011001010110101001000100101111101000101001001111101010110111111001011000001011111111011001001100001010111101010111001111010101011100000011000101010011010000001100011100010010" 3)
+
+let test7 _ = assert_equal 443977979 (countKReducibleNumbers "1111101111111110011000111111100111010110110101111111101010101101001101100101011010011010100011011011101111111101101000111110010111111111100111101001101001000110111000101000101000111011101000100011110010110110010110100010010101111001100001110100000111111011001011110111100100100111011100001110111001101000101110110010000101100001001111010110100000101110100110110101010101110111011110001101100101000000100110000001101010000010111101000001000011101100100100101101001101011111000110010110110000000000011011000111111111000100001110001100100000110011010111001011001101000011011101010110111110011110101010101011010101011001011010000100011001011011010011110011110000001101000000000101111010100101101100011110000101101010111011001010001101010101100010010101001000110" 3)
+
+let test8 _ = assert_equal 334341265 (countKReducibleNumbers "11011111110010110010100101110110100010111011100111110000011010111110110110011101001101011110110100110010110101100010010" 3)
+
+let test9 _ = assert_equal 695404935 (countKReducibleNumbers "1100110011010000110011100111010011111100001110001110100101011011000101111100000001101111110100111000011110100111100101000101001011111010010010001001101001011001011110001001101011010101011000010001100101111100000001111010000101100011111100110111011001100001000010010111011101101010101000000110101111110001000100010111100111100011010001101100110001001110000100101100110110100001100100100011001110100110011001001111100101101100001111011000000100000110110011" 5)
+
+let test10 _ = assert_equal 442 (countKReducibleNumbers "1000111111101010010011001010011000111101000011010011001101101011100111010111110100111001011100101010110011000100110010000100111100101111011001011001001010100101000111000110111101110010010001000110001101101100100111011011101010111010011010000010111100111101100010110001000111101000101010110101100011000100111010100100110011000111001100001111011111000010000001011010001100111010010010001111000001000000001011001101010110010100100000000110011000" 1)
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for countKReducibleNumbers" >::: [
+        
+  "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_k_reducible_numbers_less_than_n/scala_tests/MySuite.scala

@@ -0,0 +1,44 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.countKReducibleNumbers("111",1), 3)
+  }
+
+  test("test2") {
+    assertEquals(Main.countKReducibleNumbers("1000",2), 6)
+  }
+
+  test("test3") {
+    assertEquals(Main.countKReducibleNumbers("1",3), 0)
+  }
+
+  test("test4") {
+    assertEquals(Main.countKReducibleNumbers("10111011110001110011110001101100110100011100101011001111101100101100001110011011001111011101010111001000001111110111000101011011100101101000011111110110101010100100010110001111001011010101111100100100011101111100100101111010101010000111100101001111110001101011000111010101110001111000100100001010110001010110100110101011100101011101000001011101011111001011101101111001100100010001",2), 520827334)
+  }
+
+  test("test5") {
+    assertEquals(Main.countKReducibleNumbers("100011111101000101100100100100011101100000100011101111010010110000001010101110011111110110001010100000111011101011111011011001111101101100010110101111010000101111010011100001011101110000110110111111011001100101100110100010111000000101011111100011100001111000110111010101111011011010011010100011101100110000100111111011111100011001011000001101111000010100010001110110110110110010111011001010001101011001110001110101010",5), 477882612)
+  }
+
+  test("test6") {
+    assertEquals(Main.countKReducibleNumbers("1110010110110111111000101101010100110010010000000111010001101011001110000111001101110101111100110001001000101000110100101010111111000110111010010011011000100101111101110111011110100001001011010101100110011101010101100110001111101110100010000100000001100011110001000100100010010000110000100000010101001001110000100110010000100101000111110100101101110000101101111010000011001111011000110001010101011011001010110101001000100101111101000101001001111101010110111111001011000001011111111011001001100001010111101010111001111010101011100000011000101010011010000001100011100010010",3), 462393043)
+  }
+
+  test("test7") {
+    assertEquals(Main.countKReducibleNumbers("1111101111111110011000111111100111010110110101111111101010101101001101100101011010011010100011011011101111111101101000111110010111111111100111101001101001000110111000101000101000111011101000100011110010110110010110100010010101111001100001110100000111111011001011110111100100100111011100001110111001101000101110110010000101100001001111010110100000101110100110110101010101110111011110001101100101000000100110000001101010000010111101000001000011101100100100101101001101011111000110010110110000000000011011000111111111000100001110001100100000110011010111001011001101000011011101010110111110011110101010101011010101011001011010000100011001011011010011110011110000001101000000000101111010100101101100011110000101101010111011001010001101010101100010010101001000110",3), 443977979)
+  }
+
+  test("test8") {
+    assertEquals(Main.countKReducibleNumbers("11011111110010110010100101110110100010111011100111110000011010111110110110011101001101011110110100110010110101100010010",3), 334341265)
+  }
+
+  test("test9") {
+    assertEquals(Main.countKReducibleNumbers("1100110011010000110011100111010011111100001110001110100101011011000101111100000001101111110100111000011110100111100101000101001011111010010010001001101001011001011110001001101011010101011000010001100101111100000001111010000101100011111100110111011001100001000010010111011101101010101000000110101111110001000100010111100111100011010001101100110001001110000100101100110110100001100100100011001110100110011001001111100101101100001111011000000100000110110011",5), 695404935)
+  }
+
+  test("test10") {
+    assertEquals(Main.countKReducibleNumbers("1000111111101010010011001010011000111101000011010011001101101011100111010111110100111001011100101010110011000100110010000100111100101111011001011001001010100101000111000110111101110010010001000110001101101100100111011011101010111010011010000010111100111101100010110001000111101000101010110101100011000100111010100100110011000111001100001111011111000010000001011010001100111010010010001111000001000000001011001101010110010100100000000110011000",1), 442)
+  }
+
+}

count_k_subsequences_of_a_string_with_maximum_beauty/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, countKSubsequencesWithMaxBeauty("bcca", 2));
+}
+@Test
+public void test2() {
+    assertEquals(2, countKSubsequencesWithMaxBeauty("abbcd", 4));
+}
+
+}

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

count_lattice_points_inside_a_circle/java_tests/Main.java

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

count_lattice_points_inside_a_circle/meta.json

@@ -0,0 +1,3807 @@
+{
+    "id": 2332,
+    "name": "count_lattice_points_inside_a_circle",
+    "difficulty": "Medium",
+    "link": "https://leetcode.com/problems/count-lattice-points-inside-a-circle/",
+    "date": "1650153600000",
+    "task_description": "Given a 2D integer array `circles` where `circles[i] = [xi, yi, ri]` represents the center `(xi, yi)` and radius `ri` of the `ith` circle drawn on a grid, return _the **number of lattice points** __that are present inside **at least one** circle_. **Note:** A **lattice point** is a point with integer coordinates. Points that lie **on the circumference of a circle** are also considered to be inside it. **Example 1:** ``` **Input:** circles = [[2,2,1]] **Output:** 5 **Explanation:** The figure above shows the given circle. The lattice points present inside the circle are (1, 2), (2, 1), (2, 2), (2, 3), and (3, 2) and are shown in green. Other points such as (1, 1) and (1, 3), which are shown in red, are not considered inside the circle. Hence, the number of lattice points present inside at least one circle is 5. ``` **Example 2:** ``` **Input:** circles = [[2,2,2],[3,4,1]] **Output:** 16 **Explanation:** The figure above shows the given circles. There are exactly 16 lattice points which are present inside at least one circle. Some of them are (0, 2), (2, 0), (2, 4), (3, 2), and (4, 4). ``` **Constraints:** `1 <= circles.length <= 200` `circles[i].length == 3` `1 <= xi, yi <= 100` `1 <= ri <= min(xi, yi)`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "circles = [[2,2,1]]",
+            "output": "5 "
+        },
+        {
+            "label": "Example 2",
+            "input": "circles = [[2,2,2],[3,4,1]]",
+            "output": "16 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                [
+                    49,
+                    54,
+                    28
+                ],
+                [
+                    56,
+                    46,
+                    44
+                ],
+                [
+                    29,
+                    92,
+                    23
+                ],
+                [
+                    38,
+                    75,
+                    11
+                ],
+                [
+                    54,
+                    23,
+                    22
+                ],
+                [
+                    63,
+                    53,
+                    40
+                ],
+                [
+                    74,
+                    28,
+                    16
+                ],
+                [
+                    100,
+                    99,
+                    34
+                ],
+                [
+                    62,
+                    64,
+                    26
+                ],
+                [
+                    28,
+                    80,
+                    8
+                ],
+                [
+                    34,
+                    90,
+                    5
+                ],
+                [
+                    79,
+                    54,
+                    40
+                ],
+                [
+                    24,
+                    13,
+                    5
+                ],
+                [
+                    68,
+                    16,
+                    12
+                ],
+                [
+                    73,
+                    65,
+                    38
+                ],
+                [
+                    23,
+                    74,
+                    12
+                ],
+                [
+                    43,
+                    93,
+                    4
+                ],
+                [
+                    71,
+                    63,
+                    62
+                ],
+                [
+                    20,
+                    10,
+                    9
+                ],
+                [
+                    19,
+                    15,
+                    12
+                ],
+                [
+                    79,
+                    38,
+                    18
+                ],
+                [
+                    32,
+                    53,
+                    31
+                ],
+                [
+                    66,
+                    42,
+                    25
+                ],
+                [
+                    52,
+                    43,
+                    4
+                ],
+                [
+                    99,
+                    51,
+                    19
+                ],
+                [
+                    23,
+                    67,
+                    7
+                ]
+            ],
+            "output": 14313
+        },
+        {
+            "input": [
+                [
+                    15,
+                    84,
+                    15
+                ],
+                [
+                    8,
+                    13,
+                    7
+                ],
+                [
+                    1,
+                    50,
+                    1
+                ],
+                [
+                    15,
+                    51,
+                    6
+                ],
+                [
+                    20,
+                    72,
+                    7
+                ],
+                [
+                    55,
+                    23,
+                    2
+                ],
+                [
+                    86,
+                    28,
+                    6
+                ],
+                [
+                    49,
+                    99,
+                    31
+                ],
+                [
+                    75,
+                    54,
+                    19
+                ],
+                [
+                    91,
+                    63,
+                    56
+                ],
+                [
+                    22,
+                    56,
+                    11
+                ],
+                [
+                    100,
+                    18,
+                    8
+                ],
+                [
+                    72,
+                    27,
+                    15
+                ],
+                [
+                    44,
+                    23,
+                    20
+                ],
+                [
+                    10,
+                    50,
+                    6
+                ],
+                [
+                    33,
+                    79,
+                    25
+                ],
+                [
+                    77,
+                    16,
+                    10
+                ],
+                [
+                    76,
+                    90,
+                    73
+                ],
+                [
+                    53,
+                    20,
+                    12
+                ],
+                [
+                    50,
+                    74,
+                    10
+                ],
+                [
+                    54,
+                    32,
+                    6
+                ],
+                [
+                    96,
+                    18,
+                    3
+                ],
+                [
+                    94,
+                    1,
+                    1
+                ],
+                [
+                    94,
+                    17,
+                    3
+                ],
+                [
+                    36,
+                    89,
+                    36
+                ],
+                [
+                    53,
+                    44,
+                    34
+                ],
+                [
+                    68,
+                    76,
+                    28
+                ],
+                [
+                    50,
+                    99,
+                    15
+                ],
+                [
+                    65,
+                    85,
+                    27
+                ],
+                [
+                    63,
+                    45,
+                    35
+                ],
+                [
+                    21,
+                    3,
+                    2
+                ],
+                [
+                    14,
+                    94,
+                    1
+                ],
+                [
+                    32,
+                    69,
+                    17
+                ],
+                [
+                    3,
+                    55,
+                    3
+                ],
+                [
+                    30,
+                    72,
+                    16
+                ],
+                [
+                    4,
+                    96,
+                    2
+                ],
+                [
+                    45,
+                    79,
+                    36
+                ],
+                [
+                    65,
+                    95,
+                    24
+                ],
+                [
+                    46,
+                    65,
+                    34
+                ],
+                [
+                    79,
+                    7,
+                    5
+                ],
+                [
+                    36,
+                    11,
+                    6
+                ],
+                [
+                    96,
+                    66,
+                    45
+                ],
+                [
+                    11,
+                    27,
+                    3
+                ],
+                [
+                    46,
+                    21,
+                    21
+                ],
+                [
+                    17,
+                    80,
+                    13
+                ],
+                [
+                    23,
+                    80,
+                    10
+                ],
+                [
+                    69,
+                    67,
+                    18
+                ],
+                [
+                    64,
+                    56,
+                    3
+                ],
+                [
+                    73,
+                    81,
+                    31
+                ],
+                [
+                    68,
+                    61,
+                    44
+                ],
+                [
+                    22,
+                    37,
+                    11
+                ],
+                [
+                    81,
+                    4,
+                    1
+                ],
+                [
+                    3,
+                    28,
+                    1
+                ],
+                [
+                    21,
+                    68,
+                    16
+                ],
+                [
+                    99,
+                    22,
+                    3
+                ],
+                [
+                    64,
+                    71,
+                    16
+                ],
+                [
+                    44,
+                    97,
+                    13
+                ],
+                [
+                    12,
+                    10,
+                    4
+                ],
+                [
+                    88,
+                    38,
+                    15
+                ],
+                [
+                    14,
+                    17,
+                    8
+                ],
+                [
+                    46,
+                    82,
+                    6
+                ],
+                [
+                    51,
+                    17,
+                    2
+                ],
+                [
+                    51,
+                    90,
+                    29
+                ],
+                [
+                    60,
+                    51,
+                    29
+                ],
+                [
+                    39,
+                    95,
+                    37
+                ],
+                [
+                    58,
+                    60,
+                    50
+                ],
+                [
+                    8,
+                    33,
+                    8
+                ],
+                [
+                    78,
+                    71,
+                    33
+                ],
+                [
+                    78,
+                    18,
+                    1
+                ],
+                [
+                    84,
+                    90,
+                    6
+                ],
+                [
+                    42,
+                    45,
+                    15
+                ],
+                [
+                    2,
+                    36,
+                    1
+                ],
+                [
+                    23,
+                    69,
+                    15
+                ],
+                [
+                    45,
+                    44,
+                    39
+                ],
+                [
+                    47,
+                    99,
+                    4
+                ],
+                [
+                    86,
+                    74,
+                    35
+                ],
+                [
+                    85,
+                    36,
+                    12
+                ],
+                [
+                    33,
+                    65,
+                    33
+                ],
+                [
+                    95,
+                    49,
+                    35
+                ],
+                [
+                    17,
+                    32,
+                    10
+                ],
+                [
+                    61,
+                    4,
+                    2
+                ],
+                [
+                    40,
+                    39,
+                    14
+                ],
+                [
+                    46,
+                    27,
+                    11
+                ],
+                [
+                    51,
+                    42,
+                    29
+                ],
+                [
+                    91,
+                    99,
+                    72
+                ],
+                [
+                    71,
+                    59,
+                    12
+                ],
+                [
+                    9,
+                    93,
+                    5
+                ],
+                [
+                    57,
+                    65,
+                    51
+                ],
+                [
+                    45,
+                    71,
+                    17
+                ]
+            ],
+            "output": 22078
+        },
+        {
+            "input": [
+                [
+                    42,
+                    42,
+                    32
+                ],
+                [
+                    35,
+                    14,
+                    11
+                ],
+                [
+                    55,
+                    52,
+                    33
+                ],
+                [
+                    92,
+                    19,
+                    11
+                ],
+                [
+                    62,
+                    69,
+                    38
+                ],
+                [
+                    19,
+                    16,
+                    5
+                ],
+                [
+                    23,
+                    92,
+                    1
+                ],
+                [
+                    43,
+                    83,
+                    14
+                ],
+                [
+                    80,
+                    17,
+                    5
+                ],
+                [
+                    90,
+                    63,
+                    17
+                ],
+                [
+                    81,
+                    70,
+                    50
+                ],
+                [
+                    100,
+                    67,
+                    34
+                ],
+                [
+                    9,
+                    78,
+                    4
+                ],
+                [
+                    45,
+                    24,
+                    15
+                ],
+                [
+                    48,
+                    49,
+                    9
+                ]
+            ],
+            "output": 10368
+        },
+        {
+            "input": [
+                [
+                    39,
+                    60,
+                    39
+                ],
+                [
+                    94,
+                    48,
+                    22
+                ],
+                [
+                    58,
+                    95,
+                    15
+                ],
+                [
+                    9,
+                    21,
+                    1
+                ],
+                [
+                    1,
+                    58,
+                    1
+                ],
+                [
+                    35,
+                    45,
+                    15
+                ],
+                [
+                    23,
+                    3,
+                    3
+                ],
+                [
+                    53,
+                    1,
+                    1
+                ],
+                [
+                    29,
+                    21,
+                    3
+                ],
+                [
+                    5,
+                    4,
+                    3
+                ],
+                [
+                    82,
+                    10,
+                    2
+                ],
+                [
+                    12,
+                    62,
+                    6
+                ],
+                [
+                    56,
+                    6,
+                    4
+                ],
+                [
+                    62,
+                    45,
+                    28
+                ],
+                [
+                    74,
+                    75,
+                    19
+                ],
+                [
+                    48,
+                    12,
+                    9
+                ],
+                [
+                    39,
+                    65,
+                    24
+                ],
+                [
+                    17,
+                    18,
+                    14
+                ]
+            ],
+            "output": 8348
+        },
+        {
+            "input": [
+                [
+                    23,
+                    7,
+                    2
+                ],
+                [
+                    24,
+                    54,
+                    11
+                ],
+                [
+                    73,
+                    47,
+                    9
+                ],
+                [
+                    1,
+                    39,
+                    1
+                ],
+                [
+                    58,
+                    26,
+                    18
+                ],
+                [
+                    27,
+                    74,
+                    18
+                ],
+                [
+                    33,
+                    30,
+                    15
+                ],
+                [
+                    97,
+                    43,
+                    16
+                ],
+                [
+                    20,
+                    88,
+                    10
+                ],
+                [
+                    16,
+                    91,
+                    13
+                ],
+                [
+                    35,
+                    59,
+                    27
+                ],
+                [
+                    91,
+                    68,
+                    12
+                ],
+                [
+                    80,
+                    37,
+                    12
+                ],
+                [
+                    2,
+                    95,
+                    2
+                ],
+                [
+                    32,
+                    91,
+                    18
+                ],
+                [
+                    52,
+                    44,
+                    30
+                ],
+                [
+                    91,
+                    82,
+                    7
+                ],
+                [
+                    76,
+                    94,
+                    63
+                ],
+                [
+                    67,
+                    34,
+                    14
+                ],
+                [
+                    27,
+                    46,
+                    20
+                ],
+                [
+                    93,
+                    49,
+                    7
+                ],
+                [
+                    11,
+                    34,
+                    10
+                ],
+                [
+                    100,
+                    45,
+                    39
+                ],
+                [
+                    76,
+                    98,
+                    46
+                ],
+                [
+                    72,
+                    29,
+                    12
+                ],
+                [
+                    78,
+                    10,
+                    8
+                ],
+                [
+                    55,
+                    28,
+                    18
+                ],
+                [
+                    59,
+                    62,
+                    35
+                ],
+                [
+                    73,
+                    88,
+                    26
+                ],
+                [
+                    29,
+                    45,
+                    22
+                ],
+                [
+                    8,
+                    73,
+                    8
+                ],
+                [
+                    36,
+                    19,
+                    2
+                ],
+                [
+                    67,
+                    93,
+                    40
+                ],
+                [
+                    46,
+                    66,
+                    6
+                ],
+                [
+                    54,
+                    100,
+                    13
+                ],
+                [
+                    44,
+                    54,
+                    23
+                ],
+                [
+                    98,
+                    90,
+                    70
+                ],
+                [
+                    73,
+                    4,
+                    3
+                ],
+                [
+                    98,
+                    74,
+                    15
+                ],
+                [
+                    22,
+                    88,
+                    18
+                ],
+                [
+                    82,
+                    29,
+                    4
+                ],
+                [
+                    14,
+                    99,
+                    1
+                ],
+                [
+                    22,
+                    78,
+                    20
+                ],
+                [
+                    47,
+                    29,
+                    14
+                ],
+                [
+                    37,
+                    20,
+                    19
+                ],
+                [
+                    60,
+                    22,
+                    11
+                ],
+                [
+                    79,
+                    59,
+                    20
+                ],
+                [
+                    81,
+                    45,
+                    29
+                ],
+                [
+                    38,
+                    93,
+                    7
+                ],
+                [
+                    84,
+                    56,
+                    43
+                ],
+                [
+                    81,
+                    74,
+                    63
+                ],
+                [
+                    7,
+                    82,
+                    7
+                ],
+                [
+                    49,
+                    48,
+                    34
+                ],
+                [
+                    52,
+                    31,
+                    17
+                ],
+                [
+                    31,
+                    21,
+                    1
+                ],
+                [
+                    100,
+                    23,
+                    20
+                ],
+                [
+                    88,
+                    46,
+                    43
+                ],
+                [
+                    27,
+                    99,
+                    21
+                ],
+                [
+                    35,
+                    33,
+                    11
+                ],
+                [
+                    10,
+                    61,
+                    7
+                ],
+                [
+                    63,
+                    11,
+                    9
+                ],
+                [
+                    39,
+                    63,
+                    12
+                ],
+                [
+                    88,
+                    51,
+                    35
+                ],
+                [
+                    15,
+                    34,
+                    12
+                ],
+                [
+                    41,
+                    13,
+                    7
+                ],
+                [
+                    84,
+                    37,
+                    9
+                ],
+                [
+                    38,
+                    24,
+                    9
+                ],
+                [
+                    5,
+                    21,
+                    2
+                ],
+                [
+                    99,
+                    31,
+                    28
+                ],
+                [
+                    55,
+                    61,
+                    8
+                ],
+                [
+                    68,
+                    38,
+                    28
+                ],
+                [
+                    70,
+                    74,
+                    68
+                ],
+                [
+                    61,
+                    29,
+                    16
+                ],
+                [
+                    87,
+                    15,
+                    6
+                ],
+                [
+                    12,
+                    77,
+                    8
+                ],
+                [
+                    67,
+                    11,
+                    5
+                ],
+                [
+                    15,
+                    91,
+                    6
+                ],
+                [
+                    69,
+                    82,
+                    68
+                ],
+                [
+                    8,
+                    90,
+                    2
+                ],
+                [
+                    90,
+                    78,
+                    78
+                ],
+                [
+                    82,
+                    15,
+                    2
+                ],
+                [
+                    18,
+                    34,
+                    12
+                ],
+                [
+                    20,
+                    91,
+                    13
+                ],
+                [
+                    1,
+                    98,
+                    1
+                ],
+                [
+                    4,
+                    82,
+                    3
+                ],
+                [
+                    74,
+                    31,
+                    7
+                ],
+                [
+                    1,
+                    99,
+                    1
+                ],
+                [
+                    28,
+                    98,
+                    17
+                ],
+                [
+                    19,
+                    91,
+                    11
+                ],
+                [
+                    55,
+                    89,
+                    39
+                ],
+                [
+                    34,
+                    80,
+                    3
+                ],
+                [
+                    52,
+                    62,
+                    47
+                ],
+                [
+                    64,
+                    74,
+                    11
+                ],
+                [
+                    14,
+                    25,
+                    4
+                ],
+                [
+                    56,
+                    72,
+                    8
+                ],
+                [
+                    4,
+                    2,
+                    1
+                ],
+                [
+                    18,
+                    12,
+                    11
+                ],
+                [
+                    23,
+                    43,
+                    7
+                ],
+                [
+                    85,
+                    69,
+                    69
+                ],
+                [
+                    13,
+                    99,
+                    12
+                ],
+                [
+                    32,
+                    85,
+                    1
+                ],
+                [
+                    47,
+                    93,
+                    46
+                ],
+                [
+                    70,
+                    80,
+                    31
+                ],
+                [
+                    54,
+                    81,
+                    16
+                ],
+                [
+                    7,
+                    88,
+                    2
+                ],
+                [
+                    66,
+                    59,
+                    49
+                ],
+                [
+                    65,
+                    96,
+                    16
+                ],
+                [
+                    37,
+                    11,
+                    6
+                ],
+                [
+                    33,
+                    58,
+                    3
+                ],
+                [
+                    65,
+                    59,
+                    54
+                ],
+                [
+                    53,
+                    68,
+                    36
+                ],
+                [
+                    29,
+                    21,
+                    17
+                ],
+                [
+                    53,
+                    3,
+                    1
+                ],
+                [
+                    50,
+                    67,
+                    8
+                ],
+                [
+                    49,
+                    59,
+                    33
+                ],
+                [
+                    2,
+                    79,
+                    1
+                ],
+                [
+                    79,
+                    18,
+                    12
+                ],
+                [
+                    95,
+                    59,
+                    3
+                ],
+                [
+                    61,
+                    12,
+                    4
+                ],
+                [
+                    68,
+                    40,
+                    7
+                ],
+                [
+                    43,
+                    78,
+                    31
+                ],
+                [
+                    26,
+                    63,
+                    13
+                ],
+                [
+                    26,
+                    65,
+                    18
+                ],
+                [
+                    27,
+                    52,
+                    22
+                ],
+                [
+                    51,
+                    97,
+                    17
+                ],
+                [
+                    99,
+                    2,
+                    2
+                ],
+                [
+                    32,
+                    14,
+                    10
+                ],
+                [
+                    37,
+                    10,
+                    8
+                ],
+                [
+                    42,
+                    60,
+                    42
+                ],
+                [
+                    8,
+                    6,
+                    1
+                ],
+                [
+                    54,
+                    42,
+                    15
+                ],
+                [
+                    16,
+                    59,
+                    11
+                ]
+            ],
+            "output": 22509
+        },
+        {
+            "input": [
+                [
+                    83,
+                    22,
+                    5
+                ],
+                [
+                    9,
+                    35,
+                    9
+                ],
+                [
+                    61,
+                    79,
+                    56
+                ],
+                [
+                    72,
+                    98,
+                    69
+                ],
+                [
+                    81,
+                    99,
+                    49
+                ],
+                [
+                    40,
+                    42,
+                    2
+                ],
+                [
+                    10,
+                    41,
+                    7
+                ],
+                [
+                    25,
+                    32,
+                    8
+                ],
+                [
+                    2,
+                    50,
+                    1
+                ],
+                [
+                    12,
+                    60,
+                    7
+                ],
+                [
+                    17,
+                    65,
+                    7
+                ],
+                [
+                    30,
+                    22,
+                    6
+                ],
+                [
+                    92,
+                    29,
+                    15
+                ],
+                [
+                    20,
+                    36,
+                    9
+                ],
+                [
+                    24,
+                    60,
+                    21
+                ],
+                [
+                    43,
+                    18,
+                    11
+                ],
+                [
+                    10,
+                    84,
+                    7
+                ],
+                [
+                    50,
+                    34,
+                    23
+                ],
+                [
+                    93,
+                    70,
+                    68
+                ],
+                [
+                    61,
+                    90,
+                    42
+                ],
+                [
+                    99,
+                    21,
+                    9
+                ],
+                [
+                    4,
+                    38,
+                    2
+                ],
+                [
+                    96,
+                    37,
+                    35
+                ],
+                [
+                    3,
+                    56,
+                    3
+                ],
+                [
+                    72,
+                    89,
+                    12
+                ],
+                [
+                    79,
+                    55,
+                    29
+                ],
+                [
+                    41,
+                    75,
+                    3
+                ],
+                [
+                    75,
+                    30,
+                    14
+                ],
+                [
+                    92,
+                    68,
+                    37
+                ],
+                [
+                    26,
+                    47,
+                    19
+                ],
+                [
+                    48,
+                    35,
+                    10
+                ],
+                [
+                    87,
+                    48,
+                    1
+                ],
+                [
+                    39,
+                    15,
+                    13
+                ],
+                [
+                    10,
+                    72,
+                    8
+                ],
+                [
+                    30,
+                    69,
+                    3
+                ],
+                [
+                    73,
+                    97,
+                    58
+                ],
+                [
+                    7,
+                    73,
+                    2
+                ],
+                [
+                    56,
+                    15,
+                    11
+                ],
+                [
+                    49,
+                    18,
+                    2
+                ],
+                [
+                    66,
+                    15,
+                    12
+                ],
+                [
+                    100,
+                    54,
+                    30
+                ],
+                [
+                    82,
+                    48,
+                    14
+                ],
+                [
+                    73,
+                    66,
+                    31
+                ],
+                [
+                    25,
+                    20,
+                    15
+                ],
+                [
+                    80,
+                    87,
+                    33
+                ],
+                [
+                    70,
+                    53,
+                    41
+                ],
+                [
+                    72,
+                    90,
+                    54
+                ],
+                [
+                    1,
+                    85,
+                    1
+                ],
+                [
+                    74,
+                    68,
+                    35
+                ],
+                [
+                    61,
+                    27,
+                    16
+                ]
+            ],
+            "output": 21406
+        },
+        {
+            "input": [
+                [
+                    85,
+                    73,
+                    48
+                ],
+                [
+                    43,
+                    38,
+                    5
+                ],
+                [
+                    35,
+                    51,
+                    28
+                ],
+                [
+                    37,
+                    38,
+                    32
+                ],
+                [
+                    68,
+                    58,
+                    6
+                ],
+                [
+                    44,
+                    61,
+                    5
+                ],
+                [
+                    9,
+                    89,
+                    7
+                ],
+                [
+                    73,
+                    60,
+                    46
+                ],
+                [
+                    35,
+                    16,
+                    15
+                ],
+                [
+                    29,
+                    96,
+                    19
+                ],
+                [
+                    97,
+                    89,
+                    57
+                ],
+                [
+                    44,
+                    89,
+                    29
+                ],
+                [
+                    56,
+                    32,
+                    2
+                ],
+                [
+                    45,
+                    3,
+                    2
+                ],
+                [
+                    99,
+                    20,
+                    9
+                ],
+                [
+                    100,
+                    80,
+                    24
+                ],
+                [
+                    36,
+                    9,
+                    1
+                ],
+                [
+                    14,
+                    90,
+                    12
+                ],
+                [
+                    47,
+                    79,
+                    13
+                ],
+                [
+                    68,
+                    58,
+                    20
+                ],
+                [
+                    20,
+                    68,
+                    20
+                ],
+                [
+                    97,
+                    54,
+                    29
+                ],
+                [
+                    22,
+                    30,
+                    8
+                ],
+                [
+                    66,
+                    23,
+                    22
+                ],
+                [
+                    89,
+                    66,
+                    15
+                ],
+                [
+                    76,
+                    94,
+                    57
+                ],
+                [
+                    35,
+                    26,
+                    22
+                ],
+                [
+                    25,
+                    89,
+                    1
+                ],
+                [
+                    83,
+                    71,
+                    61
+                ],
+                [
+                    26,
+                    25,
+                    14
+                ],
+                [
+                    15,
+                    62,
+                    5
+                ],
+                [
+                    58,
+                    77,
+                    45
+                ],
+                [
+                    90,
+                    30,
+                    21
+                ],
+                [
+                    84,
+                    100,
+                    79
+                ],
+                [
+                    14,
+                    93,
+                    12
+                ],
+                [
+                    96,
+                    96,
+                    88
+                ],
+                [
+                    2,
+                    63,
+                    2
+                ],
+                [
+                    1,
+                    94,
+                    1
+                ],
+                [
+                    42,
+                    100,
+                    18
+                ],
+                [
+                    38,
+                    40,
+                    2
+                ],
+                [
+                    77,
+                    43,
+                    15
+                ],
+                [
+                    48,
+                    38,
+                    25
+                ],
+                [
+                    8,
+                    6,
+                    4
+                ],
+                [
+                    5,
+                    22,
+                    1
+                ],
+                [
+                    38,
+                    79,
+                    15
+                ],
+                [
+                    44,
+                    15,
+                    8
+                ],
+                [
+                    20,
+                    14,
+                    9
+                ],
+                [
+                    9,
+                    28,
+                    4
+                ],
+                [
+                    91,
+                    60,
+                    51
+                ],
+                [
+                    85,
+                    3,
+                    1
+                ],
+                [
+                    43,
+                    98,
+                    21
+                ],
+                [
+                    7,
+                    37,
+                    7
+                ],
+                [
+                    42,
+                    57,
+                    36
+                ],
+                [
+                    22,
+                    87,
+                    6
+                ],
+                [
+                    70,
+                    89,
+                    16
+                ],
+                [
+                    98,
+                    61,
+                    3
+                ],
+                [
+                    11,
+                    22,
+                    10
+                ],
+                [
+                    8,
+                    23,
+                    8
+                ],
+                [
+                    14,
+                    40,
+                    4
+                ],
+                [
+                    51,
+                    48,
+                    19
+                ],
+                [
+                    80,
+                    76,
+                    31
+                ],
+                [
+                    52,
+                    99,
+                    6
+                ],
+                [
+                    53,
+                    98,
+                    49
+                ],
+                [
+                    14,
+                    24,
+                    14
+                ],
+                [
+                    61,
+                    18,
+                    12
+                ],
+                [
+                    86,
+                    12,
+                    12
+                ],
+                [
+                    92,
+                    63,
+                    18
+                ],
+                [
+                    19,
+                    79,
+                    5
+                ],
+                [
+                    85,
+                    23,
+                    11
+                ],
+                [
+                    8,
+                    12,
+                    3
+                ],
+                [
+                    12,
+                    93,
+                    5
+                ],
+                [
+                    78,
+                    58,
+                    23
+                ],
+                [
+                    98,
+                    4,
+                    1
+                ],
+                [
+                    62,
+                    90,
+                    53
+                ],
+                [
+                    92,
+                    44,
+                    7
+                ],
+                [
+                    86,
+                    97,
+                    69
+                ],
+                [
+                    22,
+                    52,
+                    11
+                ],
+                [
+                    59,
+                    32,
+                    6
+                ],
+                [
+                    36,
+                    71,
+                    8
+                ],
+                [
+                    70,
+                    78,
+                    42
+                ],
+                [
+                    99,
+                    65,
+                    33
+                ],
+                [
+                    64,
+                    69,
+                    18
+                ],
+                [
+                    39,
+                    24,
+                    14
+                ],
+                [
+                    62,
+                    11,
+                    2
+                ],
+                [
+                    44,
+                    94,
+                    42
+                ],
+                [
+                    30,
+                    95,
+                    10
+                ],
+                [
+                    57,
+                    46,
+                    23
+                ],
+                [
+                    73,
+                    40,
+                    2
+                ],
+                [
+                    97,
+                    96,
+                    53
+                ],
+                [
+                    70,
+                    81,
+                    17
+                ],
+                [
+                    10,
+                    20,
+                    1
+                ],
+                [
+                    99,
+                    24,
+                    20
+                ],
+                [
+                    84,
+                    97,
+                    31
+                ],
+                [
+                    24,
+                    43,
+                    23
+                ],
+                [
+                    35,
+                    31,
+                    13
+                ],
+                [
+                    79,
+                    55,
+                    15
+                ],
+                [
+                    10,
+                    3,
+                    2
+                ],
+                [
+                    77,
+                    53,
+                    48
+                ],
+                [
+                    30,
+                    35,
+                    1
+                ],
+                [
+                    66,
+                    27,
+                    14
+                ],
+                [
+                    54,
+                    90,
+                    49
+                ],
+                [
+                    56,
+                    74,
+                    25
+                ],
+                [
+                    79,
+                    97,
+                    76
+                ],
+                [
+                    11,
+                    66,
+                    11
+                ],
+                [
+                    11,
+                    53,
+                    8
+                ],
+                [
+                    42,
+                    56,
+                    32
+                ],
+                [
+                    10,
+                    10,
+                    5
+                ],
+                [
+                    51,
+                    70,
+                    43
+                ],
+                [
+                    89,
+                    44,
+                    27
+                ],
+                [
+                    1,
+                    57,
+                    1
+                ],
+                [
+                    21,
+                    56,
+                    8
+                ],
+                [
+                    92,
+                    30,
+                    15
+                ],
+                [
+                    24,
+                    97,
+                    5
+                ],
+                [
+                    86,
+                    45,
+                    28
+                ],
+                [
+                    76,
+                    7,
+                    5
+                ],
+                [
+                    62,
+                    80,
+                    35
+                ],
+                [
+                    8,
+                    30,
+                    4
+                ],
+                [
+                    23,
+                    73,
+                    21
+                ],
+                [
+                    40,
+                    40,
+                    12
+                ],
+                [
+                    70,
+                    66,
+                    8
+                ],
+                [
+                    14,
+                    13,
+                    1
+                ],
+                [
+                    28,
+                    12,
+                    5
+                ],
+                [
+                    30,
+                    64,
+                    9
+                ],
+                [
+                    45,
+                    100,
+                    18
+                ],
+                [
+                    78,
+                    83,
+                    42
+                ],
+                [
+                    26,
+                    88,
+                    4
+                ],
+                [
+                    25,
+                    70,
+                    7
+                ],
+                [
+                    77,
+                    54,
+                    5
+                ],
+                [
+                    62,
+                    71,
+                    61
+                ],
+                [
+                    5,
+                    25,
+                    3
+                ],
+                [
+                    82,
+                    17,
+                    13
+                ],
+                [
+                    15,
+                    75,
+                    11
+                ]
+            ],
+            "output": 27390
+        },
+        {
+            "input": [
+                [
+                    82,
+                    71,
+                    52
+                ],
+                [
+                    82,
+                    87,
+                    61
+                ],
+                [
+                    77,
+                    22,
+                    22
+                ],
+                [
+                    16,
+                    57,
+                    3
+                ],
+                [
+                    50,
+                    86,
+                    7
+                ],
+                [
+                    77,
+                    46,
+                    25
+                ],
+                [
+                    99,
+                    90,
+                    53
+                ],
+                [
+                    35,
+                    28,
+                    2
+                ],
+                [
+                    83,
+                    90,
+                    19
+                ],
+                [
+                    74,
+                    44,
+                    43
+                ],
+                [
+                    54,
+                    39,
+                    26
+                ],
+                [
+                    60,
+                    1,
+                    1
+                ],
+                [
+                    77,
+                    64,
+                    56
+                ],
+                [
+                    35,
+                    39,
+                    35
+                ],
+                [
+                    53,
+                    68,
+                    23
+                ],
+                [
+                    2,
+                    15,
+                    1
+                ],
+                [
+                    8,
+                    54,
+                    6
+                ],
+                [
+                    98,
+                    46,
+                    43
+                ],
+                [
+                    12,
+                    33,
+                    8
+                ],
+                [
+                    3,
+                    62,
+                    2
+                ],
+                [
+                    99,
+                    44,
+                    41
+                ],
+                [
+                    98,
+                    88,
+                    40
+                ],
+                [
+                    100,
+                    50,
+                    41
+                ],
+                [
+                    39,
+                    3,
+                    2
+                ],
+                [
+                    16,
+                    88,
+                    3
+                ],
+                [
+                    98,
+                    26,
+                    12
+                ],
+                [
+                    14,
+                    39,
+                    7
+                ],
+                [
+                    45,
+                    59,
+                    2
+                ],
+                [
+                    53,
+                    92,
+                    37
+                ],
+                [
+                    81,
+                    25,
+                    6
+                ],
+                [
+                    92,
+                    18,
+                    10
+                ],
+                [
+                    80,
+                    93,
+                    78
+                ],
+                [
+                    90,
+                    24,
+                    22
+                ],
+                [
+                    4,
+                    29,
+                    4
+                ],
+                [
+                    74,
+                    83,
+                    73
+                ],
+                [
+                    48,
+                    4,
+                    3
+                ],
+                [
+                    56,
+                    72,
+                    5
+                ],
+                [
+                    16,
+                    13,
+                    1
+                ],
+                [
+                    16,
+                    24,
+                    8
+                ],
+                [
+                    46,
+                    43,
+                    35
+                ],
+                [
+                    90,
+                    80,
+                    3
+                ],
+                [
+                    86,
+                    18,
+                    6
+                ],
+                [
+                    28,
+                    49,
+                    24
+                ],
+                [
+                    61,
+                    34,
+                    11
+                ],
+                [
+                    83,
+                    55,
+                    25
+                ],
+                [
+                    48,
+                    89,
+                    33
+                ],
+                [
+                    22,
+                    37,
+                    20
+                ],
+                [
+                    7,
+                    6,
+                    5
+                ],
+                [
+                    85,
+                    29,
+                    5
+                ],
+                [
+                    17,
+                    28,
+                    15
+                ],
+                [
+                    37,
+                    55,
+                    21
+                ],
+                [
+                    1,
+                    89,
+                    1
+                ],
+                [
+                    38,
+                    90,
+                    28
+                ],
+                [
+                    41,
+                    7,
+                    2
+                ],
+                [
+                    7,
+                    6,
+                    5
+                ],
+                [
+                    69,
+                    10,
+                    2
+                ],
+                [
+                    59,
+                    2,
+                    1
+                ],
+                [
+                    76,
+                    43,
+                    21
+                ],
+                [
+                    53,
+                    52,
+                    29
+                ],
+                [
+                    42,
+                    26,
+                    24
+                ],
+                [
+                    12,
+                    38,
+                    12
+                ],
+                [
+                    52,
+                    28,
+                    6
+                ],
+                [
+                    50,
+                    76,
+                    46
+                ],
+                [
+                    27,
+                    56,
+                    23
+                ],
+                [
+                    32,
+                    69,
+                    25
+                ],
+                [
+                    89,
+                    16,
+                    8
+                ],
+                [
+                    1,
+                    50,
+                    1
+                ],
+                [
+                    31,
+                    34,
+                    29
+                ],
+                [
+                    21,
+                    3,
+                    1
+                ],
+                [
+                    67,
+                    71,
+                    7
+                ],
+                [
+                    40,
+                    86,
+                    11
+                ],
+                [
+                    24,
+                    74,
+                    24
+                ],
+                [
+                    1,
+                    73,
+                    1
+                ],
+                [
+                    87,
+                    83,
+                    58
+                ],
+                [
+                    47,
+                    81,
+                    32
+                ],
+                [
+                    42,
+                    92,
+                    19
+                ],
+                [
+                    29,
+                    25,
+                    24
+                ],
+                [
+                    15,
+                    97,
+                    2
+                ],
+                [
+                    11,
+                    5,
+                    3
+                ],
+                [
+                    16,
+                    57,
+                    12
+                ],
+                [
+                    79,
+                    15,
+                    4
+                ],
+                [
+                    55,
+                    89,
+                    52
+                ],
+                [
+                    1,
+                    84,
+                    1
+                ],
+                [
+                    1,
+                    21,
+                    1
+                ],
+                [
+                    31,
+                    14,
+                    14
+                ],
+                [
+                    82,
+                    45,
+                    9
+                ],
+                [
+                    96,
+                    36,
+                    21
+                ],
+                [
+                    55,
+                    84,
+                    54
+                ],
+                [
+                    64,
+                    95,
+                    64
+                ],
+                [
+                    32,
+                    95,
+                    18
+                ],
+                [
+                    86,
+                    97,
+                    52
+                ],
+                [
+                    69,
+                    36,
+                    22
+                ],
+                [
+                    67,
+                    15,
+                    14
+                ],
+                [
+                    24,
+                    91,
+                    14
+                ],
+                [
+                    47,
+                    10,
+                    1
+                ],
+                [
+                    87,
+                    20,
+                    7
+                ],
+                [
+                    2,
+                    91,
+                    1
+                ],
+                [
+                    67,
+                    65,
+                    12
+                ],
+                [
+                    90,
+                    40,
+                    8
+                ],
+                [
+                    31,
+                    14,
+                    14
+                ],
+                [
+                    16,
+                    24,
+                    3
+                ],
+                [
+                    80,
+                    34,
+                    29
+                ],
+                [
+                    67,
+                    25,
+                    4
+                ],
+                [
+                    57,
+                    94,
+                    33
+                ],
+                [
+                    8,
+                    31,
+                    7
+                ],
+                [
+                    35,
+                    12,
+                    5
+                ],
+                [
+                    65,
+                    69,
+                    49
+                ],
+                [
+                    92,
+                    12,
+                    2
+                ],
+                [
+                    46,
+                    67,
+                    1
+                ],
+                [
+                    35,
+                    73,
+                    11
+                ],
+                [
+                    62,
+                    44,
+                    28
+                ],
+                [
+                    86,
+                    83,
+                    15
+                ],
+                [
+                    54,
+                    42,
+                    21
+                ],
+                [
+                    26,
+                    59,
+                    2
+                ],
+                [
+                    67,
+                    44,
+                    13
+                ],
+                [
+                    3,
+                    54,
+                    2
+                ],
+                [
+                    84,
+                    24,
+                    5
+                ],
+                [
+                    42,
+                    31,
+                    30
+                ],
+                [
+                    42,
+                    6,
+                    2
+                ],
+                [
+                    66,
+                    78,
+                    65
+                ],
+                [
+                    25,
+                    15,
+                    7
+                ],
+                [
+                    9,
+                    31,
+                    7
+                ],
+                [
+                    24,
+                    84,
+                    14
+                ],
+                [
+                    12,
+                    21,
+                    9
+                ],
+                [
+                    38,
+                    65,
+                    16
+                ],
+                [
+                    7,
+                    82,
+                    6
+                ],
+                [
+                    18,
+                    22,
+                    18
+                ],
+                [
+                    39,
+                    81,
+                    38
+                ],
+                [
+                    48,
+                    2,
+                    1
+                ],
+                [
+                    48,
+                    97,
+                    30
+                ],
+                [
+                    92,
+                    38,
+                    26
+                ],
+                [
+                    56,
+                    83,
+                    36
+                ],
+                [
+                    19,
+                    49,
+                    13
+                ],
+                [
+                    8,
+                    42,
+                    3
+                ],
+                [
+                    88,
+                    51,
+                    29
+                ],
+                [
+                    17,
+                    15,
+                    5
+                ],
+                [
+                    100,
+                    59,
+                    55
+                ],
+                [
+                    83,
+                    53,
+                    35
+                ],
+                [
+                    84,
+                    64,
+                    28
+                ],
+                [
+                    94,
+                    32,
+                    31
+                ],
+                [
+                    21,
+                    63,
+                    7
+                ],
+                [
+                    38,
+                    39,
+                    21
+                ],
+                [
+                    33,
+                    26,
+                    6
+                ],
+                [
+                    56,
+                    38,
+                    37
+                ],
+                [
+                    97,
+                    54,
+                    19
+                ],
+                [
+                    47,
+                    91,
+                    24
+                ],
+                [
+                    88,
+                    10,
+                    2
+                ],
+                [
+                    18,
+                    1,
+                    1
+                ],
+                [
+                    43,
+                    4,
+                    2
+                ],
+                [
+                    58,
+                    10,
+                    10
+                ],
+                [
+                    5,
+                    38,
+                    4
+                ],
+                [
+                    39,
+                    32,
+                    18
+                ],
+                [
+                    82,
+                    60,
+                    48
+                ],
+                [
+                    56,
+                    47,
+                    11
+                ],
+                [
+                    69,
+                    91,
+                    3
+                ],
+                [
+                    73,
+                    42,
+                    2
+                ],
+                [
+                    30,
+                    88,
+                    15
+                ],
+                [
+                    8,
+                    82,
+                    2
+                ],
+                [
+                    21,
+                    80,
+                    4
+                ],
+                [
+                    8,
+                    79,
+                    4
+                ],
+                [
+                    2,
+                    41,
+                    2
+                ],
+                [
+                    1,
+                    62,
+                    1
+                ],
+                [
+                    55,
+                    17,
+                    8
+                ],
+                [
+                    35,
+                    87,
+                    31
+                ],
+                [
+                    55,
+                    1,
+                    1
+                ],
+                [
+                    44,
+                    68,
+                    1
+                ],
+                [
+                    15,
+                    36,
+                    9
+                ],
+                [
+                    79,
+                    84,
+                    52
+                ],
+                [
+                    65,
+                    68,
+                    48
+                ],
+                [
+                    64,
+                    90,
+                    13
+                ],
+                [
+                    32,
+                    5,
+                    2
+                ],
+                [
+                    98,
+                    63,
+                    5
+                ],
+                [
+                    94,
+                    1,
+                    1
+                ],
+                [
+                    18,
+                    16,
+                    10
+                ],
+                [
+                    70,
+                    72,
+                    62
+                ],
+                [
+                    1,
+                    43,
+                    1
+                ],
+                [
+                    13,
+                    90,
+                    6
+                ]
+            ],
+            "output": 23012
+        },
+        {
+            "input": [
+                [
+                    6,
+                    53,
+                    5
+                ],
+                [
+                    39,
+                    92,
+                    18
+                ],
+                [
+                    49,
+                    82,
+                    22
+                ],
+                [
+                    54,
+                    55,
+                    42
+                ],
+                [
+                    73,
+                    73,
+                    34
+                ],
+                [
+                    79,
+                    69,
+                    64
+                ],
+                [
+                    3,
+                    53,
+                    2
+                ],
+                [
+                    43,
+                    15,
+                    12
+                ],
+                [
+                    53,
+                    63,
+                    32
+                ],
+                [
+                    42,
+                    100,
+                    14
+                ],
+                [
+                    93,
+                    98,
+                    32
+                ],
+                [
+                    19,
+                    53,
+                    11
+                ],
+                [
+                    65,
+                    13,
+                    3
+                ],
+                [
+                    100,
+                    7,
+                    2
+                ],
+                [
+                    76,
+                    68,
+                    46
+                ],
+                [
+                    21,
+                    83,
+                    15
+                ],
+                [
+                    30,
+                    70,
+                    12
+                ],
+                [
+                    54,
+                    10,
+                    2
+                ],
+                [
+                    72,
+                    91,
+                    48
+                ],
+                [
+                    3,
+                    83,
+                    2
+                ],
+                [
+                    63,
+                    52,
+                    36
+                ],
+                [
+                    87,
+                    20,
+                    18
+                ],
+                [
+                    7,
+                    25,
+                    6
+                ],
+                [
+                    16,
+                    48,
+                    2
+                ],
+                [
+                    15,
+                    27,
+                    8
+                ],
+                [
+                    7,
+                    20,
+                    3
+                ],
+                [
+                    48,
+                    35,
+                    1
+                ],
+                [
+                    50,
+                    46,
+                    24
+                ],
+                [
+                    40,
+                    35,
+                    17
+                ],
+                [
+                    20,
+                    84,
+                    6
+                ],
+                [
+                    48,
+                    58,
+                    32
+                ],
+                [
+                    84,
+                    96,
+                    59
+                ],
+                [
+                    25,
+                    38,
+                    5
+                ],
+                [
+                    7,
+                    30,
+                    5
+                ],
+                [
+                    81,
+                    19,
+                    6
+                ],
+                [
+                    7,
+                    5,
+                    5
+                ],
+                [
+                    14,
+                    91,
+                    11
+                ],
+                [
+                    65,
+                    66,
+                    46
+                ],
+                [
+                    44,
+                    31,
+                    31
+                ],
+                [
+                    91,
+                    10,
+                    4
+                ],
+                [
+                    12,
+                    78,
+                    10
+                ],
+                [
+                    89,
+                    7,
+                    6
+                ],
+                [
+                    68,
+                    62,
+                    40
+                ],
+                [
+                    7,
+                    34,
+                    7
+                ],
+                [
+                    77,
+                    100,
+                    56
+                ],
+                [
+                    31,
+                    16,
+                    1
+                ],
+                [
+                    39,
+                    75,
+                    22
+                ],
+                [
+                    52,
+                    81,
+                    43
+                ],
+                [
+                    62,
+                    68,
+                    31
+                ],
+                [
+                    18,
+                    59,
+                    14
+                ],
+                [
+                    85,
+                    64,
+                    16
+                ],
+                [
+                    19,
+                    98,
+                    2
+                ]
+            ],
+            "output": 17755
+        },
+        {
+            "input": [
+                [
+                    19,
+                    61,
+                    2
+                ],
+                [
+                    15,
+                    92,
+                    6
+                ],
+                [
+                    52,
+                    77,
+                    43
+                ],
+                [
+                    3,
+                    13,
+                    3
+                ],
+                [
+                    80,
+                    90,
+                    20
+                ],
+                [
+                    21,
+                    12,
+                    2
+                ],
+                [
+                    80,
+                    22,
+                    12
+                ],
+                [
+                    81,
+                    10,
+                    2
+                ],
+                [
+                    28,
+                    97,
+                    8
+                ],
+                [
+                    40,
+                    45,
+                    35
+                ],
+                [
+                    15,
+                    22,
+                    8
+                ],
+                [
+                    86,
+                    58,
+                    24
+                ],
+                [
+                    52,
+                    53,
+                    26
+                ],
+                [
+                    53,
+                    17,
+                    6
+                ],
+                [
+                    41,
+                    50,
+                    36
+                ],
+                [
+                    68,
+                    43,
+                    40
+                ],
+                [
+                    3,
+                    32,
+                    3
+                ],
+                [
+                    87,
+                    42,
+                    3
+                ],
+                [
+                    28,
+                    3,
+                    1
+                ],
+                [
+                    52,
+                    20,
+                    10
+                ],
+                [
+                    96,
+                    51,
+                    2
+                ],
+                [
+                    26,
+                    26,
+                    12
+                ],
+                [
+                    49,
+                    80,
+                    15
+                ],
+                [
+                    82,
+                    57,
+                    11
+                ],
+                [
+                    50,
+                    91,
+                    24
+                ],
+                [
+                    55,
+                    30,
+                    19
+                ],
+                [
+                    63,
+                    94,
+                    33
+                ],
+                [
+                    50,
+                    91,
+                    45
+                ],
+                [
+                    66,
+                    82,
+                    57
+                ],
+                [
+                    8,
+                    55,
+                    2
+                ],
+                [
+                    66,
+                    34,
+                    14
+                ],
+                [
+                    82,
+                    82,
+                    65
+                ],
+                [
+                    58,
+                    25,
+                    19
+                ],
+                [
+                    69,
+                    2,
+                    1
+                ],
+                [
+                    98,
+                    34,
+                    31
+                ],
+                [
+                    31,
+                    69,
+                    4
+                ],
+                [
+                    99,
+                    59,
+                    3
+                ],
+                [
+                    88,
+                    17,
+                    7
+                ],
+                [
+                    78,
+                    59,
+                    47
+                ],
+                [
+                    26,
+                    83,
+                    8
+                ],
+                [
+                    50,
+                    74,
+                    15
+                ],
+                [
+                    41,
+                    88,
+                    21
+                ],
+                [
+                    41,
+                    48,
+                    28
+                ],
+                [
+                    97,
+                    69,
+                    34
+                ],
+                [
+                    81,
+                    96,
+                    71
+                ],
+                [
+                    58,
+                    59,
+                    51
+                ],
+                [
+                    33,
+                    61,
+                    31
+                ],
+                [
+                    69,
+                    25,
+                    22
+                ],
+                [
+                    24,
+                    6,
+                    1
+                ],
+                [
+                    43,
+                    64,
+                    5
+                ],
+                [
+                    95,
+                    25,
+                    18
+                ],
+                [
+                    17,
+                    100,
+                    8
+                ],
+                [
+                    47,
+                    54,
+                    5
+                ],
+                [
+                    23,
+                    42,
+                    19
+                ],
+                [
+                    52,
+                    100,
+                    45
+                ]
+            ],
+            "output": 19823
+        }
+    ],
+    "haskell_template": "countLatticePoints :: [[Int]] -> Int\ncountLatticePoints circles ",
+    "ocaml_template": "let countLatticePoints (circles: int list list) : int =  ",
+    "scala_template": "def countLatticePoints(circles: List[List[Int]]): Int = { \n    \n}",
+    "java_template": "public static int countLatticePoints(List<List<Integer>> circles) {\n\n}",
+    "python_template": "class Solution(object):\n    def countLatticePoints(self, circles):\n        \"\"\"\n        :type circles: List[List[int]]\n        :rtype: int\n        \"\"\"\n        "
+}

count_lattice_points_inside_a_circle/ocaml_tests/main.ml

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

count_lattice_points_inside_a_circle/scala_tests/MySuite.scala

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

count_mentions_per_user/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(2,2)), countMentions(2, new ArrayList<>(Arrays.asList(new ArrayList<>(Arrays.asList("MESSAGE","10","id1 id0")),new ArrayList<>(Arrays.asList("OFFLINE","11","0")),new ArrayList<>(Arrays.asList("MESSAGE","71","HERE"))))));
+}
+@Test
+public void test2() {
+    assertEquals(new ArrayList<>(Arrays.asList(2,2)), countMentions(2, new ArrayList<>(Arrays.asList(new ArrayList<>(Arrays.asList("MESSAGE","10","id1 id0")),new ArrayList<>(Arrays.asList("OFFLINE","11","0")),new ArrayList<>(Arrays.asList("MESSAGE","12","ALL"))))));
+}
+@Test
+public void test3() {
+    assertEquals(new ArrayList<>(Arrays.asList(0,1)), countMentions(2, new ArrayList<>(Arrays.asList(new ArrayList<>(Arrays.asList("OFFLINE","10","0")),new ArrayList<>(Arrays.asList("MESSAGE","12","HERE"))))));
+}
+
+}

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

count_non_decreasing_subarrays_after_k_operations/meta.json

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

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

count_number_of_bad_pairs/java_tests/Main.java

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

count_number_of_bad_pairs/meta.json

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

count_number_of_bad_pairs/ocaml_tests/main.ml

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

count_number_of_bad_pairs/scala_tests/MySuite.scala

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

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

count_number_of_distinct_integers_after_reverse_operations/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, countDistinctIntegers(new ArrayList<>(Arrays.asList(1,13,10,12,31))));
+}
+@Test
+public void test2() {
+    assertEquals(1, countDistinctIntegers(new ArrayList<>(Arrays.asList(2,2,2))));
+}
+
+}

count_number_of_distinct_integers_after_reverse_operations/ocaml_tests/main.ml

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

count_number_of_distinct_integers_after_reverse_operations/scala_tests/MySuite.scala

@@ -0,0 +1,12 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.countDistinctIntegers(List(1,13,10,12,31)), 6)
+  }
+
+  test("test2") {
+    assertEquals(Main.countDistinctIntegers(List(2,2,2)), 1)
+  }
+
+}

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

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

count_number_of_possible_root_nodes/meta.json

@@ -0,0 +1,375 @@
+{
+    "id": 2652,
+    "name": "count_number_of_possible_root_nodes",
+    "difficulty": "Hard",
+    "link": "https://leetcode.com/problems/count-number-of-possible-root-nodes/",
+    "date": "1676678400000",
+    "task_description": "Alice has an undirected tree with `n` nodes labeled from `0` to `n - 1`. The tree is represented as a 2D integer array `edges` of length `n - 1` where `edges[i] = [ai, bi]` indicates that there is an edge between nodes `ai` and `bi` in the tree. Alice wants Bob to find the root of the tree. She allows Bob to make several **guesses** about her tree. In one guess, he does the following: Chooses two **distinct** integers `u` and `v` such that there exists an edge `[u, v]` in the tree. He tells Alice that `u` is the **parent** of `v` in the tree. Bob's guesses are represented by a 2D integer array `guesses` where `guesses[j] = [uj, vj]` indicates Bob guessed `uj` to be the parent of `vj`. Alice being lazy, does not reply to each of Bob's guesses, but just says that **at least** `k` of his guesses are `true`. Given the 2D integer arrays `edges`, `guesses` and the integer `k`, return _the **number of possible nodes** that can be the root of Alice's tree_. If there is no such tree, return `0`. **Example 1:** ``` **Input:** edges = [[0,1],[1,2],[1,3],[4,2]], guesses = [[1,3],[0,1],[1,0],[2,4]], k = 3 **Output:** 3 **Explanation:** Root = 0, correct guesses = [1,3], [0,1], [2,4] Root = 1, correct guesses = [1,3], [1,0], [2,4] Root = 2, correct guesses = [1,3], [1,0], [2,4] Root = 3, correct guesses = [1,0], [2,4] Root = 4, correct guesses = [1,3], [1,0] Considering 0, 1, or 2 as root node leads to 3 correct guesses. ``` **Example 2:** ``` **Input:** edges = [[0,1],[1,2],[2,3],[3,4]], guesses = [[1,0],[3,4],[2,1],[3,2]], k = 1 **Output:** 5 **Explanation:** Root = 0, correct guesses = [3,4] Root = 1, correct guesses = [1,0], [3,4] Root = 2, correct guesses = [1,0], [2,1], [3,4] Root = 3, correct guesses = [1,0], [2,1], [3,2], [3,4] Root = 4, correct guesses = [1,0], [2,1], [3,2] Considering any node as root will give at least 1 correct guess. ``` **Constraints:** `edges.length == n - 1` `2 <= n <= 105` `1 <= guesses.length <= 105` `0 <= ai, bi, uj, vj <= n - 1` `ai != bi` `uj != vj` `edges` represents a valid tree. `guesses[j]` is an edge of the tree. `guesses` is unique. `0 <= k <= guesses.length`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "edges = [[0,1],[1,2],[1,3],[4,2]], guesses = [[1,3],[0,1],[1,0],[2,4]], k = 3",
+            "output": "3 "
+        },
+        {
+            "label": "Example 2",
+            "input": "edges = [[0,1],[1,2],[2,3],[3,4]], guesses = [[1,0],[3,4],[2,1],[3,2]], k = 1",
+            "output": "5 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                [
+                    [
+                        0,
+                        1
+                    ],
+                    [
+                        1,
+                        2
+                    ],
+                    [
+                        2,
+                        3
+                    ],
+                    [
+                        3,
+                        4
+                    ],
+                    [
+                        3,
+                        5
+                    ],
+                    [
+                        3,
+                        6
+                    ],
+                    [
+                        2,
+                        7
+                    ]
+                ],
+                [
+                    [
+                        1,
+                        2
+                    ],
+                    [
+                        3,
+                        4
+                    ],
+                    [
+                        2,
+                        3
+                    ],
+                    [
+                        3,
+                        5
+                    ]
+                ],
+                0
+            ],
+            "output": 8
+        },
+        {
+            "input": [
+                [
+                    [
+                        0,
+                        1
+                    ]
+                ],
+                [
+                    [
+                        0,
+                        1
+                    ]
+                ],
+                1
+            ],
+            "output": 1
+        },
+        {
+            "input": [
+                [
+                    [
+                        0,
+                        1
+                    ],
+                    [
+                        1,
+                        2
+                    ],
+                    [
+                        1,
+                        3
+                    ]
+                ],
+                [
+                    [
+                        0,
+                        1
+                    ],
+                    [
+                        1,
+                        2
+                    ],
+                    [
+                        1,
+                        3
+                    ]
+                ],
+                3
+            ],
+            "output": 1
+        },
+        {
+            "input": [
+                [
+                    [
+                        0,
+                        1
+                    ],
+                    [
+                        1,
+                        2
+                    ],
+                    [
+                        1,
+                        3
+                    ],
+                    [
+                        2,
+                        4
+                    ],
+                    [
+                        4,
+                        5
+                    ]
+                ],
+                [
+                    [
+                        2,
+                        4
+                    ],
+                    [
+                        4,
+                        5
+                    ],
+                    [
+                        1,
+                        3
+                    ],
+                    [
+                        1,
+                        2
+                    ],
+                    [
+                        0,
+                        1
+                    ]
+                ],
+                0
+            ],
+            "output": 6
+        },
+        {
+            "input": [
+                [
+                    [
+                        0,
+                        1
+                    ],
+                    [
+                        1,
+                        2
+                    ],
+                    [
+                        1,
+                        3
+                    ],
+                    [
+                        1,
+                        4
+                    ],
+                    [
+                        4,
+                        5
+                    ],
+                    [
+                        5,
+                        6
+                    ],
+                    [
+                        1,
+                        7
+                    ],
+                    [
+                        1,
+                        8
+                    ],
+                    [
+                        6,
+                        9
+                    ]
+                ],
+                [
+                    [
+                        4,
+                        5
+                    ],
+                    [
+                        1,
+                        8
+                    ],
+                    [
+                        6,
+                        9
+                    ]
+                ],
+                3
+            ],
+            "output": 6
+        },
+        {
+            "input": [
+                [
+                    [
+                        0,
+                        1
+                    ],
+                    [
+                        1,
+                        2
+                    ],
+                    [
+                        0,
+                        3
+                    ],
+                    [
+                        1,
+                        4
+                    ],
+                    [
+                        4,
+                        5
+                    ],
+                    [
+                        0,
+                        6
+                    ]
+                ],
+                [
+                    [
+                        1,
+                        4
+                    ]
+                ],
+                1
+            ],
+            "output": 5
+        },
+        {
+            "input": [
+                [
+                    [
+                        0,
+                        1
+                    ]
+                ],
+                [
+                    [
+                        0,
+                        1
+                    ]
+                ],
+                0
+            ],
+            "output": 2
+        },
+        {
+            "input": [
+                [
+                    [
+                        0,
+                        1
+                    ],
+                    [
+                        1,
+                        2
+                    ],
+                    [
+                        2,
+                        3
+                    ],
+                    [
+                        0,
+                        4
+                    ],
+                    [
+                        2,
+                        5
+                    ]
+                ],
+                [
+                    [
+                        0,
+                        1
+                    ]
+                ],
+                1
+            ],
+            "output": 2
+        },
+        {
+            "input": [
+                [
+                    [
+                        0,
+                        1
+                    ],
+                    [
+                        1,
+                        2
+                    ]
+                ],
+                [
+                    [
+                        0,
+                        1
+                    ]
+                ],
+                1
+            ],
+            "output": 1
+        },
+        {
+            "input": [
+                [
+                    [
+                        0,
+                        1
+                    ],
+                    [
+                        1,
+                        2
+                    ]
+                ],
+                [
+                    [
+                        0,
+                        1
+                    ]
+                ],
+                1
+            ],
+            "output": 1
+        }
+    ],
+    "haskell_template": "rootCount :: [[Int]] -> [[Int]] -> Int -> Int\nrootCount edges guesses k ",
+    "ocaml_template": "let rootCount (edges: int list list) (guesses: int list list) (k: int) : int =  ",
+    "scala_template": "def rootCount(edges: List[List[Int]],guesses: List[List[Int]],k: Int): Int = { \n    \n}",
+    "java_template": "public static int rootCount(List<List<Integer>> edges, List<List<Integer>> guesses, int k) {\n\n}",
+    "python_template": "class Solution(object):\n    def rootCount(self, edges, guesses, k):\n        \"\"\"\n        :type edges: List[List[int]]\n        :type guesses: List[List[int]]\n        :type k: int\n        :rtype: int\n        \"\"\"\n        "
+}

count_number_of_possible_root_nodes/ocaml_tests/main.ml

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

count_number_of_possible_root_nodes/scala_tests/MySuite.scala

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