300d9c548d0181e06510a93bf2caf000732c135de434e68f028f2cbbc52f3eaa

.gitattributes

@@ -257,3 +257,4 @@ number_of_flowers_in_full_bloom/meta.json filter=lfs diff=lfs merge=lfs -text
 number_of_increasing_paths_in_a_grid/haskell_tests/Main.hs filter=lfs diff=lfs merge=lfs -text
 number_of_increasing_paths_in_a_grid/meta.json filter=lfs diff=lfs merge=lfs -text
 number_of_pairs_satisfying_inequality/meta.json filter=lfs diff=lfs merge=lfs -text
+number_of_zero_filled_subarrays/meta.json filter=lfs diff=lfs merge=lfs -text

number_of_subarrays_with_lcm_equal_to_k/ocaml_tests/main.ml

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

number_of_subarrays_with_lcm_equal_to_k/scala_tests/MySuite.scala

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

number_of_valid_clock_times/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 (countTime \"?5:00 \")," 2 (countTime "?5:00"))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (countTime \"0?:0? \")," 100 (countTime "0?:0?"))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (countTime \"??:?? \")," 1440 (countTime "??:??"))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1, TestLabel "Test2" test2]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

number_of_valid_clock_times/java_tests/Main.java

@@ -0,0 +1,25 @@
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+import java.util.List;
+import java.util.Arrays;
+import java.util.ArrayList;
+public class Main {
+    //Program start
+    
+    //Program end
+
+    @Test
+public void test1() {
+    assertEquals(2, countTime("?5:00"));
+}
+@Test
+public void test2() {
+    assertEquals(100, countTime("0?:0?"));
+}
+@Test
+public void test3() {
+    assertEquals(1440, countTime("??:??"));
+}
+
+}

number_of_valid_clock_times/meta.json

@@ -0,0 +1,72 @@
+{
+    "id": 2528,
+    "name": "number_of_valid_clock_times",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/number-of-valid-clock-times/",
+    "date": "1664582400000",
+    "task_description": "You are given a string of length `5` called `time`, representing the current time on a digital clock in the format `\"hh:mm\"`. The **earliest** possible time is `\"00:00\"` and the **latest** possible time is `\"23:59\"`. In the string `time`, the digits represented by the `?` symbol are **unknown**, and must be **replaced** with a digit from `0` to `9`. Return_ an integer _`answer`_, the number of valid clock times that can be created by replacing every _`?`_ with a digit from _`0`_ to _`9`. **Example 1:** ``` **Input:** time = \"?5:00\" **Output:** 2 **Explanation:** We can replace the ? with either a 0 or 1, producing \"05:00\" or \"15:00\". Note that we cannot replace it with a 2, since the time \"25:00\" is invalid. In total, we have two choices. ``` **Example 2:** ``` **Input:** time = \"0?:0?\" **Output:** 100 **Explanation:** Each ? can be replaced by any digit from 0 to 9, so we have 100 total choices. ``` **Example 3:** ``` **Input:** time = \"??:??\" **Output:** 1440 **Explanation:** There are 24 possible choices for the hours, and 60 possible choices for the minutes. In total, we have 24 * 60 = 1440 choices. ``` **Constraints:** `time` is a valid string of length `5` in the format `\"hh:mm\"`. `\"00\" <= hh <= \"23\"` `\"00\" <= mm <= \"59\"` Some of the digits might be replaced with `'?'` and need to be replaced with digits from `0` to `9`.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "time = \"?5:00\"",
+            "output": "2 "
+        },
+        {
+            "label": "Example 2",
+            "input": "time = \"0?:0?\"",
+            "output": "100 "
+        },
+        {
+            "label": "Example 3",
+            "input": "time = \"??:??\"",
+            "output": "1440 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": "\"0?:??\"",
+            "output": 600
+        },
+        {
+            "input": "\"00:00\"",
+            "output": 1
+        },
+        {
+            "input": "\"?0:00\"",
+            "output": 3
+        },
+        {
+            "input": "\"00:0?\"",
+            "output": 10
+        },
+        {
+            "input": "\"??:?0\"",
+            "output": 144
+        },
+        {
+            "input": "\"?0:00\"",
+            "output": 3
+        },
+        {
+            "input": "00:?0",
+            "output": 6
+        },
+        {
+            "input": "?0:0?",
+            "output": 30
+        },
+        {
+            "input": "??:0?",
+            "output": 240
+        },
+        {
+            "input": "00:?0",
+            "output": 6
+        }
+    ],
+    "haskell_template": "countTime :: String -> Int\ncountTime time ",
+    "ocaml_template": "let countTime (time: string) : int =  ",
+    "scala_template": "def countTime(time: String): Int = { \n    \n}",
+    "java_template": "public static int countTime(String time) {\n\n}",
+    "python_template": "class Solution(object):\n    def countTime(self, time):\n        \"\"\"\n        :type time: str\n        :rtype: int\n        \"\"\"\n        "
+}

number_of_valid_clock_times/ocaml_tests/main.ml

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

number_of_valid_clock_times/scala_tests/MySuite.scala

@@ -0,0 +1,16 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.countTime("?5:00"), 2)
+  }
+
+  test("test2") {
+    assertEquals(Main.countTime("0?:0?"), 100)
+  }
+
+  test("test3") {
+    assertEquals(Main.countTime("??:??"), 1440)
+  }
+
+}

number_of_ways_to_buy_pens_and_pencils/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 (waysToBuyPensPencils 20 10 5)," 9 (waysToBuyPensPencils 20 10 5))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (waysToBuyPensPencils 5 10 10)," 1 (waysToBuyPensPencils 5 10 10))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

number_of_ways_to_buy_pens_and_pencils/java_tests/Main.java

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

number_of_ways_to_buy_pens_and_pencils/meta.json

@@ -0,0 +1,107 @@
+{
+    "id": 2351,
+    "name": "number_of_ways_to_buy_pens_and_pencils",
+    "difficulty": "Medium",
+    "link": "https://leetcode.com/problems/number-of-ways-to-buy-pens-and-pencils/",
+    "date": "1648857600000",
+    "task_description": "You are given an integer `total` indicating the amount of money you have. You are also given two integers `cost1` and `cost2` indicating the price of a pen and pencil respectively. You can spend **part or all** of your money to buy multiple quantities (or none) of each kind of writing utensil. Return _the **number of distinct ways** you can buy some number of pens and pencils._ **Example 1:** ``` **Input:** total = 20, cost1 = 10, cost2 = 5 **Output:** 9 **Explanation:** The price of a pen is 10 and the price of a pencil is 5. - If you buy 0 pens, you can buy 0, 1, 2, 3, or 4 pencils. - If you buy 1 pen, you can buy 0, 1, or 2 pencils. - If you buy 2 pens, you cannot buy any pencils. The total number of ways to buy pens and pencils is 5 + 3 + 1 = 9. ``` **Example 2:** ``` **Input:** total = 5, cost1 = 10, cost2 = 10 **Output:** 1 **Explanation:** The price of both pens and pencils are 10, which cost more than total, so you cannot buy any writing utensils. Therefore, there is only 1 way: buy 0 pens and 0 pencils. ``` **Constraints:** `1 <= total, cost1, cost2 <= 106`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "total = 20, cost1 = 10, cost2 = 5",
+            "output": "9 "
+        },
+        {
+            "label": "Example 2",
+            "input": "total = 5, cost1 = 10, cost2 = 10",
+            "output": "1 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                871631,
+                186467,
+                13636
+            ],
+            "output": 185
+        },
+        {
+            "input": [
+                423637,
+                960136,
+                274492
+            ],
+            "output": 2
+        },
+        {
+            "input": [
+                618175,
+                609876,
+                581435
+            ],
+            "output": 3
+        },
+        {
+            "input": [
+                361954,
+                240150,
+                612661
+            ],
+            "output": 2
+        },
+        {
+            "input": [
+                83875,
+                968567,
+                762526
+            ],
+            "output": 1
+        },
+        {
+            "input": [
+                580653,
+                474757,
+                204541
+            ],
+            "output": 4
+        },
+        {
+            "input": [
+                214815,
+                107733,
+                426649
+            ],
+            "output": 2
+        },
+        {
+            "input": [
+                358410,
+                852082,
+                390378
+            ],
+            "output": 1
+        },
+        {
+            "input": [
+                200117,
+                650561,
+                233174
+            ],
+            "output": 1
+        },
+        {
+            "input": [
+                563273,
+                879850,
+                328505
+            ],
+            "output": 2
+        }
+    ],
+    "haskell_template": "waysToBuyPensPencils :: Int -> Int -> Int -> Int\nwaysToBuyPensPencils total cost1 cost2 ",
+    "ocaml_template": "let waysToBuyPensPencils (total: int) (cost1: int) (cost2: int) : int =  ",
+    "scala_template": "def waysToBuyPensPencils(total: Int,cost1: Int,cost2: Int): Int = { \n    \n}",
+    "java_template": "public static int waysToBuyPensPencils(int total, int cost1, int cost2) {\n\n}",
+    "python_template": "class Solution(object):\n    def waysToBuyPensPencils(self, total, cost1, cost2):\n        \"\"\"\n        :type total: int\n        :type cost1: int\n        :type cost2: int\n        :rtype: int\n        \"\"\"\n        "
+}

number_of_ways_to_buy_pens_and_pencils/ocaml_tests/main.ml

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

number_of_ways_to_buy_pens_and_pencils/scala_tests/MySuite.scala

@@ -0,0 +1,12 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.waysToBuyPensPencils(20,10,5), 9)
+  }
+
+  test("test2") {
+    assertEquals(Main.waysToBuyPensPencils(5,10,10), 1)
+  }
+
+}

number_of_ways_to_divide_a_long_corridor/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 (numberOfWays \"SSPPSPS \")," 3 (numberOfWays "SSPPSPS"))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (numberOfWays \"PPSPSP \")," 1 (numberOfWays "PPSPSP"))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (numberOfWays \"S \")," 0 (numberOfWays "S"))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1, TestLabel "Test2" test2]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

number_of_ways_to_divide_a_long_corridor/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, numberOfWays("SSPPSPS"));
+}
+@Test
+public void test2() {
+    assertEquals(1, numberOfWays("PPSPSP"));
+}
+@Test
+public void test3() {
+    assertEquals(0, numberOfWays("S"));
+}
+
+}

number_of_ways_to_divide_a_long_corridor/meta.json

@@ -0,0 +1,72 @@
+{
+    "id": 2251,
+    "name": "number_of_ways_to_divide_a_long_corridor",
+    "difficulty": "Hard",
+    "link": "https://leetcode.com/problems/number-of-ways-to-divide-a-long-corridor/",
+    "date": "1641600000000",
+    "task_description": "Along a long library corridor, there is a line of seats and decorative plants. You are given a **0-indexed** string `corridor` of length `n` consisting of letters `'S'` and `'P'` where each `'S'` represents a seat and each `'P'` represents a plant. One room divider has **already** been installed to the left of index `0`, and **another** to the right of index `n - 1`. Additional room dividers can be installed. For each position between indices `i - 1` and `i` (`1 <= i <= n - 1`), at most one divider can be installed. Divide the corridor into non-overlapping sections, where each section has **exactly two seats** with any number of plants. There may be multiple ways to perform the division. Two ways are **different** if there is a position with a room divider installed in the first way but not in the second way. Return _the number of ways to divide the corridor_. Since the answer may be very large, return it **modulo** `109 + 7`. If there is no way, return `0`. **Example 1:** ``` **Input:** corridor = \"SSPPSPS\" **Output:** 3 **Explanation:** There are 3 different ways to divide the corridor. The black bars in the above image indicate the two room dividers already installed. Note that in each of the ways, **each** section has exactly **two** seats. ``` **Example 2:** ``` **Input:** corridor = \"PPSPSP\" **Output:** 1 **Explanation:** There is only 1 way to divide the corridor, by not installing any additional dividers. Installing any would create some section that does not have exactly two seats. ``` **Example 3:** ``` **Input:** corridor = \"S\" **Output:** 0 **Explanation:** There is no way to divide the corridor because there will always be a section that does not have exactly two seats. ``` **Constraints:** `n == corridor.length` `1 <= n <= 105` `corridor[i]` is either `'S'` or `'P'`.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "corridor = \"SSPPSPS\"",
+            "output": "3 "
+        },
+        {
+            "label": "Example 2",
+            "input": "corridor = \"PPSPSP\"",
+            "output": "1 "
+        },
+        {
+            "label": "Example 3",
+            "input": "corridor = \"S\"",
+            "output": "0 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": "SSPSSSSSPSSSPSSPSSSSSPSSPSSSSSPSSPSSPPSSSSSSSPPSSSPPPSSSSPPSSSSPSSSSPSSSSSPS",
+            "output": 4608
+        },
+        {
+            "input": "PPSPSPSSSSSSPPSSSSSPSPSPSPSSPPPPSPSSSSSSPSSPSSSSPSSPSSSSSSSPSSSSSSSPSSPSPSPPSPSSSSSPPSSPPS",
+            "output": 960
+        },
+        {
+            "input": "SPSSPSPSSSSSSS",
+            "output": 0
+        },
+        {
+            "input": "SSSSSSSSSSSSSSSSSSSSSSSPPSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSPSPSSSSSSSS",
+            "output": 0
+        },
+        {
+            "input": "PPSPPPSSSSPPPPPPPPPPSSPSSPPPSPPPPSPPSSPSPPPPPPPPPPPPPPPPPPPPPPPPPPP",
+            "output": 5
+        },
+        {
+            "input": "PPPPPPPSPPPPPSPPSSSSPPPPPPPSSSPPSSSPSPSSPPSPSPPP",
+            "output": 0
+        },
+        {
+            "input": "SSSSSSPSSPSSSSSSSSSSSSSS",
+            "output": 4
+        },
+        {
+            "input": "PSSPPSPPSSSPSS",
+            "output": 6
+        },
+        {
+            "input": "PPPPPSPPPPPPPPPPPPPPPSPSSSSPPPPP",
+            "output": 2
+        },
+        {
+            "input": "SSSSSSSSSSSPSSSSSSSSSSSSS",
+            "output": 1
+        }
+    ],
+    "haskell_template": "numberOfWays :: String -> Int\nnumberOfWays corridor ",
+    "ocaml_template": "let numberOfWays (corridor: string) : int =  ",
+    "scala_template": "def numberOfWays(corridor: String): Int = { \n    \n}",
+    "java_template": "public static int numberOfWays(String corridor) {\n\n}",
+    "python_template": "class Solution(object):\n    def numberOfWays(self, corridor):\n        \"\"\"\n        :type corridor: str\n        :rtype: int\n        \"\"\"\n        "
+}

number_of_ways_to_divide_a_long_corridor/ocaml_tests/main.ml

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

number_of_ways_to_divide_a_long_corridor/scala_tests/MySuite.scala

@@ -0,0 +1,16 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.numberOfWays("SSPPSPS"), 3)
+  }
+
+  test("test2") {
+    assertEquals(Main.numberOfWays("PPSPSP"), 1)
+  }
+
+  test("test3") {
+    assertEquals(Main.numberOfWays("S"), 0)
+  }
+
+}

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

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

number_of_ways_to_earn_points/meta.json

@@ -0,0 +1,1300 @@
+{
+    "id": 2648,
+    "name": "number_of_ways_to_earn_points",
+    "difficulty": "Hard",
+    "link": "https://leetcode.com/problems/number-of-ways-to-earn-points/",
+    "date": "1677369600000",
+    "task_description": "There is a test that has `n` types of questions. You are given an integer `target` and a **0-indexed** 2D integer array `types` where `types[i] = [counti, marksi]` indicates that there are `counti` questions of the `ith` type, and each one of them is worth `marksi` points. Return _the number of ways you can earn **exactly** _`target`_ points in the exam_. Since the answer may be too large, return it **modulo** `109 + 7`. **Note** that questions of the same type are indistinguishable. For example, if there are `3` questions of the same type, then solving the `1st` and `2nd` questions is the same as solving the `1st` and `3rd` questions, or the `2nd` and `3rd` questions. **Example 1:** ``` **Input:** target = 6, types = [[6,1],[3,2],[2,3]] **Output:** 7 **Explanation:** You can earn 6 points in one of the seven ways: - Solve 6 questions of the 0th type: 1 + 1 + 1 + 1 + 1 + 1 = 6 - Solve 4 questions of the 0th type and 1 question of the 1st type: 1 + 1 + 1 + 1 + 2 = 6 - Solve 2 questions of the 0th type and 2 questions of the 1st type: 1 + 1 + 2 + 2 = 6 - Solve 3 questions of the 0th type and 1 question of the 2nd type: 1 + 1 + 1 + 3 = 6 - Solve 1 question of the 0th type, 1 question of the 1st type and 1 question of the 2nd type: 1 + 2 + 3 = 6 - Solve 3 questions of the 1st type: 2 + 2 + 2 = 6 - Solve 2 questions of the 2nd type: 3 + 3 = 6 ``` **Example 2:** ``` **Input:** target = 5, types = [[50,1],[50,2],[50,5]] **Output:** 4 **Explanation:** You can earn 5 points in one of the four ways: - Solve 5 questions of the 0th type: 1 + 1 + 1 + 1 + 1 = 5 - Solve 3 questions of the 0th type and 1 question of the 1st type: 1 + 1 + 1 + 2 = 5 - Solve 1 questions of the 0th type and 2 questions of the 1st type: 1 + 2 + 2 = 5 - Solve 1 question of the 2nd type: 5 ``` **Example 3:** ``` **Input:** target = 18, types = [[6,1],[3,2],[2,3]] **Output:** 1 **Explanation:** You can only earn 18 points by answering all questions. ``` **Constraints:** `1 <= target <= 1000` `n == types.length` `1 <= n <= 50` `types[i].length == 2` `1 <= counti, marksi <= 50`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "target = 6, types = [[6,1],[3,2],[2,3]]",
+            "output": "7 "
+        },
+        {
+            "label": "Example 2",
+            "input": "target = 5, types = [[50,1],[50,2],[50,5]]",
+            "output": "4 "
+        },
+        {
+            "label": "Example 3",
+            "input": "target = 18, types = [[6,1],[3,2],[2,3]]",
+            "output": "1 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                862,
+                [
+                    [
+                        9,
+                        7
+                    ],
+                    [
+                        2,
+                        36
+                    ],
+                    [
+                        32,
+                        8
+                    ],
+                    [
+                        5,
+                        37
+                    ],
+                    [
+                        6,
+                        35
+                    ],
+                    [
+                        30,
+                        2
+                    ],
+                    [
+                        23,
+                        18
+                    ],
+                    [
+                        48,
+                        47
+                    ],
+                    [
+                        33,
+                        30
+                    ],
+                    [
+                        6,
+                        24
+                    ],
+                    [
+                        39,
+                        20
+                    ],
+                    [
+                        33,
+                        40
+                    ],
+                    [
+                        40,
+                        18
+                    ],
+                    [
+                        49,
+                        33
+                    ],
+                    [
+                        16,
+                        3
+                    ],
+                    [
+                        32,
+                        22
+                    ],
+                    [
+                        2,
+                        22
+                    ],
+                    [
+                        11,
+                        48
+                    ],
+                    [
+                        16,
+                        47
+                    ],
+                    [
+                        27,
+                        9
+                    ],
+                    [
+                        44,
+                        48
+                    ],
+                    [
+                        18,
+                        29
+                    ],
+                    [
+                        7,
+                        2
+                    ],
+                    [
+                        33,
+                        16
+                    ],
+                    [
+                        40,
+                        1
+                    ],
+                    [
+                        19,
+                        47
+                    ],
+                    [
+                        34,
+                        33
+                    ],
+                    [
+                        26,
+                        8
+                    ],
+                    [
+                        39,
+                        11
+                    ],
+                    [
+                        37,
+                        25
+                    ],
+                    [
+                        26,
+                        39
+                    ],
+                    [
+                        38,
+                        15
+                    ],
+                    [
+                        13,
+                        49
+                    ],
+                    [
+                        48,
+                        18
+                    ],
+                    [
+                        17,
+                        37
+                    ],
+                    [
+                        43,
+                        1
+                    ],
+                    [
+                        44,
+                        36
+                    ],
+                    [
+                        23,
+                        33
+                    ]
+                ]
+            ],
+            "output": 544536689
+        },
+        {
+            "input": [
+                971,
+                [
+                    [
+                        44,
+                        8
+                    ],
+                    [
+                        14,
+                        40
+                    ],
+                    [
+                        30,
+                        1
+                    ],
+                    [
+                        11,
+                        12
+                    ],
+                    [
+                        26,
+                        3
+                    ],
+                    [
+                        31,
+                        7
+                    ],
+                    [
+                        39,
+                        3
+                    ],
+                    [
+                        26,
+                        44
+                    ],
+                    [
+                        46,
+                        24
+                    ],
+                    [
+                        17,
+                        7
+                    ],
+                    [
+                        12,
+                        25
+                    ],
+                    [
+                        15,
+                        22
+                    ],
+                    [
+                        39,
+                        18
+                    ],
+                    [
+                        4,
+                        11
+                    ],
+                    [
+                        12,
+                        40
+                    ]
+                ]
+            ],
+            "output": 670104762
+        },
+        {
+            "input": [
+                891,
+                [
+                    [
+                        47,
+                        18
+                    ],
+                    [
+                        19,
+                        9
+                    ],
+                    [
+                        25,
+                        34
+                    ],
+                    [
+                        37,
+                        34
+                    ],
+                    [
+                        4,
+                        38
+                    ],
+                    [
+                        42,
+                        45
+                    ],
+                    [
+                        7,
+                        43
+                    ],
+                    [
+                        14,
+                        34
+                    ],
+                    [
+                        13,
+                        22
+                    ],
+                    [
+                        21,
+                        50
+                    ],
+                    [
+                        3,
+                        2
+                    ],
+                    [
+                        12,
+                        30
+                    ],
+                    [
+                        13,
+                        27
+                    ],
+                    [
+                        8,
+                        1
+                    ],
+                    [
+                        47,
+                        34
+                    ],
+                    [
+                        20,
+                        49
+                    ],
+                    [
+                        37,
+                        3
+                    ],
+                    [
+                        6,
+                        30
+                    ],
+                    [
+                        27,
+                        32
+                    ],
+                    [
+                        38,
+                        21
+                    ],
+                    [
+                        36,
+                        42
+                    ],
+                    [
+                        43,
+                        27
+                    ],
+                    [
+                        46,
+                        35
+                    ],
+                    [
+                        8,
+                        18
+                    ],
+                    [
+                        35,
+                        48
+                    ],
+                    [
+                        4,
+                        21
+                    ],
+                    [
+                        16,
+                        50
+                    ],
+                    [
+                        42,
+                        23
+                    ],
+                    [
+                        26,
+                        39
+                    ],
+                    [
+                        40,
+                        22
+                    ],
+                    [
+                        46,
+                        39
+                    ],
+                    [
+                        14,
+                        24
+                    ],
+                    [
+                        24,
+                        37
+                    ],
+                    [
+                        12,
+                        29
+                    ],
+                    [
+                        48,
+                        45
+                    ],
+                    [
+                        13,
+                        28
+                    ],
+                    [
+                        39,
+                        47
+                    ],
+                    [
+                        41,
+                        36
+                    ]
+                ]
+            ],
+            "output": 605233870
+        },
+        {
+            "input": [
+                194,
+                [
+                    [
+                        8,
+                        48
+                    ],
+                    [
+                        23,
+                        4
+                    ],
+                    [
+                        48,
+                        7
+                    ],
+                    [
+                        28,
+                        5
+                    ],
+                    [
+                        44,
+                        17
+                    ],
+                    [
+                        4,
+                        27
+                    ],
+                    [
+                        14,
+                        18
+                    ],
+                    [
+                        40,
+                        36
+                    ],
+                    [
+                        10,
+                        8
+                    ],
+                    [
+                        17,
+                        31
+                    ],
+                    [
+                        16,
+                        33
+                    ],
+                    [
+                        7,
+                        29
+                    ],
+                    [
+                        15,
+                        49
+                    ],
+                    [
+                        49,
+                        45
+                    ],
+                    [
+                        24,
+                        22
+                    ],
+                    [
+                        33,
+                        49
+                    ],
+                    [
+                        6,
+                        2
+                    ],
+                    [
+                        35,
+                        26
+                    ],
+                    [
+                        7,
+                        2
+                    ],
+                    [
+                        45,
+                        23
+                    ],
+                    [
+                        27,
+                        46
+                    ],
+                    [
+                        48,
+                        20
+                    ],
+                    [
+                        14,
+                        28
+                    ],
+                    [
+                        30,
+                        5
+                    ],
+                    [
+                        42,
+                        18
+                    ],
+                    [
+                        50,
+                        32
+                    ],
+                    [
+                        14,
+                        1
+                    ],
+                    [
+                        7,
+                        43
+                    ],
+                    [
+                        6,
+                        8
+                    ],
+                    [
+                        45,
+                        13
+                    ],
+                    [
+                        47,
+                        2
+                    ],
+                    [
+                        34,
+                        12
+                    ],
+                    [
+                        22,
+                        2
+                    ],
+                    [
+                        1,
+                        49
+                    ],
+                    [
+                        40,
+                        9
+                    ],
+                    [
+                        9,
+                        5
+                    ]
+                ]
+            ],
+            "output": 163333403
+        },
+        {
+            "input": [
+                593,
+                [
+                    [
+                        28,
+                        27
+                    ],
+                    [
+                        32,
+                        42
+                    ],
+                    [
+                        16,
+                        34
+                    ],
+                    [
+                        9,
+                        30
+                    ],
+                    [
+                        14,
+                        16
+                    ],
+                    [
+                        33,
+                        49
+                    ],
+                    [
+                        6,
+                        47
+                    ],
+                    [
+                        11,
+                        21
+                    ],
+                    [
+                        14,
+                        31
+                    ],
+                    [
+                        18,
+                        33
+                    ],
+                    [
+                        26,
+                        25
+                    ],
+                    [
+                        29,
+                        47
+                    ],
+                    [
+                        40,
+                        41
+                    ],
+                    [
+                        17,
+                        31
+                    ],
+                    [
+                        7,
+                        10
+                    ],
+                    [
+                        6,
+                        1
+                    ],
+                    [
+                        3,
+                        3
+                    ],
+                    [
+                        2,
+                        23
+                    ],
+                    [
+                        34,
+                        26
+                    ],
+                    [
+                        8,
+                        39
+                    ],
+                    [
+                        2,
+                        48
+                    ],
+                    [
+                        37,
+                        39
+                    ],
+                    [
+                        35,
+                        42
+                    ],
+                    [
+                        45,
+                        11
+                    ],
+                    [
+                        16,
+                        24
+                    ],
+                    [
+                        19,
+                        6
+                    ],
+                    [
+                        17,
+                        4
+                    ],
+                    [
+                        12,
+                        3
+                    ]
+                ]
+            ],
+            "output": 168221700
+        },
+        {
+            "input": [
+                506,
+                [
+                    [
+                        39,
+                        49
+                    ],
+                    [
+                        16,
+                        47
+                    ],
+                    [
+                        17,
+                        36
+                    ],
+                    [
+                        44,
+                        33
+                    ],
+                    [
+                        43,
+                        22
+                    ],
+                    [
+                        37,
+                        17
+                    ],
+                    [
+                        20,
+                        20
+                    ],
+                    [
+                        19,
+                        44
+                    ],
+                    [
+                        45,
+                        32
+                    ],
+                    [
+                        16,
+                        29
+                    ],
+                    [
+                        24,
+                        27
+                    ],
+                    [
+                        42,
+                        29
+                    ],
+                    [
+                        10,
+                        40
+                    ],
+                    [
+                        27,
+                        12
+                    ],
+                    [
+                        16,
+                        19
+                    ],
+                    [
+                        43,
+                        26
+                    ],
+                    [
+                        1,
+                        31
+                    ],
+                    [
+                        11,
+                        29
+                    ],
+                    [
+                        22,
+                        20
+                    ],
+                    [
+                        14,
+                        31
+                    ],
+                    [
+                        11,
+                        26
+                    ],
+                    [
+                        11,
+                        24
+                    ]
+                ]
+            ],
+            "output": 216374332
+        },
+        {
+            "input": [
+                683,
+                [
+                    [
+                        37,
+                        23
+                    ],
+                    [
+                        2,
+                        3
+                    ],
+                    [
+                        8,
+                        44
+                    ],
+                    [
+                        26,
+                        48
+                    ],
+                    [
+                        17,
+                        2
+                    ],
+                    [
+                        13,
+                        36
+                    ],
+                    [
+                        26,
+                        16
+                    ],
+                    [
+                        10,
+                        23
+                    ],
+                    [
+                        46,
+                        9
+                    ],
+                    [
+                        10,
+                        37
+                    ],
+                    [
+                        30,
+                        23
+                    ],
+                    [
+                        16,
+                        50
+                    ],
+                    [
+                        18,
+                        38
+                    ],
+                    [
+                        49,
+                        28
+                    ],
+                    [
+                        6,
+                        50
+                    ],
+                    [
+                        4,
+                        43
+                    ],
+                    [
+                        40,
+                        31
+                    ],
+                    [
+                        36,
+                        20
+                    ],
+                    [
+                        3,
+                        15
+                    ],
+                    [
+                        46,
+                        29
+                    ],
+                    [
+                        48,
+                        14
+                    ],
+                    [
+                        25,
+                        29
+                    ],
+                    [
+                        31,
+                        33
+                    ],
+                    [
+                        25,
+                        24
+                    ],
+                    [
+                        10,
+                        26
+                    ],
+                    [
+                        9,
+                        29
+                    ],
+                    [
+                        13,
+                        12
+                    ],
+                    [
+                        22,
+                        13
+                    ],
+                    [
+                        21,
+                        26
+                    ],
+                    [
+                        30,
+                        24
+                    ],
+                    [
+                        39,
+                        38
+                    ],
+                    [
+                        5,
+                        28
+                    ],
+                    [
+                        30,
+                        16
+                    ],
+                    [
+                        9,
+                        4
+                    ],
+                    [
+                        11,
+                        14
+                    ],
+                    [
+                        18,
+                        37
+                    ],
+                    [
+                        5,
+                        43
+                    ],
+                    [
+                        17,
+                        30
+                    ],
+                    [
+                        18,
+                        39
+                    ],
+                    [
+                        26,
+                        43
+                    ],
+                    [
+                        46,
+                        29
+                    ],
+                    [
+                        9,
+                        44
+                    ]
+                ]
+            ],
+            "output": 733333952
+        },
+        {
+            "input": [
+                84,
+                [
+                    [
+                        42,
+                        12
+                    ],
+                    [
+                        9,
+                        40
+                    ],
+                    [
+                        30,
+                        48
+                    ],
+                    [
+                        13,
+                        9
+                    ],
+                    [
+                        42,
+                        40
+                    ],
+                    [
+                        19,
+                        2
+                    ],
+                    [
+                        21,
+                        42
+                    ],
+                    [
+                        44,
+                        10
+                    ],
+                    [
+                        25,
+                        48
+                    ],
+                    [
+                        46,
+                        38
+                    ],
+                    [
+                        1,
+                        16
+                    ],
+                    [
+                        40,
+                        43
+                    ],
+                    [
+                        32,
+                        46
+                    ],
+                    [
+                        38,
+                        11
+                    ],
+                    [
+                        31,
+                        6
+                    ],
+                    [
+                        2,
+                        3
+                    ],
+                    [
+                        3,
+                        49
+                    ],
+                    [
+                        42,
+                        36
+                    ],
+                    [
+                        45,
+                        49
+                    ],
+                    [
+                        20,
+                        35
+                    ]
+                ]
+            ],
+            "output": 5707
+        },
+        {
+            "input": [
+                85,
+                [
+                    [
+                        28,
+                        19
+                    ],
+                    [
+                        25,
+                        12
+                    ],
+                    [
+                        7,
+                        13
+                    ],
+                    [
+                        1,
+                        15
+                    ],
+                    [
+                        17,
+                        2
+                    ],
+                    [
+                        21,
+                        32
+                    ],
+                    [
+                        42,
+                        35
+                    ],
+                    [
+                        33,
+                        12
+                    ],
+                    [
+                        38,
+                        7
+                    ],
+                    [
+                        34,
+                        29
+                    ],
+                    [
+                        25,
+                        49
+                    ],
+                    [
+                        45,
+                        26
+                    ],
+                    [
+                        44,
+                        21
+                    ],
+                    [
+                        10,
+                        3
+                    ],
+                    [
+                        7,
+                        49
+                    ],
+                    [
+                        14,
+                        26
+                    ],
+                    [
+                        22,
+                        25
+                    ],
+                    [
+                        7,
+                        29
+                    ],
+                    [
+                        44,
+                        42
+                    ],
+                    [
+                        1,
+                        3
+                    ],
+                    [
+                        35,
+                        29
+                    ],
+                    [
+                        44,
+                        1
+                    ],
+                    [
+                        33,
+                        21
+                    ],
+                    [
+                        1,
+                        45
+                    ],
+                    [
+                        13,
+                        37
+                    ],
+                    [
+                        14,
+                        30
+                    ],
+                    [
+                        47,
+                        44
+                    ],
+                    [
+                        45,
+                        17
+                    ],
+                    [
+                        28,
+                        33
+                    ],
+                    [
+                        9,
+                        2
+                    ],
+                    [
+                        11,
+                        33
+                    ],
+                    [
+                        19,
+                        4
+                    ],
+                    [
+                        22,
+                        46
+                    ],
+                    [
+                        32,
+                        23
+                    ],
+                    [
+                        25,
+                        5
+                    ],
+                    [
+                        17,
+                        39
+                    ],
+                    [
+                        41,
+                        19
+                    ],
+                    [
+                        29,
+                        43
+                    ],
+                    [
+                        22,
+                        39
+                    ],
+                    [
+                        15,
+                        13
+                    ],
+                    [
+                        7,
+                        33
+                    ],
+                    [
+                        10,
+                        14
+                    ],
+                    [
+                        33,
+                        24
+                    ],
+                    [
+                        4,
+                        3
+                    ],
+                    [
+                        22,
+                        47
+                    ],
+                    [
+                        35,
+                        4
+                    ],
+                    [
+                        19,
+                        50
+                    ],
+                    [
+                        31,
+                        34
+                    ],
+                    [
+                        28,
+                        45
+                    ],
+                    [
+                        28,
+                        43
+                    ]
+                ]
+            ],
+            "output": 230998762
+        },
+        {
+            "input": [
+                173,
+                [
+                    [
+                        16,
+                        26
+                    ],
+                    [
+                        26,
+                        5
+                    ],
+                    [
+                        49,
+                        1
+                    ],
+                    [
+                        4,
+                        11
+                    ],
+                    [
+                        31,
+                        44
+                    ],
+                    [
+                        35,
+                        16
+                    ],
+                    [
+                        48,
+                        25
+                    ],
+                    [
+                        20,
+                        49
+                    ]
+                ]
+            ],
+            "output": 7298
+        }
+    ],
+    "haskell_template": "waysToReachTarget :: Int -> [[Int]] -> Int\nwaysToReachTarget target types ",
+    "ocaml_template": "let waysToReachTarget (target: int) (types: int list list) : int =  ",
+    "scala_template": "def waysToReachTarget(target: Int,types: List[List[Int]]): Int = { \n    \n}",
+    "java_template": "public static int waysToReachTarget(int target, List<List<Integer>> types) {\n\n}",
+    "python_template": "class Solution(object):\n    def waysToReachTarget(self, target, types):\n        \"\"\"\n        :type target: int\n        :type types: List[List[int]]\n        :rtype: int\n        \"\"\"\n        "
+}

number_of_ways_to_earn_points/ocaml_tests/main.ml

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

number_of_ways_to_earn_points/scala_tests/MySuite.scala

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

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

number_of_ways_to_reach_a_position_after_exactly_k_steps/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, numberOfWays(1, 2, 3));
+}
+@Test
+public void test2() {
+    assertEquals(0, numberOfWays(2, 5, 10));
+}
+
+}

number_of_ways_to_reach_a_position_after_exactly_k_steps/meta.json

@@ -0,0 +1,107 @@
+{
+    "id": 2477,
+    "name": "number_of_ways_to_reach_a_position_after_exactly_k_steps",
+    "difficulty": "Medium",
+    "link": "https://leetcode.com/problems/number-of-ways-to-reach-a-position-after-exactly-k-steps/",
+    "date": "1661644800000",
+    "task_description": "You are given two **positive** integers `startPos` and `endPos`. Initially, you are standing at position `startPos` on an **infinite** number line. With one step, you can move either one position to the left, or one position to the right. Given a positive integer `k`, return _the number of **different** ways to reach the position _`endPos`_ starting from _`startPos`_, such that you perform **exactly** _`k`_ steps_. Since the answer may be very large, return it **modulo** `109 + 7`. Two ways are considered different if the order of the steps made is not exactly the same. **Note** that the number line includes negative integers. **Example 1:** ``` **Input:** startPos = 1, endPos = 2, k = 3 **Output:** 3 **Explanation:** We can reach position 2 from 1 in exactly 3 steps in three ways: - 1 -> 2 -> 3 -> 2. - 1 -> 2 -> 1 -> 2. - 1 -> 0 -> 1 -> 2. It can be proven that no other way is possible, so we return 3. ``` **Example 2:** ``` **Input:** startPos = 2, endPos = 5, k = 10 **Output:** 0 **Explanation:** It is impossible to reach position 5 from position 2 in exactly 10 steps. ``` **Constraints:** `1 <= startPos, endPos, k <= 1000`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "startPos = 1, endPos = 2, k = 3",
+            "output": "3 "
+        },
+        {
+            "label": "Example 2",
+            "input": "startPos = 2, endPos = 5, k = 10",
+            "output": "0 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                67,
+                535,
+                157
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                67,
+                426,
+                905
+            ],
+            "output": 478687450
+        },
+        {
+            "input": [
+                670,
+                912,
+                370
+            ],
+            "output": 945230893
+        },
+        {
+            "input": [
+                164,
+                96,
+                789
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                57,
+                796,
+                866
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                105,
+                690,
+                749
+            ],
+            "output": 435423671
+        },
+        {
+            "input": [
+                281,
+                224,
+                7
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                86,
+                331,
+                691
+            ],
+            "output": 156456068
+        },
+        {
+            "input": [
+                489,
+                72,
+                188
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                385,
+                136,
+                541
+            ],
+            "output": 678519907
+        }
+    ],
+    "haskell_template": "numberOfWays :: Int -> Int -> Int -> Int\nnumberOfWays startPos endPos k ",
+    "ocaml_template": "let numberOfWays (startPos: int) (endPos: int) (k: int) : int =  ",
+    "scala_template": "def numberOfWays(startPos: Int,endPos: Int,k: Int): Int = { \n    \n}",
+    "java_template": "public static int numberOfWays(int startPos, int endPos, int k) {\n\n}",
+    "python_template": "class Solution(object):\n    def numberOfWays(self, startPos, endPos, k):\n        \"\"\"\n        :type startPos: int\n        :type endPos: int\n        :type k: int\n        :rtype: int\n        \"\"\"\n        "
+}

number_of_ways_to_reach_a_position_after_exactly_k_steps/ocaml_tests/main.ml

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

number_of_ways_to_reach_a_position_after_exactly_k_steps/scala_tests/MySuite.scala

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

number_of_ways_to_select_buildings/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 (numberOfWays \"001101 \")," 6 (numberOfWays "001101"))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (numberOfWays \"11100 \")," 0 (numberOfWays "11100"))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

number_of_ways_to_select_buildings/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, numberOfWays("001101"));
+}
+@Test
+public void test2() {
+    assertEquals(0, numberOfWays("11100"));
+}
+
+}

number_of_ways_to_select_buildings/ocaml_tests/main.ml

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

number_of_ways_to_select_buildings/scala_tests/MySuite.scala

@@ -0,0 +1,12 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.numberOfWays("001101"), 6)
+  }
+
+  test("test2") {
+    assertEquals(Main.numberOfWays("11100"), 0)
+  }
+
+}

number_of_ways_to_split_array/java_tests/Main.java

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

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

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

number_of_zero_filled_subarrays/meta.json

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

number_of_zero_filled_subarrays/ocaml_tests/main.ml

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