88172528aff7d5f4b03791c78a9538bd129960bea3241db0df6269e07e50df47

.gitattributes

@@ -252,3 +252,5 @@ most_popular_video_creator/meta.json filter=lfs diff=lfs merge=lfs -text
 movement_of_robots/meta.json filter=lfs diff=lfs merge=lfs -text
 next_greater_element_iv/meta.json filter=lfs diff=lfs merge=lfs -text
 node_with_highest_edge_score/meta.json filter=lfs diff=lfs merge=lfs -text
+number_of_excellent_pairs/meta.json filter=lfs diff=lfs merge=lfs -text
+number_of_flowers_in_full_bloom/meta.json filter=lfs diff=lfs merge=lfs -text

number_of_beautiful_partitions/scala_tests/MySuite.scala

@@ -0,0 +1,16 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.beautifulPartitions("23542185131",3,2), 3)
+  }
+
+  test("test2") {
+    assertEquals(Main.beautifulPartitions("23542185131",3,3), 1)
+  }
+
+  test("test3") {
+    assertEquals(Main.beautifulPartitions("3312958",3,1), 1)
+  }
+
+}

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

number_of_black_blocks/java_tests/Main.java

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

number_of_black_blocks/ocaml_tests/main.ml

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

number_of_black_blocks/scala_tests/MySuite.scala

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

number_of_changing_keys/haskell_tests/Main.hs

@@ -0,0 +1,41 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+countKeyChanges :: String -> Int
+countKeyChanges s = undefined
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (countKeyChanges \"aAbBcC \")," 2 (countKeyChanges "aAbBcC"))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (countKeyChanges \"AaAaAaaA \")," 0 (countKeyChanges "AaAaAaaA"))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (countKeyChanges  \"sJZIxUDeOnkCxEKHMqCGmsEYAyjzhfcDjszMWonomvIAOhhWKixeBCxTVNbdHyKwmuAJGI \")," 68 (countKeyChanges "sJZIxUDeOnkCxEKHMqCGmsEYAyjzhfcDjszMWonomvIAOhhWKixeBCxTVNbdHyKwmuAJGI"))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (countKeyChanges  \"jHnOXcWJmsLiDoxSKJcrLDFbQoPUuTXaiGTTciAT \")," 37 (countKeyChanges "jHnOXcWJmsLiDoxSKJcrLDFbQoPUuTXaiGTTciAT"))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (countKeyChanges  \"W \")," 0 (countKeyChanges "W"))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (countKeyChanges  \"flr \")," 2 (countKeyChanges "flr"))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (countKeyChanges  \"GzkXFWdMQKSjiwbhNZgzzaebLaNnxZwvh \")," 30 (countKeyChanges "GzkXFWdMQKSjiwbhNZgzzaebLaNnxZwvh"))
+
+
+-- 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]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

number_of_changing_keys/java_tests/Main.java

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

number_of_changing_keys/meta.json

@@ -0,0 +1,47 @@
+{
+    "id": 3312,
+    "name": "number_of_changing_keys",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/number-of-changing-keys/",
+    "date": "2024-01-21 00:00:00",
+    "task_description": "You are given a **0-indexed **string `s` typed by a user. Changing a key is defined as using a key different from the last used key. For example, `s = \"ab\"` has a change of a key while `s = \"bBBb\"` does not have any. Return _the number of times the user had to change the key. _ **Note: **Modifiers like `shift` or `caps lock` won't be counted in changing the key that is if a user typed the letter `'a'` and then the letter `'A'` then it will not be considered as a changing of key. **Example 1:** ``` **Input:** s = \"aAbBcC\" **Output:** 2 **Explanation:** From s[0] = 'a' to s[1] = 'A', there is no change of key as caps lock or shift is not counted. From s[1] = 'A' to s[2] = 'b', there is a change of key. From s[2] = 'b' to s[3] = 'B', there is no change of key as caps lock or shift is not counted. From s[3] = 'B' to s[4] = 'c', there is a change of key. From s[4] = 'c' to s[5] = 'C', there is no change of key as caps lock or shift is not counted. ``` **Example 2:** ``` **Input:** s = \"AaAaAaaA\" **Output:** 0 **Explanation:** There is no change of key since only the letters 'a' and 'A' are pressed which does not require change of key. ``` **Constraints:** `1 <= s.length <= 100` `s` consists of only upper case and lower case English letters.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "s = \"aAbBcC\"",
+            "output": "2 "
+        },
+        {
+            "label": "Example 2",
+            "input": "s = \"AaAaAaaA\"",
+            "output": "0 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": "sJZIxUDeOnkCxEKHMqCGmsEYAyjzhfcDjszMWonomvIAOhhWKixeBCxTVNbdHyKwmuAJGI",
+            "output": 68
+        },
+        {
+            "input": "jHnOXcWJmsLiDoxSKJcrLDFbQoPUuTXaiGTTciAT",
+            "output": 37
+        },
+        {
+            "input": "W",
+            "output": 0
+        },
+        {
+            "input": "flr",
+            "output": 2
+        },
+        {
+            "input": "GzkXFWdMQKSjiwbhNZgzzaebLaNnxZwvh",
+            "output": 30
+        }
+    ],
+    "haskell_template": "countKeyChanges :: String -> Int\ncountKeyChanges s ",
+    "ocaml_template": "let countKeyChanges (s: string) : int =  ",
+    "scala_template": "def countKeyChanges(s: String): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public int countKeyChanges(String s) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def countKeyChanges(self, s):\n        \"\"\"\n        :type s: str\n        :rtype: int\n        \"\"\"\n        "
+}

number_of_changing_keys/ocaml_tests/main.ml

@@ -0,0 +1,42 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+    let countKeyChanges (s: string) : int =   failwith "Not implemented"
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 2 (countKeyChanges "aAbBcC")
+
+let test2 _ = assert_equal 0 (countKeyChanges "AaAaAaaA")
+
+let test3 _ = assert_equal 0 (countKeyChanges "sJZIxUDeOnkCxEKHMqCGmsEYAyjzhfcDjszMWonomvIAOhhWKixeBCxTVNbdHyKwmuAJGI")
+
+let test4 _ = assert_equal 0 (countKeyChanges "jHnOXcWJmsLiDoxSKJcrLDFbQoPUuTXaiGTTciAT")
+
+let test5 _ = assert_equal 0 (countKeyChanges "W")
+
+let test6 _ = assert_equal 0 (countKeyChanges "flr")
+
+let test7 _ = assert_equal 0 (countKeyChanges "GzkXFWdMQKSjiwbhNZgzzaebLaNnxZwvh")
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for countKeyChanges" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+  "test3" >:: test3;
+  "test4" >:: test4;
+  "test5" >:: test5;
+  "test6" >:: test6;
+  "test7" >:: test7;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

number_of_changing_keys/scala_tests/MySuite.scala

@@ -0,0 +1,32 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.countKeyChanges("aAbBcC"), 2)
+  }
+
+  test("test2") {
+    assertEquals(Main.countKeyChanges("AaAaAaaA"), 0)
+  }
+
+  test("test3") {
+    assertEquals(Main.countKeyChanges(",s,J,Z,I,x,U,D,e,O,n,k,C,x,E,K,H,M,q,C,G,m,s,E,Y,A,y,j,z,h,f,c,D,j,s,z,M,W,o,n,o,m,v,I,A,O,h,h,W,K,i,x,e,B,C,x,T,V,N,b,d,H,y,K,w,m,u,A,J,G,I,"), 68)
+  }
+
+  test("test4") {
+    assertEquals(Main.countKeyChanges(",j,H,n,O,X,c,W,J,m,s,L,i,D,o,x,S,K,J,c,r,L,D,F,b,Q,o,P,U,u,T,X,a,i,G,T,T,c,i,A,T,"), 37)
+  }
+
+  test("test5") {
+    assertEquals(Main.countKeyChanges(",W,"), 0)
+  }
+
+  test("test6") {
+    assertEquals(Main.countKeyChanges(",f,l,r,"), 2)
+  }
+
+  test("test7") {
+    assertEquals(Main.countKeyChanges(",G,z,k,X,F,W,d,M,Q,K,S,j,i,w,b,h,N,Z,g,z,z,a,e,b,L,a,N,n,x,Z,w,v,h,"), 30)
+  }
+
+}

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

number_of_common_factors/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, commonFactors(12, 6));
+}
+@Test
+public void test2() {
+    assertEquals(2, commonFactors(25, 30));
+}
+
+}

number_of_common_factors/meta.json

@@ -0,0 +1,97 @@
+{
+    "id": 2507,
+    "name": "number_of_common_factors",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/number-of-common-factors/",
+    "date": "1664064000000",
+    "task_description": "Given two positive integers `a` and `b`, return _the number of **common** factors of _`a`_ and _`b`. An integer `x` is a **common factor** of `a` and `b` if `x` divides both `a` and `b`. **Example 1:** ``` **Input:** a = 12, b = 6 **Output:** 4 **Explanation:** The common factors of 12 and 6 are 1, 2, 3, 6. ``` **Example 2:** ``` **Input:** a = 25, b = 30 **Output:** 2 **Explanation:** The common factors of 25 and 30 are 1, 5. ``` **Constraints:** `1 <= a, b <= 1000`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "a = 12, b = 6",
+            "output": "4 "
+        },
+        {
+            "label": "Example 2",
+            "input": "a = 25, b = 30",
+            "output": "2 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                451,
+                147
+            ],
+            "output": 1
+        },
+        {
+            "input": [
+                140,
+                725
+            ],
+            "output": 2
+        },
+        {
+            "input": [
+                640,
+                81
+            ],
+            "output": 1
+        },
+        {
+            "input": [
+                868,
+                559
+            ],
+            "output": 1
+        },
+        {
+            "input": [
+                195,
+                384
+            ],
+            "output": 2
+        },
+        {
+            "input": [
+                739,
+                215
+            ],
+            "output": 1
+        },
+        {
+            "input": [
+                103,
+                422
+            ],
+            "output": 1
+        },
+        {
+            "input": [
+                705,
+                23
+            ],
+            "output": 1
+        },
+        {
+            "input": [
+                1000,
+                488
+            ],
+            "output": 4
+        },
+        {
+            "input": [
+                202,
+                862
+            ],
+            "output": 2
+        }
+    ],
+    "haskell_template": "commonFactors :: Int -> Int -> Int\ncommonFactors a b ",
+    "ocaml_template": "let commonFactors (a: int) (b: int) : int =  ",
+    "scala_template": "def commonFactors(a: Int,b: Int): Int = { \n    \n}",
+    "java_template": "public static int commonFactors(int a, int b) {\n\n}",
+    "python_template": "class Solution(object):\n    def commonFactors(self, a, b):\n        \"\"\"\n        :type a: int\n        :type b: int\n        :rtype: int\n        \"\"\"\n        "
+}

number_of_common_factors/ocaml_tests/main.ml

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

number_of_common_factors/scala_tests/MySuite.scala

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

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

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

number_of_distinct_averages/meta.json

@@ -0,0 +1,479 @@
+{
+    "id": 2561,
+    "name": "number_of_distinct_averages",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/number-of-distinct-averages/",
+    "date": "1667001600000",
+    "task_description": "You are given a **0-indexed** integer array `nums` of **even** length. As long as `nums` is **not** empty, you must repetitively: Find the minimum number in `nums` and remove it. Find the maximum number in `nums` and remove it. Calculate the average of the two removed numbers. The **average** of two numbers `a` and `b` is `(a + b) / 2`. For example, the average of `2` and `3` is `(2 + 3) / 2 = 2.5`. Return_ the number of **distinct** averages calculated using the above process_. **Note** that when there is a tie for a minimum or maximum number, any can be removed. **Example 1:** ``` **Input:** nums = [4,1,4,0,3,5] **Output:** 2 **Explanation:** 1. Remove 0 and 5, and the average is (0 + 5) / 2 = 2.5. Now, nums = [4,1,4,3]. 2. Remove 1 and 4. The average is (1 + 4) / 2 = 2.5, and nums = [4,3]. 3. Remove 3 and 4, and the average is (3 + 4) / 2 = 3.5. Since there are 2 distinct numbers among 2.5, 2.5, and 3.5, we return 2. ``` **Example 2:** ``` **Input:** nums = [1,100] **Output:** 1 **Explanation:** There is only one average to be calculated after removing 1 and 100, so we return 1. ``` **Constraints:** `2 <= nums.length <= 100` `nums.length` is even. `0 <= nums[i] <= 100`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "nums = [4,1,4,0,3,5]",
+            "output": "2 "
+        },
+        {
+            "label": "Example 2",
+            "input": "nums = [1,100]",
+            "output": "1 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                0,
+                4,
+                7,
+                8,
+                13,
+                14,
+                25,
+                26,
+                27,
+                36,
+                47,
+                49,
+                49,
+                51,
+                51,
+                56,
+                66,
+                67,
+                67,
+                71,
+                80,
+                82,
+                85,
+                89,
+                92,
+                94,
+                96,
+                98,
+                100,
+                100
+            ],
+            "output": 11
+        },
+        {
+            "input": [
+                0,
+                15,
+                19,
+                38,
+                50,
+                59,
+                60,
+                90
+            ],
+            "output": 4
+        },
+        {
+            "input": [
+                0,
+                0,
+                0,
+                1,
+                3,
+                5,
+                5,
+                5,
+                6,
+                7,
+                10,
+                13,
+                14,
+                17,
+                18,
+                19,
+                19,
+                22,
+                25,
+                25,
+                26,
+                26,
+                33,
+                34,
+                40,
+                40,
+                41,
+                41,
+                44,
+                46,
+                46,
+                46,
+                47,
+                47,
+                48,
+                48,
+                49,
+                51,
+                51,
+                52,
+                53,
+                54,
+                57,
+                57,
+                60,
+                60,
+                62,
+                62,
+                62,
+                67,
+                67,
+                67,
+                69,
+                69,
+                70,
+                71,
+                73,
+                73,
+                73,
+                73,
+                74,
+                75,
+                75,
+                76,
+                79,
+                80,
+                80,
+                82,
+                84,
+                85,
+                86,
+                87,
+                89,
+                92,
+                94,
+                95,
+                96,
+                97,
+                99,
+                99,
+                99,
+                100
+            ],
+            "output": 16
+        },
+        {
+            "input": [
+                4,
+                31,
+                34,
+                49,
+                50,
+                51,
+                63,
+                67,
+                76,
+                88,
+                88,
+                88,
+                94,
+                99
+            ],
+            "output": 7
+        },
+        {
+            "input": [
+                5,
+                8,
+                13,
+                14,
+                16,
+                17,
+                18,
+                19,
+                26,
+                26,
+                28,
+                33,
+                34,
+                38,
+                46,
+                49,
+                50,
+                50,
+                51,
+                56,
+                57,
+                57,
+                64,
+                66,
+                67,
+                69,
+                71,
+                71,
+                73,
+                75,
+                76,
+                83,
+                87,
+                87,
+                87,
+                98
+            ],
+            "output": 10
+        },
+        {
+            "input": [
+                11,
+                13,
+                13,
+                19,
+                31,
+                33,
+                45,
+                47,
+                47,
+                51,
+                62,
+                84,
+                87,
+                89
+            ],
+            "output": 6
+        },
+        {
+            "input": [
+                0,
+                1,
+                3,
+                3,
+                6,
+                6,
+                7,
+                8,
+                9,
+                9,
+                14,
+                17,
+                18,
+                18,
+                20,
+                22,
+                24,
+                25,
+                28,
+                28,
+                29,
+                29,
+                30,
+                31,
+                32,
+                32,
+                33,
+                36,
+                38,
+                38,
+                39,
+                40,
+                41,
+                43,
+                43,
+                46,
+                52,
+                52,
+                55,
+                57,
+                57,
+                57,
+                60,
+                61,
+                61,
+                64,
+                66,
+                68,
+                68,
+                69,
+                70,
+                71,
+                72,
+                73,
+                73,
+                77,
+                79,
+                79,
+                80,
+                80,
+                81,
+                82,
+                84,
+                89,
+                90,
+                90,
+                91,
+                97,
+                100,
+                100
+            ],
+            "output": 13
+        },
+        {
+            "input": [
+                12,
+                26,
+                30,
+                34,
+                35,
+                36,
+                38,
+                39,
+                42,
+                44,
+                63,
+                64,
+                68,
+                68,
+                77,
+                79,
+                90,
+                98,
+                100,
+                100
+            ],
+            "output": 8
+        },
+        {
+            "input": [
+                0,
+                0,
+                1,
+                2,
+                5,
+                6,
+                7,
+                9,
+                11,
+                13,
+                13,
+                13,
+                14,
+                15,
+                15,
+                16,
+                18,
+                18,
+                19,
+                20,
+                20,
+                23,
+                23,
+                24,
+                24,
+                26,
+                26,
+                27,
+                27,
+                28,
+                28,
+                28,
+                29,
+                31,
+                31,
+                32,
+                34,
+                34,
+                35,
+                36,
+                39,
+                39,
+                41,
+                41,
+                43,
+                43,
+                44,
+                44,
+                45,
+                47,
+                48,
+                49,
+                49,
+                52,
+                56,
+                56,
+                57,
+                58,
+                59,
+                60,
+                60,
+                61,
+                62,
+                64,
+                65,
+                67,
+                67,
+                70,
+                71,
+                71,
+                72,
+                72,
+                72,
+                73,
+                77,
+                78,
+                78,
+                78,
+                81,
+                82,
+                84,
+                84,
+                84,
+                85,
+                86,
+                86,
+                87,
+                88,
+                88,
+                89,
+                90,
+                91,
+                92,
+                93,
+                94,
+                95,
+                98,
+                99,
+                100,
+                100
+            ],
+            "output": 12
+        },
+        {
+            "input": [
+                0,
+                5,
+                22,
+                22,
+                24,
+                27,
+                32,
+                32,
+                33,
+                37,
+                37,
+                37,
+                43,
+                45,
+                50,
+                59,
+                60,
+                64,
+                69,
+                72,
+                75,
+                77,
+                77,
+                87,
+                89,
+                91,
+                95,
+                98
+            ],
+            "output": 13
+        }
+    ],
+    "haskell_template": "distinctAverages :: [Int] -> Int\ndistinctAverages nums ",
+    "ocaml_template": "let distinctAverages (nums: int list) : int =  ",
+    "scala_template": "def distinctAverages(nums: List[Int]): Int = { \n    \n}",
+    "java_template": "public static int distinctAverages(List<Integer> nums) {\n\n}",
+    "python_template": "class Solution(object):\n    def distinctAverages(self, nums):\n        \"\"\"\n        :type nums: List[int]\n        :rtype: int\n        \"\"\"\n        "
+}

number_of_distinct_averages/ocaml_tests/main.ml

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

number_of_distinct_averages/scala_tests/MySuite.scala

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

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

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

number_of_employees_who_met_the_target/meta.json

@@ -0,0 +1,347 @@
+{
+    "id": 2876,
+    "name": "number_of_employees_who_met_the_target",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/number-of-employees-who-met-the-target/",
+    "date": "1690070400000",
+    "task_description": "There are `n` employees in a company, numbered from `0` to `n - 1`. Each employee `i` has worked for `hours[i]` hours in the company. The company requires each employee to work for **at least** `target` hours. You are given a **0-indexed** array of non-negative integers `hours` of length `n` and a non-negative integer `target`. Return _the integer denoting the number of employees who worked at least_ `target` _hours_. **Example 1:** ``` **Input:** hours = [0,1,2,3,4], target = 2 **Output:** 3 **Explanation:** The company wants each employee to work for at least 2 hours. - Employee 0 worked for 0 hours and didn't meet the target. - Employee 1 worked for 1 hours and didn't meet the target. - Employee 2 worked for 2 hours and met the target. - Employee 3 worked for 3 hours and met the target. - Employee 4 worked for 4 hours and met the target. There are 3 employees who met the target. ``` **Example 2:** ``` **Input:** hours = [5,1,4,2,2], target = 6 **Output:** 0 **Explanation:** The company wants each employee to work for at least 6 hours. There are 0 employees who met the target. ``` **Constraints:** `1 <= n == hours.length <= 50` `0 <= hours[i], target <= 105`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "hours = [0,1,2,3,4], target = 2",
+            "output": "3 "
+        },
+        {
+            "label": "Example 2",
+            "input": "hours = [5,1,4,2,2], target = 6",
+            "output": "0 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                [
+                    26917,
+                    92767,
+                    61431,
+                    74806,
+                    62926,
+                    47142,
+                    81802,
+                    33945,
+                    17936,
+                    3127,
+                    80442,
+                    72513,
+                    55219,
+                    19560,
+                    4846,
+                    57181,
+                    66197,
+                    75253,
+                    16470,
+                    56002,
+                    32785,
+                    67789,
+                    64751
+                ],
+                25375
+            ],
+            "output": 18
+        },
+        {
+            "input": [
+                [
+                    91734,
+                    99799,
+                    4973,
+                    36005,
+                    15972,
+                    31666,
+                    96819,
+                    81346,
+                    19824,
+                    17733,
+                    43540,
+                    69278,
+                    86840,
+                    81515,
+                    23413,
+                    9162,
+                    7830,
+                    83574,
+                    31740,
+                    87579
+                ],
+                6580
+            ],
+            "output": 19
+        },
+        {
+            "input": [
+                [
+                    74683,
+                    36319,
+                    79579,
+                    86033,
+                    76201,
+                    80994,
+                    71665,
+                    28663,
+                    14183,
+                    63717,
+                    76869,
+                    79525,
+                    80989,
+                    99451,
+                    63658,
+                    57250,
+                    56787,
+                    11839,
+                    23699,
+                    51417,
+                    77492,
+                    96168,
+                    40320,
+                    36123,
+                    56847,
+                    94294,
+                    41900,
+                    23089,
+                    51307,
+                    8472,
+                    73762,
+                    94425,
+                    89210,
+                    7617,
+                    94791,
+                    88354,
+                    55028,
+                    64448,
+                    15448
+                ],
+                44885
+            ],
+            "output": 27
+        },
+        {
+            "input": [
+                [
+                    65916,
+                    8703,
+                    66184,
+                    28441,
+                    83616,
+                    22076,
+                    40445,
+                    42679,
+                    6859,
+                    79231,
+                    86029,
+                    97690,
+                    73580,
+                    65065,
+                    29443
+                ],
+                77088
+            ],
+            "output": 4
+        },
+        {
+            "input": [
+                [
+                    9441,
+                    26850,
+                    60165,
+                    91173,
+                    37030,
+                    70999,
+                    27344,
+                    46359,
+                    89289,
+                    22985,
+                    31896,
+                    62574,
+                    88562,
+                    67360,
+                    84090,
+                    94337,
+                    88394,
+                    10468,
+                    32070,
+                    584,
+                    63971,
+                    96386,
+                    30715,
+                    16099,
+                    97357,
+                    293,
+                    15022,
+                    7715,
+                    30134,
+                    55366,
+                    51435,
+                    49687,
+                    54200,
+                    5973,
+                    31674
+                ],
+                56131
+            ],
+            "output": 13
+        },
+        {
+            "input": [
+                [
+                    23886
+                ],
+                61735
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                [
+                    4531,
+                    53926,
+                    40178,
+                    16515,
+                    68987,
+                    10853,
+                    66827,
+                    79486,
+                    25200,
+                    7178,
+                    37636,
+                    83521,
+                    89341,
+                    15266,
+                    60264,
+                    96601,
+                    47135
+                ],
+                1361
+            ],
+            "output": 17
+        },
+        {
+            "input": [
+                [
+                    34258,
+                    26662,
+                    92204,
+                    44479,
+                    60627,
+                    84482,
+                    59348,
+                    50092,
+                    73337,
+                    51045,
+                    87274,
+                    46163,
+                    36945,
+                    49889,
+                    45688,
+                    98137,
+                    5112,
+                    89521,
+                    94524,
+                    84627,
+                    5578,
+                    70687,
+                    79808,
+                    57000,
+                    74736,
+                    11118,
+                    25779,
+                    75000,
+                    4286,
+                    73949,
+                    58701,
+                    79512,
+                    7977,
+                    46955,
+                    65559,
+                    60435,
+                    32621,
+                    77694,
+                    90878,
+                    74586,
+                    42780,
+                    56347,
+                    30134,
+                    15356
+                ],
+                60715
+            ],
+            "output": 18
+        },
+        {
+            "input": [
+                [
+                    54001,
+                    71506,
+                    98124,
+                    45961,
+                    14470,
+                    23848,
+                    53852,
+                    59341,
+                    47118,
+                    94202,
+                    50707,
+                    72585,
+                    54343,
+                    75678,
+                    18310,
+                    90558,
+                    44936,
+                    66177,
+                    76314,
+                    33403,
+                    64742,
+                    10682,
+                    18433,
+                    18783,
+                    86658,
+                    73317,
+                    15603,
+                    25316,
+                    32229,
+                    71021,
+                    87941,
+                    1224,
+                    28861,
+                    6609,
+                    96871,
+                    5584,
+                    6816,
+                    98740
+                ],
+                25768
+            ],
+            "output": 26
+        },
+        {
+            "input": [
+                [
+                    49912,
+                    81144,
+                    39422,
+                    28821,
+                    71772,
+                    49029,
+                    90561,
+                    24982
+                ],
+                68166
+            ],
+            "output": 3
+        }
+    ],
+    "haskell_template": "numberOfEmployeesWhoMetTarget :: [Int] -> Int -> Int\nnumberOfEmployeesWhoMetTarget hours target ",
+    "ocaml_template": "let numberOfEmployeesWhoMetTarget (hours: int list) (target: int) : int =  ",
+    "scala_template": "def numberOfEmployeesWhoMetTarget(hours: List[Int],target: Int): Int = { \n    \n}",
+    "java_template": "public static int numberOfEmployeesWhoMetTarget(List<Integer> hours, int target) {\n\n}",
+    "python_template": "class Solution(object):\n    def numberOfEmployeesWhoMetTarget(self, hours, target):\n        \"\"\"\n        :type hours: List[int]\n        :type target: int\n        :rtype: int\n        \"\"\"\n        "
+}

number_of_employees_who_met_the_target/ocaml_tests/main.ml

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

number_of_employees_who_met_the_target/scala_tests/MySuite.scala

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

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

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

number_of_excellent_pairs/meta.json

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

number_of_excellent_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 (countExcellentPairs [1;2;3;1] 3)
+
+let test2 _ = assert_equal 0 (countExcellentPairs [5;1;1] 10)
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for countExcellentPairs" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

number_of_excellent_pairs/scala_tests/MySuite.scala

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

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

number_of_flowers_in_full_bloom/java_tests/Main.java

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

number_of_flowers_in_full_bloom/meta.json

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

number_of_flowers_in_full_bloom/ocaml_tests/main.ml

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

number_of_flowers_in_full_bloom/scala_tests/MySuite.scala

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

number_of_good_paths/haskell_tests/Main.hs

@@ -0,0 +1,27 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (numberOfGoodPaths [1,3,2,1,3] [[0,1],[0,2],[2,3],[2,4]])," 6 (numberOfGoodPaths [1,3,2,1,3] [[0,1],[0,2],[2,3],[2,4]]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (numberOfGoodPaths [1,1,2,2,3] [[0,1],[1,2],[2,3],[2,4]])," 7 (numberOfGoodPaths [1,1,2,2,3] [[0,1],[1,2],[2,3],[2,4]]))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (numberOfGoodPaths [1] [])," 1 (numberOfGoodPaths [1] []))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1, TestLabel "Test2" test2]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

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

number_of_good_paths/meta.json

@@ -0,0 +1,31 @@
+{
+    "id": 2505,
+    "name": "number_of_good_paths",
+    "difficulty": "Hard",
+    "link": "https://leetcode.com/problems/number-of-good-paths/",
+    "date": "1663459200000",
+    "task_description": "There is a tree (i.e. a connected, undirected graph with no cycles) consisting of `n` nodes numbered from `0` to `n - 1` and exactly `n - 1` edges. You are given a **0-indexed** integer array `vals` of length `n` where `vals[i]` denotes the value of the `ith` node. You are also given a 2D integer array `edges` where `edges[i] = [ai, bi]` denotes that there exists an **undirected** edge connecting nodes `ai` and `bi`. A **good path** is a simple path that satisfies the following conditions: The starting node and the ending node have the **same** value. All nodes between the starting node and the ending node have values **less than or equal to** the starting node (i.e. the starting node's value should be the maximum value along the path). Return _the number of distinct good paths_. Note that a path and its reverse are counted as the **same** path. For example, `0 -> 1` is considered to be the same as `1 -> 0`. A single node is also considered as a valid path. **Example 1:** ``` **Input:** vals = [1,3,2,1,3], edges = [[0,1],[0,2],[2,3],[2,4]] **Output:** 6 **Explanation:** There are 5 good paths consisting of a single node. There is 1 additional good path: 1 -> 0 -> 2 -> 4. (The reverse path 4 -> 2 -> 0 -> 1 is treated as the same as 1 -> 0 -> 2 -> 4.) Note that 0 -> 2 -> 3 is not a good path because vals[2] > vals[0]. ``` **Example 2:** ``` **Input:** vals = [1,1,2,2,3], edges = [[0,1],[1,2],[2,3],[2,4]] **Output:** 7 **Explanation:** There are 5 good paths consisting of a single node. There are 2 additional good paths: 0 -> 1 and 2 -> 3. ``` **Example 3:** ``` **Input:** vals = [1], edges = [] **Output:** 1 **Explanation:** The tree consists of only one node, so there is one good path. ``` **Constraints:** `n == vals.length` `1 <= n <= 3 * 104` `0 <= vals[i] <= 105` `edges.length == n - 1` `edges[i].length == 2` `0 <= ai, bi < n` `ai != bi` `edges` represents a valid tree.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "vals = [1,3,2,1,3], edges = [[0,1],[0,2],[2,3],[2,4]]",
+            "output": "6 "
+        },
+        {
+            "label": "Example 2",
+            "input": "vals = [1,1,2,2,3], edges = [[0,1],[1,2],[2,3],[2,4]]",
+            "output": "7 "
+        },
+        {
+            "label": "Example 3",
+            "input": "vals = [1], edges = []",
+            "output": "1 "
+        }
+    ],
+    "private_test_cases": [],
+    "haskell_template": "numberOfGoodPaths :: [Int] -> [[Int]] -> Int\nnumberOfGoodPaths vals edges ",
+    "ocaml_template": "let numberOfGoodPaths (vals: int list) (edges: int list list) : int =  ",
+    "scala_template": "def numberOfGoodPaths(vals: List[Int],edges: List[List[Int]]): Int = { \n    \n}",
+    "java_template": "public static int numberOfGoodPaths(List<Integer> vals, List<List<Integer>> edges) {\n\n}",
+    "python_template": "class Solution(object):\n    def numberOfGoodPaths(self, vals, edges):\n        \"\"\"\n        :type vals: List[int]\n        :type edges: List[List[int]]\n        :rtype: int\n        \"\"\"\n        "
+}

number_of_good_paths/ocaml_tests/main.ml

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

number_of_good_paths/scala_tests/MySuite.scala

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