4fd72f98993a86522f493405e676be94c9acfea805829bee0e1295ce16bba63c

.gitattributes

@@ -249,3 +249,6 @@ minimum_time_to_finish_the_race/meta.json filter=lfs diff=lfs merge=lfs -text
 minimum_time_to_repair_cars/meta.json filter=lfs diff=lfs merge=lfs -text
 minimum_total_cost_to_make_arrays_unequal/meta.json filter=lfs diff=lfs merge=lfs -text
 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

move_pieces_to_obtain_a_string/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 (canChange \"_L__R__R_ \"  \"L______RR \")," True (canChange "_L__R__R_" "L______RR"))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (canChange \"R_L_ \"  \"__LR \")," False (canChange "R_L_" "__LR"))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (canChange \"_R \"  \"R_ \")," False (canChange "_R" "R_"))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1, TestLabel "Test2" test2]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

move_pieces_to_obtain_a_string/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(true, canChange("_L__R__R_", "L______RR"));
+}
+@Test
+public void test2() {
+    assertEquals(false, canChange("R_L_", "__LR"));
+}
+@Test
+public void test3() {
+    assertEquals(false, canChange("_R", "R_"));
+}
+
+}

move_pieces_to_obtain_a_string/ocaml_tests/main.ml

@@ -0,0 +1,29 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal true (canChange "_L__R__R_" "L______RR")
+
+let test2 _ = assert_equal false (canChange "R_L_" "__LR")
+
+let test3 _ = assert_equal false (canChange "_R" "R_")
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for canChange" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+  "test3" >:: test3;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

move_pieces_to_obtain_a_string/scala_tests/MySuite.scala

@@ -0,0 +1,16 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.canChange("_L__R__R_","L______RR"), true)
+  }
+
+  test("test2") {
+    assertEquals(Main.canChange("R_L_","__LR"), false)
+  }
+
+  test("test3") {
+    assertEquals(Main.canChange("_R","R_"), false)
+  }
+
+}

movement_of_robots/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(8, sumDistance(new ArrayList<>(Arrays.asList(-2,0,2)), "RLL", 3));
+}
+@Test
+public void test2() {
+    assertEquals(5, sumDistance(new ArrayList<>(Arrays.asList(1,0)), "RL", 2));
+}
+
+}

movement_of_robots/meta.json

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

naming_a_company/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(6, distinctNames(Arrays.asList("coffee","donuts","time","toffee")));
+}
+@Test
+public void test2() {
+    assertEquals(0, distinctNames(Arrays.asList("lack","back")));
+}
+
+}

neighboring_bitwise_xor/java_tests/Main.java

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

neither_minimum_nor_maximum/haskell_tests/Main.hs

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

neither_minimum_nor_maximum/java_tests/Main.java

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

neither_minimum_nor_maximum/meta.json

@@ -0,0 +1,286 @@
+{
+    "id": 2836,
+    "name": "neither_minimum_nor_maximum",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/neither-minimum-nor-maximum/",
+    "date": "2023-06-04 00:00:00",
+    "task_description": "Given an integer array `nums` containing **distinct** **positive** integers, find and return **any** number from the array that is neither the **minimum** nor the **maximum** value in the array, or **`-1`** if there is no such number. Return _the selected integer._ **Example 1:** ``` **Input:** nums = [3,2,1,4] **Output:** 2 **Explanation:** In this example, the minimum value is 1 and the maximum value is 4. Therefore, either 2 or 3 can be valid answers. ``` **Example 2:** ``` **Input:** nums = [1,2] **Output:** -1 **Explanation:** Since there is no number in nums that is neither the maximum nor the minimum, we cannot select a number that satisfies the given condition. Therefore, there is no answer. ``` **Example 3:** ``` **Input:** nums = [2,1,3] **Output:** 2 **Explanation:** Since 2 is neither the maximum nor the minimum value in nums, it is the only valid answer. ``` **Constraints:** `1 <= nums.length <= 100` `1 <= nums[i] <= 100` All values in `nums` are distinct",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "nums = [3,2,1,4]",
+            "output": "2 "
+        },
+        {
+            "label": "Example 2",
+            "input": "nums = [1,2]",
+            "output": "-1 "
+        },
+        {
+            "label": "Example 3",
+            "input": "nums = [2,1,3]",
+            "output": "2 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                62,
+                86,
+                92,
+                47,
+                22,
+                36,
+                7,
+                99,
+                96,
+                84,
+                43,
+                48,
+                77,
+                41,
+                76,
+                59,
+                29,
+                32,
+                61,
+                26,
+                6,
+                42,
+                19,
+                18,
+                87,
+                24,
+                97,
+                14,
+                65,
+                98,
+                78,
+                72,
+                80,
+                16,
+                91,
+                21,
+                90,
+                94,
+                55,
+                25,
+                50,
+                51,
+                71,
+                5,
+                52,
+                8,
+                53,
+                67,
+                85,
+                56,
+                54,
+                58,
+                79,
+                88,
+                37,
+                11,
+                17,
+                81,
+                74,
+                89,
+                100,
+                23,
+                44,
+                57,
+                35,
+                66,
+                27,
+                20,
+                45,
+                12,
+                39,
+                38
+            ],
+            "output": 36
+        },
+        {
+            "input": [
+                90,
+                66,
+                94,
+                7,
+                88,
+                13
+            ],
+            "output": 88
+        },
+        {
+            "input": [
+                5,
+                64,
+                57,
+                98,
+                72,
+                92,
+                99,
+                12,
+                14,
+                18,
+                85,
+                62,
+                4,
+                77,
+                22,
+                81,
+                36,
+                63,
+                30,
+                55,
+                2,
+                27,
+                35
+            ],
+            "output": 57
+        },
+        {
+            "input": [
+                49,
+                21,
+                100,
+                37,
+                41,
+                38,
+                57,
+                2,
+                15,
+                81,
+                68,
+                98,
+                34,
+                31,
+                50,
+                14,
+                5,
+                20,
+                91,
+                86,
+                73,
+                83,
+                52,
+                30,
+                94,
+                80,
+                62,
+                53,
+                82,
+                39,
+                32,
+                23,
+                70,
+                36,
+                40,
+                96,
+                93
+            ],
+            "output": 37
+        },
+        {
+            "input": [
+                83,
+                61,
+                74,
+                75,
+                22,
+                11,
+                9,
+                6,
+                88,
+                23,
+                51,
+                89,
+                37,
+                96,
+                13,
+                33,
+                49,
+                94,
+                69,
+                78,
+                79,
+                55,
+                39,
+                57,
+                98,
+                21,
+                44,
+                30,
+                65,
+                100,
+                10,
+                87,
+                58,
+                34,
+                56,
+                41,
+                85,
+                45,
+                3,
+                48,
+                59,
+                62,
+                76,
+                92,
+                18,
+                93,
+                54,
+                42,
+                8,
+                7,
+                12,
+                31,
+                17,
+                19,
+                82,
+                4,
+                91,
+                70,
+                14,
+                32,
+                25,
+                16,
+                26,
+                50,
+                66,
+                81,
+                53,
+                77,
+                35,
+                71,
+                99,
+                27,
+                63,
+                5,
+                64,
+                28,
+                43,
+                1,
+                15,
+                36,
+                84,
+                20,
+                29,
+                46,
+                38,
+                95,
+                24,
+                68,
+                97,
+                60,
+                40
+            ],
+            "output": 74
+        }
+    ],
+    "haskell_template": "findNonMinOrMax :: [Int] -> Int\nfindNonMinOrMax nums ",
+    "ocaml_template": "let findNonMinOrMax (nums: int list) : int =  ",
+    "scala_template": "def findNonMinOrMax(nums: List[Int]): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public int findNonMinOrMax(int[] nums) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def findNonMinOrMax(self, nums):\n        \"\"\"\n        :type nums: List[int]\n        :rtype: int\n        \"\"\"\n        "
+}

neither_minimum_nor_maximum/ocaml_tests/main.ml

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

neither_minimum_nor_maximum/scala_tests/MySuite.scala

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

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

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

next_greater_element_iv/meta.json

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

next_greater_element_iv/ocaml_tests/main.ml

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

next_greater_element_iv/scala_tests/MySuite.scala

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

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

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

node_with_highest_edge_score/meta.json

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

node_with_highest_edge_score/ocaml_tests/main.ml

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

node_with_highest_edge_score/scala_tests/MySuite.scala

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

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

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

number_of_arithmetic_triplets/meta.json

@@ -0,0 +1,1015 @@
+{
+    "id": 2442,
+    "name": "number_of_arithmetic_triplets",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/number-of-arithmetic-triplets/",
+    "date": "1659225600000",
+    "task_description": "You are given a **0-indexed**, **strictly increasing** integer array `nums` and a positive integer `diff`. A triplet `(i, j, k)` is an **arithmetic triplet** if the following conditions are met: `i < j < k`, `nums[j] - nums[i] == diff`, and `nums[k] - nums[j] == diff`. Return _the number of unique **arithmetic triplets**._ **Example 1:** ``` **Input:** nums = [0,1,4,6,7,10], diff = 3 **Output:** 2 **Explanation:** (1, 2, 4) is an arithmetic triplet because both 7 - 4 == 3 and 4 - 1 == 3. (2, 4, 5) is an arithmetic triplet because both 10 - 7 == 3 and 7 - 4 == 3. ``` **Example 2:** ``` **Input:** nums = [4,5,6,7,8,9], diff = 2 **Output:** 2 **Explanation:** (0, 2, 4) is an arithmetic triplet because both 8 - 6 == 2 and 6 - 4 == 2. (1, 3, 5) is an arithmetic triplet because both 9 - 7 == 2 and 7 - 5 == 2. ``` **Constraints:** `3 <= nums.length <= 200` `0 <= nums[i] <= 200` `1 <= diff <= 50` `nums` is **strictly** increasing.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "nums = [0,1,4,6,7,10], diff = 3",
+            "output": "2 "
+        },
+        {
+            "label": "Example 2",
+            "input": "nums = [4,5,6,7,8,9], diff = 2",
+            "output": "2 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                [
+                    4,
+                    7,
+                    13,
+                    18,
+                    20,
+                    27,
+                    29,
+                    30,
+                    42,
+                    47,
+                    54,
+                    57,
+                    63,
+                    65,
+                    66,
+                    68,
+                    70,
+                    83,
+                    92,
+                    93,
+                    95,
+                    99,
+                    103,
+                    117,
+                    118,
+                    119,
+                    120,
+                    126,
+                    128,
+                    136,
+                    144,
+                    145,
+                    154,
+                    159,
+                    161,
+                    164,
+                    168,
+                    172,
+                    174,
+                    177,
+                    184,
+                    187,
+                    196,
+                    197,
+                    198,
+                    199
+                ],
+                26
+            ],
+            "output": 3
+        },
+        {
+            "input": [
+                [
+                    0,
+                    1,
+                    2,
+                    5,
+                    8,
+                    9,
+                    10,
+                    16,
+                    17,
+                    18,
+                    20,
+                    22,
+                    23,
+                    24,
+                    27,
+                    28,
+                    30,
+                    31,
+                    32,
+                    34,
+                    36,
+                    38,
+                    39,
+                    40,
+                    41,
+                    42,
+                    43,
+                    44,
+                    45,
+                    46,
+                    47,
+                    51,
+                    52,
+                    53,
+                    54,
+                    55,
+                    57,
+                    58,
+                    61,
+                    64,
+                    65,
+                    69,
+                    72,
+                    75,
+                    76,
+                    80,
+                    81,
+                    83,
+                    85,
+                    86,
+                    87,
+                    88,
+                    90,
+                    91,
+                    92,
+                    94,
+                    95,
+                    101,
+                    102,
+                    103,
+                    104,
+                    105,
+                    107,
+                    108,
+                    110,
+                    113,
+                    114,
+                    116,
+                    117,
+                    119,
+                    120,
+                    121,
+                    122,
+                    126,
+                    127,
+                    128,
+                    129,
+                    130,
+                    132,
+                    133,
+                    134,
+                    135,
+                    136,
+                    137,
+                    138,
+                    139,
+                    140,
+                    142,
+                    143,
+                    144,
+                    146,
+                    147,
+                    148,
+                    149,
+                    155,
+                    156,
+                    157,
+                    158,
+                    159,
+                    160,
+                    161,
+                    162,
+                    163,
+                    164,
+                    165,
+                    166,
+                    167,
+                    170,
+                    171,
+                    172,
+                    176,
+                    177,
+                    179,
+                    180,
+                    182,
+                    184,
+                    185,
+                    186,
+                    189,
+                    190,
+                    193,
+                    198,
+                    199
+                ],
+                26
+            ],
+            "output": 39
+        },
+        {
+            "input": [
+                [
+                    0,
+                    1,
+                    4,
+                    5,
+                    8,
+                    10,
+                    11,
+                    15,
+                    17,
+                    20,
+                    22,
+                    24,
+                    26,
+                    34,
+                    38,
+                    45,
+                    46,
+                    54,
+                    55,
+                    56,
+                    57,
+                    58,
+                    60,
+                    63,
+                    65,
+                    66,
+                    68,
+                    74,
+                    78,
+                    79,
+                    86,
+                    88,
+                    91,
+                    92,
+                    93,
+                    94,
+                    95,
+                    99,
+                    101,
+                    104,
+                    106,
+                    107,
+                    113,
+                    115,
+                    117,
+                    118,
+                    120,
+                    122,
+                    123,
+                    126,
+                    129,
+                    130,
+                    131,
+                    133,
+                    137,
+                    143,
+                    144,
+                    152,
+                    155,
+                    157,
+                    158,
+                    161,
+                    165,
+                    166,
+                    168,
+                    171,
+                    175,
+                    176,
+                    188,
+                    189,
+                    192,
+                    196,
+                    197
+                ],
+                17
+            ],
+            "output": 3
+        },
+        {
+            "input": [
+                [
+                    1,
+                    2,
+                    4,
+                    8,
+                    9,
+                    10,
+                    17,
+                    18,
+                    20,
+                    21,
+                    23,
+                    24,
+                    26,
+                    27,
+                    30,
+                    32,
+                    33,
+                    34,
+                    36,
+                    38,
+                    39,
+                    43,
+                    55,
+                    58,
+                    61,
+                    66,
+                    71,
+                    72,
+                    73,
+                    74,
+                    75,
+                    76,
+                    79,
+                    81,
+                    82,
+                    83,
+                    85,
+                    86,
+                    93,
+                    97,
+                    99,
+                    100,
+                    105,
+                    107,
+                    108,
+                    111,
+                    115,
+                    116,
+                    118,
+                    121,
+                    125,
+                    126,
+                    129,
+                    133,
+                    137,
+                    141,
+                    142,
+                    143,
+                    144,
+                    150,
+                    151,
+                    153,
+                    154,
+                    159,
+                    163,
+                    168,
+                    172,
+                    174,
+                    176,
+                    177,
+                    178,
+                    180,
+                    182,
+                    183,
+                    184,
+                    185,
+                    186,
+                    192,
+                    195,
+                    196
+                ],
+                39
+            ],
+            "output": 8
+        },
+        {
+            "input": [
+                [
+                    3,
+                    5,
+                    7,
+                    8,
+                    9,
+                    10,
+                    11,
+                    12,
+                    13,
+                    14,
+                    16,
+                    18,
+                    19,
+                    20,
+                    24,
+                    26,
+                    27,
+                    28,
+                    29,
+                    30,
+                    34,
+                    35,
+                    37,
+                    38,
+                    40,
+                    41,
+                    42,
+                    44,
+                    45,
+                    46,
+                    48,
+                    49,
+                    50,
+                    51,
+                    52,
+                    53,
+                    55,
+                    56,
+                    61,
+                    63,
+                    64,
+                    66,
+                    67,
+                    68,
+                    70,
+                    71,
+                    73,
+                    75,
+                    76,
+                    79,
+                    80,
+                    81,
+                    82,
+                    83,
+                    84,
+                    85,
+                    86,
+                    87,
+                    91,
+                    93,
+                    94,
+                    95,
+                    97,
+                    98,
+                    100,
+                    101,
+                    102,
+                    103,
+                    104,
+                    105,
+                    108,
+                    110,
+                    112,
+                    113,
+                    114,
+                    115,
+                    117,
+                    119,
+                    120,
+                    121,
+                    122,
+                    125,
+                    127,
+                    128,
+                    129,
+                    130,
+                    131,
+                    132,
+                    134,
+                    136,
+                    137,
+                    138,
+                    144,
+                    145,
+                    146,
+                    147,
+                    148,
+                    149,
+                    150,
+                    154,
+                    156,
+                    158,
+                    161,
+                    162,
+                    164,
+                    165,
+                    167,
+                    168,
+                    169,
+                    171,
+                    173,
+                    174,
+                    175,
+                    176,
+                    178,
+                    179,
+                    182,
+                    184,
+                    185,
+                    186,
+                    188,
+                    189,
+                    190,
+                    191,
+                    192,
+                    193,
+                    194,
+                    195,
+                    196,
+                    197,
+                    198,
+                    200
+                ],
+                8
+            ],
+            "output": 47
+        },
+        {
+            "input": [
+                [
+                    0,
+                    1,
+                    3,
+                    4,
+                    5,
+                    6,
+                    7,
+                    8,
+                    9,
+                    11,
+                    12,
+                    13,
+                    15,
+                    16,
+                    17,
+                    18,
+                    19,
+                    20,
+                    27,
+                    30,
+                    32,
+                    34,
+                    35,
+                    36,
+                    37,
+                    39,
+                    43,
+                    45,
+                    46,
+                    47,
+                    48,
+                    50,
+                    51,
+                    52,
+                    53,
+                    55,
+                    56,
+                    57,
+                    58,
+                    60,
+                    61,
+                    62,
+                    64,
+                    65,
+                    66,
+                    67,
+                    68,
+                    69,
+                    70,
+                    72,
+                    73,
+                    74,
+                    76,
+                    77,
+                    78,
+                    79,
+                    80,
+                    81,
+                    82,
+                    83,
+                    84,
+                    85,
+                    86,
+                    88,
+                    90,
+                    91,
+                    92,
+                    93,
+                    95,
+                    96,
+                    97,
+                    98,
+                    99,
+                    100,
+                    101,
+                    102,
+                    103,
+                    105,
+                    107,
+                    108,
+                    110,
+                    111,
+                    112,
+                    113,
+                    115,
+                    116,
+                    117,
+                    118,
+                    120,
+                    121,
+                    122,
+                    125,
+                    127,
+                    128,
+                    131,
+                    132,
+                    134,
+                    137,
+                    138,
+                    139,
+                    140,
+                    141,
+                    142,
+                    143,
+                    145,
+                    146,
+                    149,
+                    152,
+                    153,
+                    154,
+                    155,
+                    156,
+                    158,
+                    160,
+                    161,
+                    165,
+                    167,
+                    171,
+                    173,
+                    174,
+                    175,
+                    177,
+                    178,
+                    179,
+                    182,
+                    183,
+                    184,
+                    185,
+                    187,
+                    190,
+                    191,
+                    194,
+                    195,
+                    197
+                ],
+                15
+            ],
+            "output": 61
+        },
+        {
+            "input": [
+                [
+                    4,
+                    9,
+                    10,
+                    13,
+                    16,
+                    17,
+                    18,
+                    20,
+                    21,
+                    22,
+                    25,
+                    26,
+                    27,
+                    35,
+                    36,
+                    41,
+                    43,
+                    44,
+                    47,
+                    48,
+                    51,
+                    52,
+                    56,
+                    57,
+                    64,
+                    65,
+                    69,
+                    71,
+                    73,
+                    76,
+                    78,
+                    79,
+                    80,
+                    81,
+                    85,
+                    86,
+                    87,
+                    88,
+                    90,
+                    91,
+                    92,
+                    98,
+                    101,
+                    102,
+                    108,
+                    109,
+                    111,
+                    112,
+                    113,
+                    126,
+                    128,
+                    129,
+                    130,
+                    131,
+                    133,
+                    135,
+                    139,
+                    141,
+                    149,
+                    155,
+                    156,
+                    162,
+                    163,
+                    164,
+                    165,
+                    167,
+                    168,
+                    169,
+                    170,
+                    172,
+                    173,
+                    174,
+                    175,
+                    176,
+                    179,
+                    182,
+                    183,
+                    187,
+                    191,
+                    192,
+                    194,
+                    195,
+                    196,
+                    197,
+                    198
+                ],
+                6
+            ],
+            "output": 14
+        },
+        {
+            "input": [
+                [
+                    0,
+                    1,
+                    2,
+                    3,
+                    4,
+                    5,
+                    11,
+                    13,
+                    15,
+                    18,
+                    20,
+                    22,
+                    23,
+                    25,
+                    26,
+                    28,
+                    32,
+                    34,
+                    36,
+                    39,
+                    41,
+                    43,
+                    51,
+                    52,
+                    53,
+                    54,
+                    55,
+                    59,
+                    62,
+                    69,
+                    70,
+                    72,
+                    76,
+                    77,
+                    78,
+                    81,
+                    83,
+                    86,
+                    89,
+                    90,
+                    91,
+                    94,
+                    95,
+                    97,
+                    98,
+                    100,
+                    104,
+                    108,
+                    109,
+                    110,
+                    111,
+                    115,
+                    116,
+                    119,
+                    122,
+                    125,
+                    126,
+                    127,
+                    130,
+                    132,
+                    134,
+                    138,
+                    139,
+                    141,
+                    142,
+                    148,
+                    149,
+                    152,
+                    153,
+                    154,
+                    155,
+                    158,
+                    159,
+                    161,
+                    162,
+                    163,
+                    164,
+                    167,
+                    169,
+                    170,
+                    175,
+                    179,
+                    182,
+                    184,
+                    189,
+                    192,
+                    193,
+                    194,
+                    199,
+                    200
+                ],
+                6
+            ],
+            "output": 14
+        },
+        {
+            "input": [
+                [
+                    1,
+                    2,
+                    6,
+                    30,
+                    43,
+                    47,
+                    48,
+                    50,
+                    52,
+                    55,
+                    60,
+                    63,
+                    71,
+                    72,
+                    78,
+                    81,
+                    84,
+                    87,
+                    96,
+                    97,
+                    117,
+                    125,
+                    126,
+                    137,
+                    142,
+                    154,
+                    167,
+                    172,
+                    174,
+                    178,
+                    180,
+                    197,
+                    200
+                ],
+                20
+            ],
+            "output": 1
+        },
+        {
+            "input": [
+                [
+                    1,
+                    2,
+                    5,
+                    8,
+                    11,
+                    12,
+                    14,
+                    15,
+                    17,
+                    18,
+                    21,
+                    23,
+                    24,
+                    25,
+                    26,
+                    28,
+                    29,
+                    32,
+                    33,
+                    34,
+                    35,
+                    36,
+                    37,
+                    38,
+                    39,
+                    42,
+                    48,
+                    49,
+                    50,
+                    51,
+                    52,
+                    53,
+                    55,
+                    56,
+                    58,
+                    61,
+                    64,
+                    65,
+                    66,
+                    67,
+                    68,
+                    69,
+                    73,
+                    74,
+                    75,
+                    76,
+                    77,
+                    82,
+                    86,
+                    87,
+                    90,
+                    91,
+                    92,
+                    93,
+                    96,
+                    97,
+                    100,
+                    109,
+                    110,
+                    111,
+                    112,
+                    113,
+                    118,
+                    121,
+                    122,
+                    123,
+                    124,
+                    125,
+                    126,
+                    129,
+                    131,
+                    132,
+                    133,
+                    135,
+                    136,
+                    137,
+                    138,
+                    141,
+                    142,
+                    143,
+                    146,
+                    149,
+                    151,
+                    152,
+                    154,
+                    155,
+                    158,
+                    159,
+                    162,
+                    163,
+                    167,
+                    168,
+                    169,
+                    171,
+                    172,
+                    175,
+                    179,
+                    180,
+                    182,
+                    183,
+                    184,
+                    185,
+                    186,
+                    188,
+                    190,
+                    193,
+                    194,
+                    195,
+                    196,
+                    197,
+                    199,
+                    200
+                ],
+                21
+            ],
+            "output": 26
+        }
+    ],
+    "haskell_template": "arithmeticTriplets :: [Int] -> Int -> Int\narithmeticTriplets nums diff ",
+    "ocaml_template": "let arithmeticTriplets (nums: int list) (diff: int) : int =  ",
+    "scala_template": "def arithmeticTriplets(nums: List[Int],diff: Int): Int = { \n    \n}",
+    "java_template": "public static int arithmeticTriplets(List<Integer> nums, int diff) {\n\n}",
+    "python_template": "class Solution(object):\n    def arithmeticTriplets(self, nums, diff):\n        \"\"\"\n        :type nums: List[int]\n        :type diff: int\n        :rtype: int\n        \"\"\"\n        "
+}

number_of_arithmetic_triplets/ocaml_tests/main.ml

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

number_of_arithmetic_triplets/scala_tests/MySuite.scala

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

number_of_beautiful_pairs/haskell_tests/Main.hs

@@ -0,0 +1,41 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+countBeautifulPairs :: [Int] -> Int
+countBeautifulPairs nums = undefined
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (countBeautifulPairs [2,5,1,4])," 5 (countBeautifulPairs [2,5,1,4]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (countBeautifulPairs [11,21,12])," 2 (countBeautifulPairs [11,21,12]))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (countBeautifulPairs [2589, 416, 8132, 718, 9296, 3306, 1258, 8493, 1081, 7335, 9952, 3791, 8418, 3107, 9602, 9979, 4154, 3791, 5243, 4278, 1189, 7207, 4406, 6321, 5226, 7348, 3865, 8301, 9139, 5746, 1283, 8812, 2881, 337, 2335, 8802, 8946, 3125, 744, 905, 5149, 3537, 6498, 6152, 593, 6293, 7359, 1844, 3987, 8635, 9905, 895, 6266, 4775, 2063, 2691, 2218, 2928, 3723, 4926, 3441, 8752, 2078, 909, 2971, 5621, 7526, 6575, 5619, 6609, 7137, 2353, 2725, 986, 1868, 7714, 887, 1386, 1659, 6762, 4999, 4188, 999, 2725, 8302, 8059, 2171, 9442, 5471, 8592, 8029])," 2799 (countBeautifulPairs [2589, 416, 8132, 718, 9296, 3306, 1258, 8493, 1081, 7335, 9952, 3791, 8418, 3107, 9602, 9979, 4154, 3791, 5243, 4278, 1189, 7207, 4406, 6321, 5226, 7348, 3865, 8301, 9139, 5746, 1283, 8812, 2881, 337, 2335, 8802, 8946, 3125, 744, 905, 5149, 3537, 6498, 6152, 593, 6293, 7359, 1844, 3987, 8635, 9905, 895, 6266, 4775, 2063, 2691, 2218, 2928, 3723, 4926, 3441, 8752, 2078, 909, 2971, 5621, 7526, 6575, 5619, 6609, 7137, 2353, 2725, 986, 1868, 7714, 887, 1386, 1659, 6762, 4999, 4188, 999, 2725, 8302, 8059, 2171, 9442, 5471, 8592, 8029]))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (countBeautifulPairs [9568, 4468, 6126, 5827, 5061, 3927, 7924, 4233, 9149, 6096, 5542, 183, 1587, 5744, 2683, 2566, 3399, 5854, 2663, 5104, 5289, 8874, 4732, 2438, 1737, 2118, 888, 774, 7576, 9899, 7321, 8013, 5756, 1543, 8629, 6545, 661, 6765, 1825, 4298, 1203, 9153, 3962, 8294, 4541, 1505, 1348, 2182, 4861, 7515, 2859, 7268, 6582, 3294, 263, 8667])," 1093 (countBeautifulPairs [9568, 4468, 6126, 5827, 5061, 3927, 7924, 4233, 9149, 6096, 5542, 183, 1587, 5744, 2683, 2566, 3399, 5854, 2663, 5104, 5289, 8874, 4732, 2438, 1737, 2118, 888, 774, 7576, 9899, 7321, 8013, 5756, 1543, 8629, 6545, 661, 6765, 1825, 4298, 1203, 9153, 3962, 8294, 4541, 1505, 1348, 2182, 4861, 7515, 2859, 7268, 6582, 3294, 263, 8667]))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (countBeautifulPairs [189, 1442, 1025, 5855, 2345, 7697, 9091, 8139, 3813, 2638, 9984, 7324, 723, 4521, 9206, 6646, 6567, 1667, 8443, 7935, 6515, 566, 1857, 3678, 1117, 1998, 3079, 1483])," 282 (countBeautifulPairs [189, 1442, 1025, 5855, 2345, 7697, 9091, 8139, 3813, 2638, 9984, 7324, 723, 4521, 9206, 6646, 6567, 1667, 8443, 7935, 6515, 566, 1857, 3678, 1117, 1998, 3079, 1483]))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (countBeautifulPairs [653, 7825, 2553, 3689, 7419, 1163, 8588, 239, 405, 4959, 1807, 7928, 3256, 5039, 7751, 1116, 3345, 6622, 1096, 3931, 1107, 3108, 1593, 3615, 2174, 7029, 9643, 2594, 1104, 5459, 1439, 4276, 2173, 8319, 5332, 8338, 9921, 2999, 8215, 3639, 1518, 6172, 4704, 6049, 9599, 1274, 7894, 8023, 1753, 9189, 9743, 6413, 6424, 3327, 3085, 9488, 3903, 6248, 6517, 2345, 8434, 9285, 5527, 7809, 23, 5579])," 1543 (countBeautifulPairs [653, 7825, 2553, 3689, 7419, 1163, 8588, 239, 405, 4959, 1807, 7928, 3256, 5039, 7751, 1116, 3345, 6622, 1096, 3931, 1107, 3108, 1593, 3615, 2174, 7029, 9643, 2594, 1104, 5459, 1439, 4276, 2173, 8319, 5332, 8338, 9921, 2999, 8215, 3639, 1518, 6172, 4704, 6049, 9599, 1274, 7894, 8023, 1753, 9189, 9743, 6413, 6424, 3327, 3085, 9488, 3903, 6248, 6517, 2345, 8434, 9285, 5527, 7809, 23, 5579]))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (countBeautifulPairs [8509, 4764, 273, 3519, 5629, 3926, 2559, 6048, 8119, 6751, 3433, 1296, 473, 5707, 449, 5347, 1003, 1078, 9882, 5835, 6132, 8925, 9168, 3645, 9618, 5303, 4033, 2144, 7251, 5381, 3153, 3734, 3081, 3949, 6464, 4827, 6547, 3251, 6987, 3759, 638, 5329, 473, 2389, 1806, 6956, 7795, 7998, 7852, 1614, 2161, 2701, 7735, 6296, 1112, 3958, 251, 1167, 574, 6005, 2636, 2776, 8183, 7834, 3445, 1957, 8008, 6552, 2985, 3612])," 1620 (countBeautifulPairs [8509, 4764, 273, 3519, 5629, 3926, 2559, 6048, 8119, 6751, 3433, 1296, 473, 5707, 449, 5347, 1003, 1078, 9882, 5835, 6132, 8925, 9168, 3645, 9618, 5303, 4033, 2144, 7251, 5381, 3153, 3734, 3081, 3949, 6464, 4827, 6547, 3251, 6987, 3759, 638, 5329, 473, 2389, 1806, 6956, 7795, 7998, 7852, 1614, 2161, 2701, 7735, 6296, 1112, 3958, 251, 1167, 574, 6005, 2636, 2776, 8183, 7834, 3445, 1957, 8008, 6552, 2985, 3612]))
+
+
+-- 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_beautiful_pairs/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(5, countBeautifulPairs(Arrays.asList(2,5,1,4)));
+}
+@Test
+public void test2() {
+    assertEquals(2, countBeautifulPairs(Arrays.asList(11,21,12)));
+}
+
+}

number_of_beautiful_pairs/meta.json

@@ -0,0 +1,363 @@
+{
+    "id": 2831,
+    "name": "number_of_beautiful_pairs",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/number-of-beautiful-pairs/",
+    "date": "2023-06-18 00:00:00",
+    "task_description": "You are given a **0-indexed **integer array `nums`. A pair of indices `i`, `j` where `0 <= i < j < nums.length` is called beautiful if the **first digit** of `nums[i]` and the **last digit** of `nums[j]` are **coprime**. Return _the total number of beautiful pairs in _`nums`. Two integers `x` and `y` are **coprime** if there is no integer greater than 1 that divides both of them. In other words, `x` and `y` are coprime if `gcd(x, y) == 1`, where `gcd(x, y)` is the **greatest common divisor** of `x` and `y`. **Example 1:** ``` **Input:** nums = [2,5,1,4] **Output:** 5 **Explanation:** There are 5 beautiful pairs in nums: When i = 0 and j = 1: the first digit of nums[0] is 2, and the last digit of nums[1] is 5. We can confirm that 2 and 5 are coprime, since gcd(2,5) == 1. When i = 0 and j = 2: the first digit of nums[0] is 2, and the last digit of nums[2] is 1. Indeed, gcd(2,1) == 1. When i = 1 and j = 2: the first digit of nums[1] is 5, and the last digit of nums[2] is 1. Indeed, gcd(5,1) == 1. When i = 1 and j = 3: the first digit of nums[1] is 5, and the last digit of nums[3] is 4. Indeed, gcd(5,4) == 1. When i = 2 and j = 3: the first digit of nums[2] is 1, and the last digit of nums[3] is 4. Indeed, gcd(1,4) == 1. Thus, we return 5. ``` **Example 2:** ``` **Input:** nums = [11,21,12] **Output:** 2 **Explanation:** There are 2 beautiful pairs: When i = 0 and j = 1: the first digit of nums[0] is 1, and the last digit of nums[1] is 1. Indeed, gcd(1,1) == 1. When i = 0 and j = 2: the first digit of nums[0] is 1, and the last digit of nums[2] is 2. Indeed, gcd(1,2) == 1. Thus, we return 2. ``` **Constraints:** `2 <= nums.length <= 100` `1 <= nums[i] <= 9999` `nums[i] % 10 != 0`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "nums = [2,5,1,4]",
+            "output": "5 "
+        },
+        {
+            "label": "Example 2",
+            "input": "nums = [11,21,12]",
+            "output": "2 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                2589,
+                416,
+                8132,
+                718,
+                9296,
+                3306,
+                1258,
+                8493,
+                1081,
+                7335,
+                9952,
+                3791,
+                8418,
+                3107,
+                9602,
+                9979,
+                4154,
+                3791,
+                5243,
+                4278,
+                1189,
+                7207,
+                4406,
+                6321,
+                5226,
+                7348,
+                3865,
+                8301,
+                9139,
+                5746,
+                1283,
+                8812,
+                2881,
+                337,
+                2335,
+                8802,
+                8946,
+                3125,
+                744,
+                905,
+                5149,
+                3537,
+                6498,
+                6152,
+                593,
+                6293,
+                7359,
+                1844,
+                3987,
+                8635,
+                9905,
+                895,
+                6266,
+                4775,
+                2063,
+                2691,
+                2218,
+                2928,
+                3723,
+                4926,
+                3441,
+                8752,
+                2078,
+                909,
+                2971,
+                5621,
+                7526,
+                6575,
+                5619,
+                6609,
+                7137,
+                2353,
+                2725,
+                986,
+                1868,
+                7714,
+                887,
+                1386,
+                1659,
+                6762,
+                4999,
+                4188,
+                999,
+                2725,
+                8302,
+                8059,
+                2171,
+                9442,
+                5471,
+                8592,
+                8029
+            ],
+            "output": 2799
+        },
+        {
+            "input": [
+                9568,
+                4468,
+                6126,
+                5827,
+                5061,
+                3927,
+                7924,
+                4233,
+                9149,
+                6096,
+                5542,
+                183,
+                1587,
+                5744,
+                2683,
+                2566,
+                3399,
+                5854,
+                2663,
+                5104,
+                5289,
+                8874,
+                4732,
+                2438,
+                1737,
+                2118,
+                888,
+                774,
+                7576,
+                9899,
+                7321,
+                8013,
+                5756,
+                1543,
+                8629,
+                6545,
+                661,
+                6765,
+                1825,
+                4298,
+                1203,
+                9153,
+                3962,
+                8294,
+                4541,
+                1505,
+                1348,
+                2182,
+                4861,
+                7515,
+                2859,
+                7268,
+                6582,
+                3294,
+                263,
+                8667
+            ],
+            "output": 1093
+        },
+        {
+            "input": [
+                189,
+                1442,
+                1025,
+                5855,
+                2345,
+                7697,
+                9091,
+                8139,
+                3813,
+                2638,
+                9984,
+                7324,
+                723,
+                4521,
+                9206,
+                6646,
+                6567,
+                1667,
+                8443,
+                7935,
+                6515,
+                566,
+                1857,
+                3678,
+                1117,
+                1998,
+                3079,
+                1483
+            ],
+            "output": 282
+        },
+        {
+            "input": [
+                653,
+                7825,
+                2553,
+                3689,
+                7419,
+                1163,
+                8588,
+                239,
+                405,
+                4959,
+                1807,
+                7928,
+                3256,
+                5039,
+                7751,
+                1116,
+                3345,
+                6622,
+                1096,
+                3931,
+                1107,
+                3108,
+                1593,
+                3615,
+                2174,
+                7029,
+                9643,
+                2594,
+                1104,
+                5459,
+                1439,
+                4276,
+                2173,
+                8319,
+                5332,
+                8338,
+                9921,
+                2999,
+                8215,
+                3639,
+                1518,
+                6172,
+                4704,
+                6049,
+                9599,
+                1274,
+                7894,
+                8023,
+                1753,
+                9189,
+                9743,
+                6413,
+                6424,
+                3327,
+                3085,
+                9488,
+                3903,
+                6248,
+                6517,
+                2345,
+                8434,
+                9285,
+                5527,
+                7809,
+                23,
+                5579
+            ],
+            "output": 1543
+        },
+        {
+            "input": [
+                8509,
+                4764,
+                273,
+                3519,
+                5629,
+                3926,
+                2559,
+                6048,
+                8119,
+                6751,
+                3433,
+                1296,
+                473,
+                5707,
+                449,
+                5347,
+                1003,
+                1078,
+                9882,
+                5835,
+                6132,
+                8925,
+                9168,
+                3645,
+                9618,
+                5303,
+                4033,
+                2144,
+                7251,
+                5381,
+                3153,
+                3734,
+                3081,
+                3949,
+                6464,
+                4827,
+                6547,
+                3251,
+                6987,
+                3759,
+                638,
+                5329,
+                473,
+                2389,
+                1806,
+                6956,
+                7795,
+                7998,
+                7852,
+                1614,
+                2161,
+                2701,
+                7735,
+                6296,
+                1112,
+                3958,
+                251,
+                1167,
+                574,
+                6005,
+                2636,
+                2776,
+                8183,
+                7834,
+                3445,
+                1957,
+                8008,
+                6552,
+                2985,
+                3612
+            ],
+            "output": 1620
+        }
+    ],
+    "haskell_template": "countBeautifulPairs :: [Int] -> Int\ncountBeautifulPairs nums ",
+    "ocaml_template": "let countBeautifulPairs (nums: int list) : int =  ",
+    "scala_template": "def countBeautifulPairs(nums: List[Int]): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public int countBeautifulPairs(int[] nums) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def countBeautifulPairs(self, nums):\n        \"\"\"\n        :type nums: List[int]\n        :rtype: int\n        \"\"\"\n        "
+}

number_of_beautiful_pairs/ocaml_tests/main.ml

@@ -0,0 +1,42 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+    let countBeautifulPairs (nums: int list) : int =   failwith "Not implemented"
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 5 (countBeautifulPairs [2;5;1;4])
+
+let test2 _ = assert_equal 2 (countBeautifulPairs [11;21;12])
+
+let test3 _ = assert_equal 2 (countBeautifulPairs [2589; 416; 8132; 718; 9296; 3306; 1258; 8493; 1081; 7335; 9952; 3791; 8418; 3107; 9602; 9979; 4154; 3791; 5243; 4278; 1189; 7207; 4406; 6321; 5226; 7348; 3865; 8301; 9139; 5746; 1283; 8812; 2881; 337; 2335; 8802; 8946; 3125; 744; 905; 5149; 3537; 6498; 6152; 593; 6293; 7359; 1844; 3987; 8635; 9905; 895; 6266; 4775; 2063; 2691; 2218; 2928; 3723; 4926; 3441; 8752; 2078; 909; 2971; 5621; 7526; 6575; 5619; 6609; 7137; 2353; 2725; 986; 1868; 7714; 887; 1386; 1659; 6762; 4999; 4188; 999; 2725; 8302; 8059; 2171; 9442; 5471; 8592; 8029])
+
+let test4 _ = assert_equal 2 (countBeautifulPairs [9568; 4468; 6126; 5827; 5061; 3927; 7924; 4233; 9149; 6096; 5542; 183; 1587; 5744; 2683; 2566; 3399; 5854; 2663; 5104; 5289; 8874; 4732; 2438; 1737; 2118; 888; 774; 7576; 9899; 7321; 8013; 5756; 1543; 8629; 6545; 661; 6765; 1825; 4298; 1203; 9153; 3962; 8294; 4541; 1505; 1348; 2182; 4861; 7515; 2859; 7268; 6582; 3294; 263; 8667])
+
+let test5 _ = assert_equal 2 (countBeautifulPairs [189; 1442; 1025; 5855; 2345; 7697; 9091; 8139; 3813; 2638; 9984; 7324; 723; 4521; 9206; 6646; 6567; 1667; 8443; 7935; 6515; 566; 1857; 3678; 1117; 1998; 3079; 1483])
+
+let test6 _ = assert_equal 2 (countBeautifulPairs [653; 7825; 2553; 3689; 7419; 1163; 8588; 239; 405; 4959; 1807; 7928; 3256; 5039; 7751; 1116; 3345; 6622; 1096; 3931; 1107; 3108; 1593; 3615; 2174; 7029; 9643; 2594; 1104; 5459; 1439; 4276; 2173; 8319; 5332; 8338; 9921; 2999; 8215; 3639; 1518; 6172; 4704; 6049; 9599; 1274; 7894; 8023; 1753; 9189; 9743; 6413; 6424; 3327; 3085; 9488; 3903; 6248; 6517; 2345; 8434; 9285; 5527; 7809; 23; 5579])
+
+let test7 _ = assert_equal 2 (countBeautifulPairs [8509; 4764; 273; 3519; 5629; 3926; 2559; 6048; 8119; 6751; 3433; 1296; 473; 5707; 449; 5347; 1003; 1078; 9882; 5835; 6132; 8925; 9168; 3645; 9618; 5303; 4033; 2144; 7251; 5381; 3153; 3734; 3081; 3949; 6464; 4827; 6547; 3251; 6987; 3759; 638; 5329; 473; 2389; 1806; 6956; 7795; 7998; 7852; 1614; 2161; 2701; 7735; 6296; 1112; 3958; 251; 1167; 574; 6005; 2636; 2776; 8183; 7834; 3445; 1957; 8008; 6552; 2985; 3612])
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for countBeautifulPairs" >::: [
+        
+  "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_beautiful_pairs/scala_tests/MySuite.scala

@@ -0,0 +1,32 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.countBeautifulPairs(List(2,5,1,4)), 5)
+  }
+
+  test("test2") {
+    assertEquals(Main.countBeautifulPairs(List(11,21,12)), 2)
+  }
+
+  test("test3") {
+    assertEquals(Main.countBeautifulPairs(2589,416,8132,718,9296,3306,1258,8493,1081,7335,9952,3791,8418,3107,9602,9979,4154,3791,5243,4278,1189,7207,4406,6321,5226,7348,3865,8301,9139,5746,1283,8812,2881,337,2335,8802,8946,3125,744,905,5149,3537,6498,6152,593,6293,7359,1844,3987,8635,9905,895,6266,4775,2063,2691,2218,2928,3723,4926,3441,8752,2078,909,2971,5621,7526,6575,5619,6609,7137,2353,2725,986,1868,7714,887,1386,1659,6762,4999,4188,999,2725,8302,8059,2171,9442,5471,8592,8029), 2799)
+  }
+
+  test("test4") {
+    assertEquals(Main.countBeautifulPairs(9568,4468,6126,5827,5061,3927,7924,4233,9149,6096,5542,183,1587,5744,2683,2566,3399,5854,2663,5104,5289,8874,4732,2438,1737,2118,888,774,7576,9899,7321,8013,5756,1543,8629,6545,661,6765,1825,4298,1203,9153,3962,8294,4541,1505,1348,2182,4861,7515,2859,7268,6582,3294,263,8667), 1093)
+  }
+
+  test("test5") {
+    assertEquals(Main.countBeautifulPairs(189,1442,1025,5855,2345,7697,9091,8139,3813,2638,9984,7324,723,4521,9206,6646,6567,1667,8443,7935,6515,566,1857,3678,1117,1998,3079,1483), 282)
+  }
+
+  test("test6") {
+    assertEquals(Main.countBeautifulPairs(653,7825,2553,3689,7419,1163,8588,239,405,4959,1807,7928,3256,5039,7751,1116,3345,6622,1096,3931,1107,3108,1593,3615,2174,7029,9643,2594,1104,5459,1439,4276,2173,8319,5332,8338,9921,2999,8215,3639,1518,6172,4704,6049,9599,1274,7894,8023,1753,9189,9743,6413,6424,3327,3085,9488,3903,6248,6517,2345,8434,9285,5527,7809,23,5579), 1543)
+  }
+
+  test("test7") {
+    assertEquals(Main.countBeautifulPairs(8509,4764,273,3519,5629,3926,2559,6048,8119,6751,3433,1296,473,5707,449,5347,1003,1078,9882,5835,6132,8925,9168,3645,9618,5303,4033,2144,7251,5381,3153,3734,3081,3949,6464,4827,6547,3251,6987,3759,638,5329,473,2389,1806,6956,7795,7998,7852,1614,2161,2701,7735,6296,1112,3958,251,1167,574,6005,2636,2776,8183,7834,3445,1957,8008,6552,2985,3612), 1620)
+  }
+
+}

number_of_beautiful_partitions/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 (beautifulPartitions \"23542185131 \" 3 2)," 3 (beautifulPartitions "23542185131" 3 2))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (beautifulPartitions \"23542185131 \" 3 3)," 1 (beautifulPartitions "23542185131" 3 3))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (beautifulPartitions \"3312958 \" 3 1)," 1 (beautifulPartitions "3312958" 3 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_beautiful_partitions/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, beautifulPartitions("23542185131", 3, 2));
+}
+@Test
+public void test2() {
+    assertEquals(1, beautifulPartitions("23542185131", 3, 3));
+}
+@Test
+public void test3() {
+    assertEquals(1, beautifulPartitions("3312958", 3, 1));
+}
+
+}

number_of_beautiful_partitions/meta.json

@@ -0,0 +1,112 @@
+{
+    "id": 2569,
+    "name": "number_of_beautiful_partitions",
+    "difficulty": "Hard",
+    "link": "https://leetcode.com/problems/number-of-beautiful-partitions/",
+    "date": "1668297600000",
+    "task_description": "You are given a string `s` that consists of the digits `'1'` to `'9'` and two integers `k` and `minLength`. A partition of `s` is called **beautiful** if: `s` is partitioned into `k` non-intersecting substrings. Each substring has a length of **at least** `minLength`. Each substring starts with a **prime** digit and ends with a **non-prime** digit. Prime digits are `'2'`, `'3'`, `'5'`, and `'7'`, and the rest of the digits are non-prime. Return_ the number of **beautiful** partitions of _`s`. Since the answer may be very large, return it **modulo** `109 + 7`. A **substring** is a contiguous sequence of characters within a string. **Example 1:** ``` **Input:** s = \"23542185131\", k = 3, minLength = 2 **Output:** 3 **Explanation:** There exists three ways to create a beautiful partition: \"2354 | 218 | 5131\" \"2354 | 21851 | 31\" \"2354218 | 51 | 31\" ``` **Example 2:** ``` **Input:** s = \"23542185131\", k = 3, minLength = 3 **Output:** 1 **Explanation:** There exists one way to create a beautiful partition: \"2354 | 218 | 5131\". ``` **Example 3:** ``` **Input:** s = \"3312958\", k = 3, minLength = 1 **Output:** 1 **Explanation:** There exists one way to create a beautiful partition: \"331 | 29 | 58\". ``` **Constraints:** `1 <= k, minLength <= s.length <= 1000` `s` consists of the digits `'1'` to `'9'`.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "s = \"23542185131\", k = 3, minLength = 2",
+            "output": "3 "
+        },
+        {
+            "label": "Example 2",
+            "input": "s = \"23542185131\", k = 3, minLength = 3",
+            "output": "1 "
+        },
+        {
+            "label": "Example 3",
+            "input": "s = \"3312958\", k = 3, minLength = 1",
+            "output": "1 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                "\"14799179822947387567455836795857273593595986592183174998186383617155757615165219562745715618363564416866256857346664971994581168562161134755327898238989757536575198627339888872545443114569548664476114554614822567193653822772113267248174758776346616361269457898478639729515796948743828638\"",
+                99,
+                245
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                "\"437413949498186333477426462641925582785215862448125617372236591189521623484143958327529223637565882789426899277231833279\"",
+                115,
+                10
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                "\"4317464565679651432381413965496285922397668489668864289414635592671162684579677472769267969378545694812183389661351128961842938725173797677572217831772321387499184825854183241997222472419869655463597816493381722557168513874646271199512517977789678214116858557468664331617426249492113964256627394539656557932324391233123995155846379892261542364671395148481322154476251168341752122693179681719275532315973853515946742385986285946536836733546929132869272179899918397699873885484239945613425349893428491566387812141493752433382356485311469983999892834754616362584427525172113116231866779768883659624\"",
+                174,
+                453
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                "\"752484597635819885466173664323492448318426544719225461993814875643828258657314397983449137779812248721467465214131488167752381573876277\"",
+                111,
+                65
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                "\"48359691625839758295964818438679133746447965232248315673424352474779448337347375542985175738951499874873437279656817578173821482974683888288173248661699546629929964986523257417638726347916157525995599861843191277281883946574544211555554478323748483525656185555159255888371637118225814236726819442341127516571966268549383649148839744185125175354986638498386138458956245874881213834795968819149149922947529967921453155853638252655985271148444825774883464755285738733634648424532651335142316473128813271378944262679172686139635762766618627228736156679398158569317485328272362255712775655492558749927867899385288651778697431871859918563373827919321616351261878192938748933359159461513342567817188888591467542994118697566218417583596377369356327137497992633678993143494499881787833848696748519513283588572341353841656366151271631875124172946479491499529811241763158663647783428523421226436826767922459936489874279574589431871757993263986932973697126651956463459339581658145856\"",
+                721,
+                715
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                "\"161857729969633326821811535419926225618462693999241129297549533741613354959365886839447674342579689415912341157183828996529725545133617189616439214283494612873651824875838628143534238376133511536619681663749371184269791669671789498544421692693889264967711232162234989979657895652186162884219851256934748375553165459348439773818117783649676292665457835285577386682671841931267636821122436437575732188258323835393175829443647514715385268576464578324299743859138397\"",
+                44,
+                116
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                "536399865312865746346883626876294519957394812233833731842513577957766393183336319162828274794785845734514844964876286757994776477661652762688721211623223779895947338966639188197984529824649453335767694346578872465794867515196633481198517157732651349722625437587553291238694957626222725287493864149564114548734781726711634786883855784792731279128134549185979661894239565376747831958625339688682476245463844686329592637152435914872186542139126377",
+                183,
+                65
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                "318673251546382596981292699892567635383987323833663734628672772649445225372495264632178416897595573549165787586264455282993176587815647253151815979239453847349868837623822539479837944256766785157616234149611857163676943333258428256589937415638565968699766882379861136459436211549612533623781767249914622992777473257148568616513571553975715735193181388599559786226918446457796857185943843582581175815992988476896385511853343292218426772717723125995547439939225585764131813553444848345697161145274766516219551855943536299359122567541657967543136869134878252234479397966753368324631823194754122242845",
+                208,
+                113
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                "525993424367234273654971645999936994675566426342215492474724183169338911762181887973113695341239564324314554592221258562558699177437138559743969229517863324918276756373147121685748245655354855416846661188663676343643156539534227411912412634811922563735437282753685119769962718897353692521147994656323966882925912354931643242996199289764826311419319924866352211249715315792332279653518254867329472398672686732682682288426177464742391999165498766735951281381696581591371464372786847559224356635764966875277459123881852635267646656639942318999721741682871139412723261187825253386674573166737882585494983731632729823694149968219895589812486639867186826624341142646383114158368648872957356951177916984959889458975364979479214978495963161236898356999451195815926813381538562538126973265494468464261722495999325829415127857461728632166",
+                807,
+                167
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                "963821256231166116482823877934857616699335845916597266191655729224666522116975714748144711718399966176218544282298499835735687223436587969163928315918712734938123511143836691868293181539427913115648346479487728662771158652643735998314578795435417223464469713758274986638183187997413357145624368923824329643844622765759556451832897121213983926562168432124216139487848338818281595251458257761987854948752636466976423841134388131117197966323119731427965529297616395817938834717826477749314566322889993287141562798951169373666899838542482273387719317929368385649217545337513194379918529252131581916916424194411946171837877661752886352532894699635259676138493333273476388",
+                70,
+                253
+            ],
+            "output": 0
+        }
+    ],
+    "haskell_template": "beautifulPartitions :: String -> Int -> Int -> Int\nbeautifulPartitions s k minLength ",
+    "ocaml_template": "let beautifulPartitions (s: string) (k: int) (minLength: int) : int =  ",
+    "scala_template": "def beautifulPartitions(s: String,k: Int,minLength: Int): Int = { \n    \n}",
+    "java_template": "public static int beautifulPartitions(String s, int k, int minLength) {\n\n}",
+    "python_template": "class Solution(object):\n    def beautifulPartitions(self, s, k, minLength):\n        \"\"\"\n        :type s: str\n        :type k: int\n        :type minLength: int\n        :rtype: int\n        \"\"\"\n        "
+}